From edb7ab468b0469ab1d1b3704cbbcf962332789e1 Mon Sep 17 00:00:00 2001 From: Mark Lobodzinski Date: Tue, 10 Apr 2018 14:01:13 -0600 Subject: repo: Delete loader, layers, tests files Change-Id: I28b8833df82946457325353cc03d3f91e6a776cf --- build_windows_targets.bat | 170 - layers/CMakeLists.txt | 233 - layers/README.md | 84 - layers/VkLayer_core_validation.def | 29 - layers/VkLayer_image.def | 29 - layers/VkLayer_object_tracker.def | 29 - layers/VkLayer_parameter_validation.def | 29 - layers/VkLayer_swapchain.def | 29 - layers/VkLayer_threading.def | 29 - layers/VkLayer_unique_objects.def | 29 - layers/buffer_validation.cpp | 4146 ------ layers/buffer_validation.h | 265 - layers/core_validation.cpp | 12868 ------------------- layers/core_validation.h | 167 - layers/core_validation_error_enums.h | 236 - layers/core_validation_layer.md | 44 - layers/core_validation_types.h | 953 -- layers/descriptor_sets.cpp | 2220 ---- layers/descriptor_sets.h | 581 - layers/hash_util.h | 164 - layers/hash_vk_types.h | 86 - layers/linux/VkLayer_core_validation.json | 43 - layers/linux/VkLayer_object_tracker.json | 29 - layers/linux/VkLayer_parameter_validation.json | 29 - layers/linux/VkLayer_standard_validation.json | 17 - layers/linux/VkLayer_threading.json | 17 - layers/linux/VkLayer_unique_objects.json | 11 - layers/macos/VkLayer_core_validation.json | 29 - layers/macos/VkLayer_device_simulation.json | 11 - layers/macos/VkLayer_object_tracker.json | 29 - layers/macos/VkLayer_parameter_validation.json | 29 - layers/macos/VkLayer_standard_validation.json | 17 - layers/macos/VkLayer_threading.json | 17 - layers/macos/VkLayer_unique_objects.json | 11 - layers/object_tracker.h | 296 - layers/object_tracker_layer.md | 12 - layers/object_tracker_utils.cpp | 1410 -- layers/old_vuid_to_new_mapping.txt | 3107 ----- layers/parameter_name.h | 148 - layers/parameter_validation.h | 912 -- layers/parameter_validation_layer.md | 8 - layers/parameter_validation_utils.cpp | 3093 ----- layers/shader_validation.cpp | 1728 --- layers/shader_validation.h | 200 - layers/threading.cpp | 566 - layers/threading.h | 431 - layers/threading_layer.md | 2 - layers/unique_objects.cpp | 990 -- layers/unique_objects.h | 135 - layers/unique_objects_layer.md | 7 - layers/vk_format_utils.cpp | 1084 -- layers/vk_format_utils.h | 166 - layers/vk_layer_config.cpp | 321 - layers/vk_layer_config.h | 72 - layers/vk_layer_data.h | 55 - layers/vk_layer_extension_utils.cpp | 66 - layers/vk_layer_extension_utils.h | 40 - layers/vk_layer_logging.h | 1133 -- layers/vk_layer_settings.txt | 81 - layers/vk_layer_table.cpp | 146 - layers/vk_layer_table.h | 51 - layers/vk_layer_utils.cpp | 207 - layers/vk_layer_utils.h | 125 - layers/vk_validation_error_database.txt | 3939 ------ layers/vk_validation_error_messages.h | 11826 ----------------- layers/vu_csv_stats.sh | 38 - layers/windows/VkLayer_core_validation.json | 38 - layers/windows/VkLayer_object_tracker.json | 29 - layers/windows/VkLayer_parameter_validation.json | 29 - layers/windows/VkLayer_standard_validation.json | 17 - layers/windows/VkLayer_threading.json | 17 - layers/windows/VkLayer_unique_objects.json | 11 - layers/xxhash.c | 888 -- layers/xxhash.h | 293 - loader/CMakeLists.txt | 307 - loader/LoaderAndLayerInterface.md | 2756 ---- loader/README.md | 8 - loader/asm_offset.c | 94 - loader/cJSON.c | 1215 -- loader/cJSON.h | 174 - loader/debug_utils.c | 1001 -- loader/debug_utils.h | 101 - loader/dev_ext_trampoline.c | 538 - loader/dirent_on_windows.c | 128 - loader/dirent_on_windows.h | 51 - loader/extension_manual.c | 362 - loader/extension_manual.h | 82 - loader/gpa_helper.h | 232 - loader/images/function_device_chain.png | Bin 115414 -> 0 bytes loader/images/function_device_chain_white.png | Bin 120563 -> 0 bytes loader/images/function_instance_chain.png | Bin 133822 -> 0 bytes loader/images/function_instance_chain_white.png | Bin 141522 -> 0 bytes loader/images/high_level_loader.png | Bin 92519 -> 0 bytes loader/images/high_level_loader_white.png | Bin 95728 -> 0 bytes loader/images/loader_device_chain_app.png | Bin 35095 -> 0 bytes loader/images/loader_device_chain_app_white.png | Bin 35776 -> 0 bytes loader/images/loader_device_chain_loader.png | Bin 38797 -> 0 bytes loader/images/loader_device_chain_loader_white.png | Bin 39680 -> 0 bytes loader/images/loader_instance_chain.png | Bin 49202 -> 0 bytes loader/images/loader_instance_chain_white.png | Bin 50324 -> 0 bytes loader/images/loader_layer_order.png | Bin 57064 -> 0 bytes loader/images/loader_layer_order_white.png | Bin 59335 -> 0 bytes loader/loader.aps | Bin 1920 -> 0 bytes loader/loader.c | 7055 ---------- loader/loader.h | 512 - loader/loader.rc | 98 - loader/loader_cmake_config.h.in | 2 - loader/murmurhash.c | 98 - loader/murmurhash.h | 52 - loader/phys_dev_ext.c | 1056 -- loader/trampoline.c | 2637 ---- loader/unknown_ext_chain.c | 819 -- loader/unknown_ext_chain_gas.asm | 873 -- loader/unknown_ext_chain_masm.asm | 883 -- loader/vk_loader_layer.h | 46 - loader/vk_loader_platform.h | 367 - loader/vulkan-1.def | 213 - loader/vulkan.pc.in | 12 - loader/wsi.c | 1791 --- loader/wsi.h | 166 - windowsRuntimeInstaller/ConfigureRT.vcxproj | 80 - windowsRuntimeInstaller/CreateInstallerRT.sh | 16 - windowsRuntimeInstaller/InstallerRT.nsi | 868 -- windowsRuntimeInstaller/NSIS_Security.patch | 58 - windowsRuntimeInstaller/README.txt | 153 - windowsRuntimeInstaller/V.bmp | Bin 27626 -> 0 bytes windowsRuntimeInstaller/V.ico | Bin 101492 -> 0 bytes windowsRuntimeInstaller/VULKANRT_LICENSE.rtf | Bin 1469 -> 0 bytes windowsRuntimeInstaller/configure_runtime.c | 764 -- 129 files changed, 82094 deletions(-) delete mode 100644 build_windows_targets.bat delete mode 100644 layers/CMakeLists.txt delete mode 100644 layers/README.md delete mode 100644 layers/VkLayer_core_validation.def delete mode 100644 layers/VkLayer_image.def delete mode 100644 layers/VkLayer_object_tracker.def delete mode 100644 layers/VkLayer_parameter_validation.def delete mode 100644 layers/VkLayer_swapchain.def delete mode 100644 layers/VkLayer_threading.def delete mode 100644 layers/VkLayer_unique_objects.def delete mode 100644 layers/buffer_validation.cpp delete mode 100644 layers/buffer_validation.h delete mode 100644 layers/core_validation.cpp delete mode 100644 layers/core_validation.h delete mode 100644 layers/core_validation_error_enums.h delete mode 100644 layers/core_validation_layer.md delete mode 100644 layers/core_validation_types.h delete mode 100644 layers/descriptor_sets.cpp delete mode 100644 layers/descriptor_sets.h delete mode 100644 layers/hash_util.h delete mode 100644 layers/hash_vk_types.h delete mode 100644 layers/linux/VkLayer_core_validation.json delete mode 100644 layers/linux/VkLayer_object_tracker.json delete mode 100644 layers/linux/VkLayer_parameter_validation.json delete mode 100644 layers/linux/VkLayer_standard_validation.json delete mode 100644 layers/linux/VkLayer_threading.json delete mode 100644 layers/linux/VkLayer_unique_objects.json delete mode 100644 layers/macos/VkLayer_core_validation.json delete mode 100644 layers/macos/VkLayer_device_simulation.json delete mode 100644 layers/macos/VkLayer_object_tracker.json delete mode 100644 layers/macos/VkLayer_parameter_validation.json delete mode 100644 layers/macos/VkLayer_standard_validation.json delete mode 100644 layers/macos/VkLayer_threading.json delete mode 100644 layers/macos/VkLayer_unique_objects.json delete mode 100644 layers/object_tracker.h delete mode 100644 layers/object_tracker_layer.md delete mode 100644 layers/object_tracker_utils.cpp delete mode 100644 layers/old_vuid_to_new_mapping.txt delete mode 100644 layers/parameter_name.h delete mode 100644 layers/parameter_validation.h delete mode 100644 layers/parameter_validation_layer.md delete mode 100644 layers/parameter_validation_utils.cpp delete mode 100644 layers/shader_validation.cpp delete mode 100644 layers/shader_validation.h delete mode 100644 layers/threading.cpp delete mode 100644 layers/threading.h delete mode 100644 layers/threading_layer.md delete mode 100644 layers/unique_objects.cpp delete mode 100644 layers/unique_objects.h delete mode 100644 layers/unique_objects_layer.md delete mode 100644 layers/vk_format_utils.cpp delete mode 100644 layers/vk_format_utils.h delete mode 100644 layers/vk_layer_config.cpp delete mode 100644 layers/vk_layer_config.h delete mode 100644 layers/vk_layer_data.h delete mode 100644 layers/vk_layer_extension_utils.cpp delete mode 100644 layers/vk_layer_extension_utils.h delete mode 100644 layers/vk_layer_logging.h delete mode 100644 layers/vk_layer_settings.txt delete mode 100644 layers/vk_layer_table.cpp delete mode 100644 layers/vk_layer_table.h delete mode 100644 layers/vk_layer_utils.cpp delete mode 100644 layers/vk_layer_utils.h delete mode 100644 layers/vk_validation_error_database.txt delete mode 100644 layers/vk_validation_error_messages.h delete mode 100755 layers/vu_csv_stats.sh delete mode 100644 layers/windows/VkLayer_core_validation.json delete mode 100644 layers/windows/VkLayer_object_tracker.json delete mode 100644 layers/windows/VkLayer_parameter_validation.json delete mode 100644 layers/windows/VkLayer_standard_validation.json delete mode 100644 layers/windows/VkLayer_threading.json delete mode 100644 layers/windows/VkLayer_unique_objects.json delete mode 100644 layers/xxhash.c delete mode 100644 layers/xxhash.h delete mode 100644 loader/CMakeLists.txt delete mode 100644 loader/LoaderAndLayerInterface.md delete mode 100644 loader/README.md delete mode 100644 loader/asm_offset.c delete mode 100644 loader/cJSON.c delete mode 100644 loader/cJSON.h delete mode 100644 loader/debug_utils.c delete mode 100644 loader/debug_utils.h delete mode 100644 loader/dev_ext_trampoline.c delete mode 100644 loader/dirent_on_windows.c delete mode 100644 loader/dirent_on_windows.h delete mode 100644 loader/extension_manual.c delete mode 100644 loader/extension_manual.h delete mode 100644 loader/gpa_helper.h delete mode 100644 loader/images/function_device_chain.png delete mode 100644 loader/images/function_device_chain_white.png delete mode 100644 loader/images/function_instance_chain.png delete mode 100644 loader/images/function_instance_chain_white.png delete mode 100644 loader/images/high_level_loader.png delete mode 100644 loader/images/high_level_loader_white.png delete mode 100644 loader/images/loader_device_chain_app.png delete mode 100644 loader/images/loader_device_chain_app_white.png delete mode 100644 loader/images/loader_device_chain_loader.png delete mode 100644 loader/images/loader_device_chain_loader_white.png delete mode 100644 loader/images/loader_instance_chain.png delete mode 100644 loader/images/loader_instance_chain_white.png delete mode 100644 loader/images/loader_layer_order.png delete mode 100644 loader/images/loader_layer_order_white.png delete mode 100644 loader/loader.aps delete mode 100644 loader/loader.c delete mode 100644 loader/loader.h delete mode 100755 loader/loader.rc delete mode 100644 loader/loader_cmake_config.h.in delete mode 100644 loader/murmurhash.c delete mode 100644 loader/murmurhash.h delete mode 100644 loader/phys_dev_ext.c delete mode 100644 loader/trampoline.c delete mode 100644 loader/unknown_ext_chain.c delete mode 100644 loader/unknown_ext_chain_gas.asm delete mode 100644 loader/unknown_ext_chain_masm.asm delete mode 100644 loader/vk_loader_layer.h delete mode 100644 loader/vk_loader_platform.h delete mode 100644 loader/vulkan-1.def delete mode 100644 loader/vulkan.pc.in delete mode 100644 loader/wsi.c delete mode 100644 loader/wsi.h delete mode 100644 windowsRuntimeInstaller/ConfigureRT.vcxproj delete mode 100755 windowsRuntimeInstaller/CreateInstallerRT.sh delete mode 100644 windowsRuntimeInstaller/InstallerRT.nsi delete mode 100644 windowsRuntimeInstaller/NSIS_Security.patch delete mode 100644 windowsRuntimeInstaller/README.txt delete mode 100644 windowsRuntimeInstaller/V.bmp delete mode 100644 windowsRuntimeInstaller/V.ico delete mode 100644 windowsRuntimeInstaller/VULKANRT_LICENSE.rtf delete mode 100644 windowsRuntimeInstaller/configure_runtime.c diff --git a/build_windows_targets.bat b/build_windows_targets.bat deleted file mode 100644 index c6e53e19..00000000 --- a/build_windows_targets.bat +++ /dev/null @@ -1,170 +0,0 @@ -echo off -REM -REM This Windows batch file builds this repository for the following targets: -REM 64/32-bit Release/Debug -REM It uses CMake to genererate the project files and then invokes msbuild -REM to build them. -REM The update_external_sources.bat batch file must be executed before running -REM this batch file -REM -REM Arguments: -REM None: Runs CMake and builds all 4 combinations -REM Argument contains: -REM cmake (case insensitive): Deletes build and build32 and runs just CMake on both -REM 32: Deletes build32, runs CMake and builds 32-bit versions -REM 64: Deletes build, runs CMake and builds 64-bit versions -REM debug (case insensitive): Builds just the debug config of a 32 and/or 64-bit build -REM release (case insensitive): Builds just the release config of a 32 and/or 64-bit build -REM Notes: -REM cmake: When specified, generate the CMake build files only - don't compile -REM 32/64: Specifying neither or both builds both -REM debug/release: Specifying neither or both builds both -REM Examples: -REM build_windows_targets.bat 64 -REM -- deletes build, creates build, runs CMake and compiles 64-bit Debug and Release. -REM build_windows_targets.bat 64 debug -REM -- deletes build, creates build, runs CMake and compiles 64-bit Debug. - -set arg_cmake=0 -set arg_32=0 -set arg_64=0 -set arg_debug=0 -set arg_release=0 - -set do_cmake=0 -set do_32=0 -set do_64=0 -set do_debug=0 -set do_release=0 - -for %%a in (%*) do ( - echo.%%a | %WINDIR%\system32\find.exe /I "cmake">Nul && (set arg_cmake=1) - echo.%%a | %WINDIR%\system32\find.exe "32">Nul && (set arg_32=1) - echo.%%a | %WINDIR%\system32\find.exe "64">Nul && (set arg_64=1) - echo.%%a | %WINDIR%\system32\find.exe /I "debug">Nul && (set arg_debug=1) - echo.%%a | %WINDIR%\system32\find.exe /I "release">Nul && (set arg_release=1) -) - -if %arg_32%==1 ( - set do_32=1 -) -if %arg_64%==1 ( - set do_64=1 -) -if %arg_32%==0 ( - if %arg_64%==0 ( - set do_32=1 - set do_64=1 - ) -) - -if %arg_debug%==1 ( - set do_debug=1 -) -if %arg_release%==1 ( - set do_release=1 -) -if %arg_debug%==0 ( - if %arg_release%==0 ( - set do_debug=1 - set do_release=1 - ) -) - -if %arg_cmake%==1 ( - set do_cmake=1 - set do_32=0 - set do_64=0 - set do_debug=0 - set do_release=0 -) - -REM Determine the appropriate CMake strings for the current version of Visual Studio -echo Determining VS version -python .\scripts\determine_vs_version.py > vsversion.tmp -set /p VS_VERSION=< vsversion.tmp -echo Detected Visual Studio Version as %VS_VERSION% -del /Q /F vsversion.tmp - -if %do_cmake%==1 ( - rmdir /Q /S build - rmdir /Q /S build32 - mkdir build - pushd build - echo Generating 64-bit CMake files for Visual Studio %VS_VERSION% - cmake -G "Visual Studio %VS_VERSION% Win64" .. - popd - mkdir build32 - pushd build32 - echo Generating 32-bit CMake files for Visual Studio %VS_VERSION% - cmake -G "Visual Studio %VS_VERSION%" .. - popd -) - -REM ******************************************* -REM 64-bit build -REM ******************************************* -if %do_64%==1 ( - rmdir /Q /S build - mkdir build - pushd build - echo Generating 64-bit CMake files for Visual Studio %VS_VERSION% - cmake -G "Visual Studio %VS_VERSION% Win64" .. - if %do_debug% equ 1 ( - echo Building 64-bit Debug - msbuild ALL_BUILD.vcxproj /p:Platform=x64 /p:Configuration=Debug /maxcpucount /verbosity:quiet - if errorlevel 1 ( - echo. - echo 64-bit Debug build failed! - popd - exit /b 1 - ) - ) - - if %do_release%==1 ( - echo Building 64-bit Release - msbuild ALL_BUILD.vcxproj /p:Platform=x64 /p:Configuration=Release /maxcpucount /verbosity:quiet - if errorlevel 1 ( - echo. - echo 64-bit Release build failed! - popd - exit /b 1 - ) - ) - popd -) - -REM ******************************************* -REM 32-bit build -REM ******************************************* - -if %do_32%==1 ( - rmdir /Q /S build32 - mkdir build32 - pushd build32 - echo Generating 32-bit CMake files for Visual Studio %VS_VERSION% - cmake -G "Visual Studio %VS_VERSION%" .. - if %do_debug%==1 ( - echo Building 32-bit Debug - msbuild ALL_BUILD.vcxproj /p:Platform=x86 /p:Configuration=Debug /maxcpucount /verbosity:quiet - if errorlevel 1 ( - echo. - echo 32-bit Debug build failed! - popd - exit /b 1 - ) - ) - - if %do_release%==1 ( - echo Building 32-bit Release - msbuild ALL_BUILD.vcxproj /p:Platform=x86 /p:Configuration=Release /maxcpucount /verbosity:quiet - if errorlevel 1 ( - echo. - echo 32-bit Release build failed! - popd - exit /b 1 - ) - ) - popd -) -exit /b 0 diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt deleted file mode 100644 index 7f341b48..00000000 --- a/layers/CMakeLists.txt +++ /dev/null @@ -1,233 +0,0 @@ -cmake_minimum_required (VERSION 2.8.11) -if(CMAKE_SYSTEM_NAME STREQUAL "Windows") - add_definitions(-DVK_USE_PLATFORM_WIN32_KHR -DVK_USE_PLATFORM_WIN32_KHX -DWIN32_LEAN_AND_MEAN) - add_custom_target(mk_layer_config_dir ALL COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/$) - set_target_properties(mk_layer_config_dir PROPERTIES FOLDER ${LVL_TARGET_FOLDER}) - set(DisplayServer Win32) -elseif(CMAKE_SYSTEM_NAME STREQUAL "Android") - add_definitions(-DVK_USE_PLATFORM_ANDROID_KHR -DVK_USE_PLATFORM_ANDROID_KHX) -elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") - 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() - - if (BUILD_WSI_MIR_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_MIR_KHR -DVK_USE_PLATFORM_MIR_KHX) - include_directories(${MIR_INCLUDE_DIR}) - endif() -elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") - add_definitions(-DVK_USE_PLATFORM_MACOS_MVK) - if(CMAKE_GENERATOR MATCHES "^Xcode.*") - add_custom_target(mk_layer_config_dir ALL COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/$) - endif() -else() - message(FATAL_ERROR "Unsupported Platform!") -endif() - -set(LAYER_JSON_FILES_WITH_DEPENDENCIES - VkLayer_core_validation - VkLayer_object_tracker - VkLayer_unique_objects - VkLayer_parameter_validation - VkLayer_threading - ) - -set(LAYER_JSON_FILES_NO_DEPENDENCIES - VkLayer_standard_validation - ) - -set(LAYER_JSON_FILES ${LAYER_JSON_FILES_WITH_DEPENDENCIES} ${LAYER_JSON_FILES_NO_DEPENDENCIES}) - -if (WIN32) - if (CMAKE_GENERATOR MATCHES "^Visual Studio.*") - foreach (config_file ${LAYER_JSON_FILES}) - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/windows/${config_file}.json src_json) - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/$/${config_file}.json dst_json) - add_custom_target(${config_file}-json ALL - DEPENDS mk_layer_config_dir - COMMAND copy ${src_json} ${dst_json} - VERBATIM - ) - set_target_properties(${config_file}-json PROPERTIES FOLDER ${LVL_TARGET_FOLDER}) - endforeach(config_file) - else() - foreach (config_file ${LAYER_JSON_FILES}) - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/windows/${config_file}.json src_json) - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/${config_file}.json dst_json) - add_custom_target(${config_file}-json ALL - COMMAND copy ${src_json} ${dst_json} - VERBATIM - ) - endforeach(config_file) - endif() - if (NOT (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)) - # Copy vk_validation_error_messages.h from source to build dir for scripts to pick up - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/vk_validation_error_messages.h src_val_msgs) - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/vk_validation_error_messages.h dst_val_msgs) - add_custom_target(vk_validation_error_messages ALL - COMMAND copy ${src_val_msgs} ${dst_val_msgs} - VERBATIM - ) - set_target_properties(vk_validation_error_messages PROPERTIES FOLDER ${LVL_TARGET_FOLDER}) - endif() -elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Linux") - # extra setup for out-of-tree builds - if (NOT (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)) - foreach (config_file ${LAYER_JSON_FILES}) - add_custom_target(${config_file}-json ALL - COMMAND ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/linux/${config_file}.json - VERBATIM - ) - endforeach(config_file) - # Add link to vk_validation_error_messages.h in build dir for scripts to pick up - add_custom_target(vk_validation_error_messages ALL - COMMAND ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/vk_validation_error_messages.h - VERBATIM - ) - endif() -elseif(APPLE) - # extra setup for out-of-tree builds - if (NOT (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)) - if (CMAKE_GENERATOR MATCHES "^Xcode.*") - foreach (config_file ${LAYER_JSON_FILES}) - add_custom_target(${config_file}-json ALL - DEPENDS mk_layer_config_dir - COMMAND ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/macos/${config_file}.json $ - VERBATIM - ) - endforeach(config_file) - else() - foreach (config_file ${LAYER_JSON_FILES}) - add_custom_target(${config_file}-json ALL - COMMAND ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/macos/${config_file}.json - VERBATIM - ) - endforeach(config_file) - endif() - # Add link to vk_validation_error_messages.h in build dir for scripts to pick up - add_custom_target(vk_validation_error_messages ALL - COMMAND ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/vk_validation_error_messages.h - VERBATIM - ) - endif() -endif() -# If a layer has a direct dependency on a project with the same name, use it. -if ((Win32) OR (NOT (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR))) - foreach (config_file ${LAYER_JSON_FILES_WITH_DEPENDENCIES}) - add_dependencies(${config_file}-json ${config_file}) - endforeach(config_file) - # If a layer has no direct dependencies, give it one so it copies in the proper order - foreach (config_file ${LAYER_JSON_FILES_NO_DEPENDENCIES}) - add_dependencies(${config_file}-json VkLayer_utils) - endforeach(config_file) -endif() - -# Add targets for JSON file install on Linux. -# Need to remove the "./" from the library path before installing to system directories. -if(UNIX) - if(INSTALL_LVL_FILES) - foreach (config_file ${LAYER_JSON_FILES}) - add_custom_target(${config_file}-staging-json ALL - COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/staging-json - COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/linux/${config_file}.json ${CMAKE_CURRENT_BINARY_DIR}/staging-json - COMMAND sed -i -e "/\"library_path\":/s$./libVkLayer$libVkLayer$" ${CMAKE_CURRENT_BINARY_DIR}/staging-json/${config_file}.json - VERBATIM - DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/linux/${config_file}.json - ) - install(FILES ${CMAKE_CURRENT_BINARY_DIR}/staging-json/${config_file}.json DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/vulkan/explicit_layer.d) - endforeach(config_file) - endif() -endif() - -if (WIN32) - macro(add_vk_layer target) - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/VkLayer_${target}.def DEF_FILE) - add_custom_target(copy-${target}-def-file ALL - COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DEF_FILE} VkLayer_${target}.def - VERBATIM - ) - set_target_properties(copy-${target}-def-file PROPERTIES FOLDER ${LVL_TARGET_FOLDER}) - add_library(VkLayer_${target} SHARED ${ARGN} VkLayer_${target}.def) - add_dependencies(VkLayer_${target} generate_helper_files) - target_link_Libraries(VkLayer_${target} VkLayer_utils) - add_dependencies(VkLayer_${target} generate_helper_files VkLayer_utils) - endmacro() -elseif(APPLE) - macro(add_vk_layer target) - add_library(VkLayer_${target} SHARED ${ARGN}) - target_link_Libraries(VkLayer_${target} VkLayer_utils) - add_dependencies(VkLayer_${target} generate_helper_files VkLayer_utils) - set_target_properties(VkLayer_${target} PROPERTIES - LINK_FLAGS "-Wl" - INSTALL_RPATH "@loader_path/" - ) - install(TARGETS VkLayer_${target} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) - endmacro() -else() - macro(add_vk_layer target) - add_library(VkLayer_${target} SHARED ${ARGN}) - target_link_Libraries(VkLayer_${target} VkLayer_utils) - add_dependencies(VkLayer_${target} generate_helper_files VkLayer_utils) - set_target_properties(VkLayer_${target} PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic,--exclude-libs,ALL") - if(INSTALL_LVL_FILES) - install(TARGETS VkLayer_${target} DESTINATION ${CMAKE_INSTALL_LIBDIR}) - endif() - endmacro() -endif() - -include_directories( - ${CMAKE_CURRENT_SOURCE_DIR} - ${CMAKE_CURRENT_SOURCE_DIR}/../loader - ${CMAKE_CURRENT_SOURCE_DIR}/../include/vulkan - ${CMAKE_CURRENT_BINARY_DIR} - ${PROJECT_BINARY_DIR} - ${CMAKE_BINARY_DIR} -) - -if (WIN32) - # Applies to all configurations - add_definitions(-D_CRT_SECURE_NO_WARNINGS) - # Avoid: fatal error C1128: number of sections exceeded object file format limit: compile with /bigobj - set_source_files_properties(core_validation.cpp threading.cpp - PROPERTIES COMPILE_FLAGS "/bigobj") - # Turn off transitional "changed behavior" warning message for Visual Studio versions prior to 2015. - # The changed behavior is that constructor initializers are now fixed to clear the struct members. - add_compile_options("$<$,$,19>>:/wd4351>") -else() - set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wpointer-arith -Wno-unused-function -Wno-sign-compare") - set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wpointer-arith -Wno-unused-function -Wno-sign-compare") -endif() - -# Clang (and not gcc) warns about unused const variables. -# Generated files may purposely contain unused consts, so -# silence this warning in Clang. -if (CMAKE_C_COMPILER_ID MATCHES "Clang") - set_source_files_properties(parameter_validation.cpp PROPERTIES - COMPILE_FLAGS "-Wno-unused-const-variable") -endif() - -run_vk_xml_generate(threading_generator.py thread_check.h) -run_vk_xml_generate(parameter_validation_generator.py parameter_validation.cpp) -run_vk_xml_generate(unique_objects_generator.py unique_objects_wrappers.h) -run_vk_xml_generate(dispatch_table_helper_generator.py vk_dispatch_table_helper.h) -run_vk_xml_generate(object_tracker_generator.py object_tracker.cpp) - -add_vk_layer(core_validation core_validation.cpp vk_layer_table.cpp descriptor_sets.cpp buffer_validation.cpp shader_validation.cpp xxhash.c) -add_vk_layer(object_tracker object_tracker.cpp object_tracker_utils.cpp vk_layer_table.cpp) -# generated -add_vk_layer(threading threading.cpp thread_check.h vk_layer_table.cpp) -add_vk_layer(unique_objects unique_objects.cpp unique_objects_wrappers.h vk_layer_table.cpp) -add_vk_layer(parameter_validation parameter_validation.cpp parameter_validation_utils.cpp parameter_validation.h vk_layer_table.cpp vk_validation_error_messages.h) - -# Core validation has additional dependencies -target_include_directories(VkLayer_core_validation PRIVATE ${GLSLANG_SPIRV_INCLUDE_DIR}) -target_include_directories(VkLayer_core_validation PRIVATE ${SPIRV_TOOLS_INCLUDE_DIR}) -target_link_libraries(VkLayer_core_validation ${SPIRV_TOOLS_LIBRARIES}) diff --git a/layers/README.md b/layers/README.md deleted file mode 100644 index bc6728e5..00000000 --- a/layers/README.md +++ /dev/null @@ -1,84 +0,0 @@ -# Layer Description and Status - -## Layer Library Interface - -All layer libraries must support the layer library interface defined in -[`LoaderAndLayerInterface.md`][]. - -[`LoaderAndLayerInterface.md`]: ../loader/LoaderAndLayerInterface.md#layer-library-interface - -## Overview - -Layer libraries can be written to intercept or hook VK entry points for various -debug and validation purposes. One or more VK entry points can be defined in your Layer -library. Undefined entrypoints in the Layer library will be passed to the next Layer which -may be the driver. Multiple layer libraries can be chained (actually a hierarchy) together. -vkEnumerateInstanceLayerProperties can be called to list the -available layers and their properties. Layers can intercept all Vulkan commands -that take a dispatchable object as it's first argument. I.e. VkInstance, VkPhysicalDevice, -VkDevice, VkCommandBuffer, and VkQueue. -vkXXXXGetProcAddr is used internally by the Layers and Loader to initialize dispatch tables. -Layers can also be activated via the VK_INSTANCE_LAYERS environment variable. - -All validation layers work with the DEBUG_REPORT extension to provide validation feedback. -When a validation layer is enabled, it will look for a vk_layer_settings.txt file (see"Using -Layers" section below for more details) to define its logging behavior, which can include -sending output to a file, stdout, or debug output (Windows). Applications can also register -debug callback functions via the DEBUG_REPORT extension to receive callbacks when validation -events occur. Application callbacks are independent of settings in a vk_layer_settings.txt -file which will be carried out separately. If no vk_layer_settings.txt file is present and -no application callbacks are registered, error messages will be output through default -logging callbacks. - -### Layer library example code - -Note that some layers are code-generated and will therefore exist in the directory `(build_dir)/layers` - -`include/vkLayer.h` - header file for layer code. - -### Layer Details -For complete details of current validation layers, including all of the validation checks that they perform, please refer to the document `layers/vk_validation_layer_details.md`. Below is a brief overview of each layer. - -### Standard Validation -This is a meta-layer managed by the loader. (name = `VK_LAYER_LUNARG_standard_validation`) - specifying this layer name will cause the loader to load the all of the standard validation layers (listed below) in the following optimal order: `VK_LAYER_GOOGLE_threading`, `VK_LAYER_LUNARG_parameter_validation`, `VK_LAYER_LUNARG_object_tracker`, `VK_LAYER_LUNARG_core_validation`, and `VK_LAYER_GOOGLE_unique_objects`. Other layers can be specified and the loader will remove duplicates. - -### Object Validation and Statistics -(build dir)/layers/object_tracker.cpp (name=`VK_LAYER_LUNARG_object_tracker`) - Track object creation, use, and destruction. As objects are created they are stored in a map. As objects are used the layer verifies they exist in the map, flagging errors for unknown objects. As objects are destroyed they are removed from the map. At `vkDestroyDevice()` and `vkDestroyInstance()` times, if any objects have not been destroyed they are reported as leaked objects. If a Dbg callback function is registered this layer will use callback function(s) for reporting, otherwise it will use stdout. - -### Validate API State and Shaders -layers/core\_validation.cpp (name=`VK_LAYER_LUNARG_core_validation`) - The core\_validation layer does the bulk of the API validation that requires storing state. Some of the state it tracks includes the Descriptor Set, Pipeline State, Shaders, and dynamic state, and memory objects and bindings. It performs some point validation as states are created and used, and further validation Draw call and QueueSubmit time. Of primary interest is making sure that the resources bound to Descriptor Sets correctly align with the layout specified for the Set. Also, all of the image and buffer layouts are validated to make sure explicit layout transitions are properly managed. Related to memory, core\_validation includes tracking object bindings, memory hazards, and memory object lifetimes. It also validates several other hazard-related issues related to command buffers, fences, and memory mapping. Additionally core\_validation include shader validation (formerly separate shader\_checker layer) that inspects the SPIR-V shader images and fixed function pipeline stages at PSO creation time. It flags errors when inconsistencies are found across interfaces between shader stages. The exact behavior of the checks depends on the pair of pipeline stages involved. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. This layer also validates correct usage of image- and buffer-related APIs, including image and buffer parameters, formats, and correct use. - -### Check parameters -layers/parameter_validation.cpp (name=`VK_LAYER_LUNARG_parameter_validation`) - Check the input parameters to API calls for validity. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. - -### Check threading -layers/threading.cpp (name=`VK_LAYER_GOOGLE_threading`) - Check multithreading of API calls for validity. Currently this checks that only one thread at a time uses an object in free-threaded API calls. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. - -### Unique Objects -(build dir)/layers/unique_objects.cpp (name=`VK_LAYER_GOOGLE_unique_objects`) - The Vulkan specification allows objects that have non-unique handles. This makes tracking object lifetimes difficult in that it is unclear which object is being referenced on deletion. The unique_objects layer was created to address this problem. If loaded in the correct position (last, which is closest to the display driver) it will alias all objects with a unique object representation, allowing proper object lifetime tracking. This layer does no validation on its own and may not be required for the proper operation of all layers or all platforms. One sign that it is needed is the appearance of errors emitted from the object_tracker layer indicating the use of previously destroyed objects. - -## Using Layers - -1. Build VK loader using normal steps (cmake and make) -2. Place `libVkLayer_.so` in the same directory as your VK test or app: - - `cp build/layer/libVkLayer_threading.so build/tests` - - This is required for the Loader to be able to scan and enumerate your library. - Alternatively, use the `VK_LAYER_PATH` environment variable to specify where the layer libraries reside. - -3. To specify how your layers should behave, create a vk_layer_settings.txt file. This file can exist in the same directory as your app or in a directory given by the `VK_LAYER_SETTINGS_PATH` environment variable. Alternatively, you can use any filename you want if you set `VK_LAYER_SETTINGS_PATH` to the full path of the file, rather than the directory that contains it. - - Model the file after the following example: [*vk_layer_settings.txt*](vk_layer_settings.txt) - -4. Specify which layers to activate using environment variables. - - `export VK\_INSTANCE\_LAYERS=VK\_LAYER\_LUNARG\_parameter\_validation:VK\_LAYER\_LUNARG\_core\_validation` - `cd build/tests; ./vkinfo` - - -## Status - - -### Current known issues - diff --git a/layers/VkLayer_core_validation.def b/layers/VkLayer_core_validation.def deleted file mode 100644 index bced6e6d..00000000 --- a/layers/VkLayer_core_validation.def +++ /dev/null @@ -1,29 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2016 The Khronos Group Inc. -; Copyright (c) 2015-2016 Valve Corporation -; Copyright (c) 2015-2016 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY VkLayer_core_validation -EXPORTS -vkGetInstanceProcAddr -vkGetDeviceProcAddr -vkEnumerateInstanceLayerProperties -vkEnumerateInstanceExtensionProperties diff --git a/layers/VkLayer_image.def b/layers/VkLayer_image.def deleted file mode 100644 index ff442df0..00000000 --- a/layers/VkLayer_image.def +++ /dev/null @@ -1,29 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2016 The Khronos Group Inc. -; Copyright (c) 2015-2016 Valve Corporation -; Copyright (c) 2015-2016 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY VkLayer_image -EXPORTS -vkGetInstanceProcAddr -vkGetDeviceProcAddr -vkEnumerateInstanceLayerProperties -vkEnumerateInstanceExtensionProperties diff --git a/layers/VkLayer_object_tracker.def b/layers/VkLayer_object_tracker.def deleted file mode 100644 index a0aed9a4..00000000 --- a/layers/VkLayer_object_tracker.def +++ /dev/null @@ -1,29 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2016 The Khronos Group Inc. -; Copyright (c) 2015-2016 Valve Corporation -; Copyright (c) 2015-2016 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY VkLayer_object_tracker -EXPORTS -vkGetInstanceProcAddr -vkGetDeviceProcAddr -vkEnumerateInstanceLayerProperties -vkEnumerateInstanceExtensionProperties diff --git a/layers/VkLayer_parameter_validation.def b/layers/VkLayer_parameter_validation.def deleted file mode 100644 index eb524c02..00000000 --- a/layers/VkLayer_parameter_validation.def +++ /dev/null @@ -1,29 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2016 The Khronos Group Inc. -; Copyright (c) 2015-2016 Valve Corporation -; Copyright (c) 2015-2016 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY VkLayer_parameter_validation -EXPORTS -vkGetInstanceProcAddr -vkGetDeviceProcAddr -vkEnumerateInstanceLayerProperties -vkEnumerateInstanceExtensionProperties diff --git a/layers/VkLayer_swapchain.def b/layers/VkLayer_swapchain.def deleted file mode 100644 index c7431bb5..00000000 --- a/layers/VkLayer_swapchain.def +++ /dev/null @@ -1,29 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2016 The Khronos Group Inc. -; Copyright (c) 2015-2016 Valve Corporation -; Copyright (c) 2015-2016 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY VkLayer_swapchain -EXPORTS -vkGetInstanceProcAddr -vkGetDeviceProcAddr -vkEnumerateInstanceLayerProperties -vkEnumerateInstanceExtensionProperties diff --git a/layers/VkLayer_threading.def b/layers/VkLayer_threading.def deleted file mode 100644 index 22b6f7a9..00000000 --- a/layers/VkLayer_threading.def +++ /dev/null @@ -1,29 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2016 The Khronos Group Inc. -; Copyright (c) 2015-2016 Valve Corporation -; Copyright (c) 2015-2016 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY VkLayer_threading -EXPORTS -vkGetInstanceProcAddr -vkGetDeviceProcAddr -vkEnumerateInstanceLayerProperties -vkEnumerateInstanceExtensionProperties diff --git a/layers/VkLayer_unique_objects.def b/layers/VkLayer_unique_objects.def deleted file mode 100644 index 684b6f7f..00000000 --- a/layers/VkLayer_unique_objects.def +++ /dev/null @@ -1,29 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2016 The Khronos Group Inc. -; Copyright (c) 2015-2016 Valve Corporation -; Copyright (c) 2015-2016 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY VkLayer_unique_objects -EXPORTS -vkGetInstanceProcAddr -vkGetDeviceProcAddr -vkEnumerateInstanceLayerProperties -vkEnumerateInstanceExtensionProperties diff --git a/layers/buffer_validation.cpp b/layers/buffer_validation.cpp deleted file mode 100644 index 66ae6725..00000000 --- a/layers/buffer_validation.cpp +++ /dev/null @@ -1,4146 +0,0 @@ -/* 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: Dave Houlton - */ - -// Allow use of STL min and max functions in Windows -#define NOMINMAX - -#include -#include - -#include "vk_enum_string_helper.h" -#include "vk_layer_data.h" -#include "vk_layer_utils.h" -#include "vk_layer_logging.h" -#include "vk_typemap_helper.h" - -#include "buffer_validation.h" - -void SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const VkImageLayout &layout) { - auto it = pCB->imageLayoutMap.find(imgpair); - if (it != pCB->imageLayoutMap.end()) { - it->second.layout = layout; - } else { - assert(imgpair.hasSubresource); - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (!FindCmdBufLayout(device_data, pCB, imgpair.image, imgpair.subresource, node)) { - node.initialLayout = layout; - } - SetLayout(device_data, pCB, imgpair, {node.initialLayout, layout}); - } -} -template -void SetLayout(layer_data *device_data, OBJECT *pObject, VkImage image, VkImageSubresource range, const LAYOUT &layout) { - ImageSubresourcePair imgpair = {image, true, range}; - SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT); - SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT); - SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT); - SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT); - if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR); - SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR); - SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } -} - -template -void SetLayout(layer_data *device_data, OBJECT *pObject, ImageSubresourcePair imgpair, const LAYOUT &layout, - VkImageAspectFlags aspectMask) { - if (imgpair.subresource.aspectMask & aspectMask) { - imgpair.subresource.aspectMask = aspectMask; - SetLayout(device_data, pObject, imgpair, layout); - } -} - -// Set the layout in supplied map -void SetLayout(std::unordered_map &imageLayoutMap, ImageSubresourcePair imgpair, - VkImageLayout layout) { - auto it = imageLayoutMap.find(imgpair); - if (it != imageLayoutMap.end()) { - it->second.layout = layout; // Update - } else { - imageLayoutMap[imgpair].layout = layout; // Insert - } -} - -bool FindLayoutVerifyNode(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, ImageSubresourcePair imgpair, - IMAGE_CMD_BUF_LAYOUT_NODE &node, const VkImageAspectFlags aspectMask) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - if (!(imgpair.subresource.aspectMask & aspectMask)) { - return false; - } - VkImageAspectFlags oldAspectMask = imgpair.subresource.aspectMask; - imgpair.subresource.aspectMask = aspectMask; - auto imgsubIt = pCB->imageLayoutMap.find(imgpair); - if (imgsubIt == pCB->imageLayoutMap.end()) { - return false; - } - if (node.layout != VK_IMAGE_LAYOUT_MAX_ENUM && node.layout != imgsubIt->second.layout) { - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image), - DRAWSTATE_INVALID_LAYOUT, - "Cannot query for VkImage 0x%" PRIx64 " layout when combined aspect mask %d has multiple layout types: %s and %s", - HandleToUint64(imgpair.image), oldAspectMask, string_VkImageLayout(node.layout), - string_VkImageLayout(imgsubIt->second.layout)); - } - if (node.initialLayout != VK_IMAGE_LAYOUT_MAX_ENUM && node.initialLayout != imgsubIt->second.initialLayout) { - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image), - DRAWSTATE_INVALID_LAYOUT, - "Cannot query for VkImage 0x%" PRIx64 - " layout when combined aspect mask %d has multiple initial layout types: %s and %s", - HandleToUint64(imgpair.image), oldAspectMask, string_VkImageLayout(node.initialLayout), - string_VkImageLayout(imgsubIt->second.initialLayout)); - } - node = imgsubIt->second; - return true; -} - -bool FindLayoutVerifyLayout(layer_data const *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout, - const VkImageAspectFlags aspectMask) { - if (!(imgpair.subresource.aspectMask & aspectMask)) { - return false; - } - const debug_report_data *report_data = core_validation::GetReportData(device_data); - VkImageAspectFlags oldAspectMask = imgpair.subresource.aspectMask; - imgpair.subresource.aspectMask = aspectMask; - auto imgsubIt = (*core_validation::GetImageLayoutMap(device_data)).find(imgpair); - if (imgsubIt == (*core_validation::GetImageLayoutMap(device_data)).end()) { - return false; - } - if (layout != VK_IMAGE_LAYOUT_MAX_ENUM && layout != imgsubIt->second.layout) { - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image), - DRAWSTATE_INVALID_LAYOUT, - "Cannot query for VkImage 0x%" PRIx64 " layout when combined aspect mask %d has multiple layout types: %s and %s", - HandleToUint64(imgpair.image), oldAspectMask, string_VkImageLayout(layout), - string_VkImageLayout(imgsubIt->second.layout)); - } - layout = imgsubIt->second.layout; - return true; -} - -// Find layout(s) on the command buffer level -bool FindCmdBufLayout(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, VkImage image, VkImageSubresource range, - IMAGE_CMD_BUF_LAYOUT_NODE &node) { - ImageSubresourcePair imgpair = {image, true, range}; - node = IMAGE_CMD_BUF_LAYOUT_NODE(VK_IMAGE_LAYOUT_MAX_ENUM, VK_IMAGE_LAYOUT_MAX_ENUM); - FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_COLOR_BIT); - FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_DEPTH_BIT); - FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_STENCIL_BIT); - FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_METADATA_BIT); - if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR); - FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR); - FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - if (node.layout == VK_IMAGE_LAYOUT_MAX_ENUM) { - imgpair = {image, false, VkImageSubresource()}; - auto imgsubIt = pCB->imageLayoutMap.find(imgpair); - if (imgsubIt == pCB->imageLayoutMap.end()) return false; - // TODO: This is ostensibly a find function but it changes state here - node = imgsubIt->second; - } - return true; -} - -// Find layout(s) on the global level -bool FindGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout) { - layout = VK_IMAGE_LAYOUT_MAX_ENUM; - FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT); - FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT); - FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT); - FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT); - if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR); - FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR); - FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - if (layout == VK_IMAGE_LAYOUT_MAX_ENUM) { - imgpair = {imgpair.image, false, VkImageSubresource()}; - auto imgsubIt = (*core_validation::GetImageLayoutMap(device_data)).find(imgpair); - if (imgsubIt == (*core_validation::GetImageLayoutMap(device_data)).end()) return false; - layout = imgsubIt->second.layout; - } - return true; -} - -bool FindLayouts(layer_data *device_data, VkImage image, std::vector &layouts) { - auto sub_data = (*core_validation::GetImageSubresourceMap(device_data)).find(image); - if (sub_data == (*core_validation::GetImageSubresourceMap(device_data)).end()) return false; - auto image_state = GetImageState(device_data, image); - if (!image_state) return false; - bool ignoreGlobal = false; - // TODO: Make this robust for >1 aspect mask. Now it will just say ignore potential errors in this case. - if (sub_data->second.size() >= (image_state->createInfo.arrayLayers * image_state->createInfo.mipLevels + 1)) { - ignoreGlobal = true; - } - for (auto imgsubpair : sub_data->second) { - if (ignoreGlobal && !imgsubpair.hasSubresource) continue; - auto img_data = (*core_validation::GetImageLayoutMap(device_data)).find(imgsubpair); - if (img_data != (*core_validation::GetImageLayoutMap(device_data)).end()) { - layouts.push_back(img_data->second.layout); - } - } - return true; -} -bool FindLayout(const std::unordered_map &imageLayoutMap, ImageSubresourcePair imgpair, - VkImageLayout &layout, const VkImageAspectFlags aspectMask) { - if (!(imgpair.subresource.aspectMask & aspectMask)) { - return false; - } - imgpair.subresource.aspectMask = aspectMask; - auto imgsubIt = imageLayoutMap.find(imgpair); - if (imgsubIt == imageLayoutMap.end()) { - return false; - } - layout = imgsubIt->second.layout; - return true; -} - -// find layout in supplied map -bool FindLayout(layer_data *device_data, const std::unordered_map &imageLayoutMap, - ImageSubresourcePair imgpair, VkImageLayout &layout) { - layout = VK_IMAGE_LAYOUT_MAX_ENUM; - FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT); - FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT); - FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT); - FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT); - if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR); - FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR); - FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - // Image+subresource not found, look for image handle w/o subresource - if (layout == VK_IMAGE_LAYOUT_MAX_ENUM) { - imgpair = {imgpair.image, false, VkImageSubresource()}; - auto imgsubIt = imageLayoutMap.find(imgpair); - if (imgsubIt == imageLayoutMap.end()) return false; - layout = imgsubIt->second.layout; - } - return true; -} - -// Set the layout on the global level -void SetGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, const VkImageLayout &layout) { - VkImage &image = imgpair.image; - auto &lmap = (*core_validation::GetImageLayoutMap(device_data)); - auto data = lmap.find(imgpair); - if (data != lmap.end()) { - data->second.layout = layout; // Update - } else { - lmap[imgpair].layout = layout; // Insert - } - auto &image_subresources = (*core_validation::GetImageSubresourceMap(device_data))[image]; - auto subresource = std::find(image_subresources.begin(), image_subresources.end(), imgpair); - if (subresource == image_subresources.end()) { - image_subresources.push_back(imgpair); - } -} - -// Set the layout on the cmdbuf level -void SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const IMAGE_CMD_BUF_LAYOUT_NODE &node) { - auto it = pCB->imageLayoutMap.find(imgpair); - if (it != pCB->imageLayoutMap.end()) { - it->second = node; // Update - } else { - pCB->imageLayoutMap[imgpair] = node; // Insert - } -} -// Set image layout for given VkImageSubresourceRange struct -void SetImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *image_state, - VkImageSubresourceRange image_subresource_range, const VkImageLayout &layout) { - assert(image_state); - cb_node->image_layout_change_count++; // Change the version of this data to force revalidation - for (uint32_t level_index = 0; level_index < image_subresource_range.levelCount; ++level_index) { - uint32_t level = image_subresource_range.baseMipLevel + level_index; - for (uint32_t layer_index = 0; layer_index < image_subresource_range.layerCount; layer_index++) { - uint32_t layer = image_subresource_range.baseArrayLayer + layer_index; - VkImageSubresource sub = {image_subresource_range.aspectMask, level, layer}; - // TODO: If ImageView was created with depth or stencil, transition both layouts as the aspectMask is ignored and both - // are used. Verify that the extra implicit layout is OK for descriptor set layout validation - if (image_subresource_range.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { - if (FormatIsDepthAndStencil(image_state->createInfo.format)) { - sub.aspectMask |= (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); - } - } - SetLayout(device_data, cb_node, image_state->image, sub, layout); - } - } -} -// Set image layout for given VkImageSubresourceLayers struct -void SetImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *image_state, - VkImageSubresourceLayers image_subresource_layers, const VkImageLayout &layout) { - // Transfer VkImageSubresourceLayers into VkImageSubresourceRange struct - VkImageSubresourceRange image_subresource_range; - image_subresource_range.aspectMask = image_subresource_layers.aspectMask; - image_subresource_range.baseArrayLayer = image_subresource_layers.baseArrayLayer; - image_subresource_range.layerCount = image_subresource_layers.layerCount; - image_subresource_range.baseMipLevel = image_subresource_layers.mipLevel; - image_subresource_range.levelCount = 1; - SetImageLayout(device_data, cb_node, image_state, image_subresource_range, layout); -} - -// Set image layout for all slices of an image view -void SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, VkImageView imageView, const VkImageLayout &layout) { - auto view_state = GetImageViewState(device_data, imageView); - assert(view_state); - - IMAGE_STATE *image_state = GetImageState(device_data, view_state->create_info.image); - VkImageSubresourceRange sub_range = view_state->create_info.subresourceRange; - - // When changing the layout of a 3D image subresource via a 2D or 2D_ARRRAY image view, all depth slices of - // the subresource mip level(s) are transitioned, ignoring any layers restriction in the subresource info. - if ((image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) && (view_state->create_info.viewType != VK_IMAGE_VIEW_TYPE_3D)) { - sub_range.baseArrayLayer = 0; - sub_range.layerCount = image_state->createInfo.extent.depth; - } - - SetImageLayout(device_data, cb_node, image_state, sub_range, layout); -} - -bool VerifyFramebufferAndRenderPassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, - const VkRenderPassBeginInfo *pRenderPassBegin, - const FRAMEBUFFER_STATE *framebuffer_state) { - bool skip = false; - auto const pRenderPassInfo = GetRenderPassState(device_data, pRenderPassBegin->renderPass)->createInfo.ptr(); - auto const &framebufferInfo = framebuffer_state->createInfo; - const auto report_data = core_validation::GetReportData(device_data); - if (pRenderPassInfo->attachmentCount != framebufferInfo.attachmentCount) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_RENDERPASS, - "You cannot start a render pass using a framebuffer with a different number of attachments."); - } - for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) { - const VkImageView &image_view = framebufferInfo.pAttachments[i]; - auto view_state = GetImageViewState(device_data, image_view); - assert(view_state); - const VkImage &image = view_state->create_info.image; - const VkImageSubresourceRange &subRange = view_state->create_info.subresourceRange; - auto initial_layout = pRenderPassInfo->pAttachments[i].initialLayout; - // TODO: Do not iterate over every possibility - consolidate where possible - for (uint32_t j = 0; j < subRange.levelCount; j++) { - uint32_t level = subRange.baseMipLevel + j; - for (uint32_t k = 0; k < subRange.layerCount; k++) { - uint32_t layer = subRange.baseArrayLayer + k; - VkImageSubresource sub = {subRange.aspectMask, level, layer}; - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (!FindCmdBufLayout(device_data, pCB, image, sub, node)) { - // Missing layouts will be added during state update - continue; - } - if (initial_layout != VK_IMAGE_LAYOUT_UNDEFINED && initial_layout != node.layout) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, - "You cannot start a render pass using attachment %u where the render pass initial layout is %s " - "and the previous known layout of the attachment is %s. The layouts must match, or the render " - "pass initial layout for the attachment must be VK_IMAGE_LAYOUT_UNDEFINED", - i, string_VkImageLayout(initial_layout), string_VkImageLayout(node.layout)); - } - } - } - } - return skip; -} - -void TransitionAttachmentRefLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, FRAMEBUFFER_STATE *pFramebuffer, - VkAttachmentReference ref) { - if (ref.attachment != VK_ATTACHMENT_UNUSED) { - auto image_view = pFramebuffer->createInfo.pAttachments[ref.attachment]; - SetImageViewLayout(device_data, pCB, image_view, ref.layout); - } -} - -void TransitionSubpassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, const RENDER_PASS_STATE *render_pass_state, - const int subpass_index, FRAMEBUFFER_STATE *framebuffer_state) { - assert(render_pass_state); - - if (framebuffer_state) { - auto const &subpass = render_pass_state->createInfo.pSubpasses[subpass_index]; - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, subpass.pInputAttachments[j]); - } - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, subpass.pColorAttachments[j]); - } - if (subpass.pDepthStencilAttachment) { - TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, *subpass.pDepthStencilAttachment); - } - } -} - -bool ValidateImageAspectLayout(layer_data *device_data, GLOBAL_CB_NODE const *pCB, const VkImageMemoryBarrier *mem_barrier, - uint32_t level, uint32_t layer, VkImageAspectFlags aspect) { - if (!(mem_barrier->subresourceRange.aspectMask & aspect)) { - return false; - } - VkImageSubresource sub = {aspect, level, layer}; - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (!FindCmdBufLayout(device_data, pCB, mem_barrier->image, sub, node)) { - return false; - } - bool skip = false; - if (mem_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) { - // TODO: Set memory invalid which is in mem_tracker currently - } else if (node.layout != mem_barrier->oldLayout) { - skip = - log_msg(core_validation::GetReportData(device_data), VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(pCB->commandBuffer), VALIDATION_ERROR_0a00095a, - "For image 0x%" PRIx64 - " you cannot transition the layout of aspect=%d level=%d layer=%d from %s when current layout is %s.", - HandleToUint64(mem_barrier->image), aspect, level, layer, string_VkImageLayout(mem_barrier->oldLayout), - string_VkImageLayout(node.layout)); - } - return skip; -} - -// Transition the layout state for renderpass attachments based on the BeginRenderPass() call. This includes: -// 1. Transition into initialLayout state -// 2. Transition from initialLayout to layout used in subpass 0 -void TransitionBeginRenderPassLayouts(layer_data *device_data, GLOBAL_CB_NODE *cb_state, const RENDER_PASS_STATE *render_pass_state, - FRAMEBUFFER_STATE *framebuffer_state) { - // First transition into initialLayout - auto const rpci = render_pass_state->createInfo.ptr(); - for (uint32_t i = 0; i < rpci->attachmentCount; ++i) { - VkImageView image_view = framebuffer_state->createInfo.pAttachments[i]; - SetImageViewLayout(device_data, cb_state, image_view, rpci->pAttachments[i].initialLayout); - } - // Now transition for first subpass (index 0) - TransitionSubpassLayouts(device_data, cb_state, render_pass_state, 0, framebuffer_state); -} - -void TransitionImageAspectLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, const VkImageMemoryBarrier *mem_barrier, - uint32_t level, uint32_t layer, VkImageAspectFlags aspect) { - if (!(mem_barrier->subresourceRange.aspectMask & aspect)) { - return; - } - VkImageSubresource sub = {aspect, level, layer}; - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (!FindCmdBufLayout(device_data, pCB, mem_barrier->image, sub, node)) { - pCB->image_layout_change_count++; // Change the version of this data to force revalidation - SetLayout(device_data, pCB, mem_barrier->image, sub, - IMAGE_CMD_BUF_LAYOUT_NODE(mem_barrier->oldLayout, mem_barrier->newLayout)); - return; - } - if (mem_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) { - // TODO: Set memory invalid - } - SetLayout(device_data, pCB, mem_barrier->image, sub, mem_barrier->newLayout); -} - -bool VerifyAspectsPresent(VkImageAspectFlags aspect_mask, VkFormat format) { - if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0) { - if (!(FormatIsColor(format) || FormatIsMultiplane(format))) return false; - } - if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != 0) { - if (!FormatHasDepth(format)) return false; - } - if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != 0) { - if (!FormatHasStencil(format)) return false; - } - if (0 != - (aspect_mask & (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR))) { - if (FormatPlaneCount(format) == 1) return false; - } - return true; -} - -// Verify an ImageMemoryBarrier's old/new ImageLayouts are compatible with the Image's ImageUsageFlags. -bool ValidateBarrierLayoutToImageUsage(layer_data *device_data, const VkImageMemoryBarrier *img_barrier, bool new_not_old, - VkImageUsageFlags usage_flags, const char *func_name) { - const auto report_data = core_validation::GetReportData(device_data); - bool skip = false; - const VkImageLayout layout = (new_not_old) ? img_barrier->newLayout : img_barrier->oldLayout; - UNIQUE_VALIDATION_ERROR_CODE msg_code = VALIDATION_ERROR_UNDEFINED; // sentinel value meaning "no error" - - switch (layout) { - case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: - if ((usage_flags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) == 0) { - msg_code = VALIDATION_ERROR_0a000970; - } - break; - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: - if ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0) { - msg_code = VALIDATION_ERROR_0a000972; - } - break; - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: - if ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0) { - msg_code = VALIDATION_ERROR_0a000974; - } - break; - case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: - if ((usage_flags & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) == 0) { - msg_code = VALIDATION_ERROR_0a000976; - } - break; - case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: - if ((usage_flags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) == 0) { - msg_code = VALIDATION_ERROR_0a000978; - } - break; - case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: - if ((usage_flags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) == 0) { - msg_code = VALIDATION_ERROR_0a00097a; - } - break; - default: - // Other VkImageLayout values do not have VUs defined in this context. - break; - } - - if (msg_code != VALIDATION_ERROR_UNDEFINED) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(img_barrier->image), msg_code, - "%s: Image barrier 0x%p %sLayout=%s is not compatible with image 0x%" PRIx64 " usage flags 0x%" PRIx32 ".", - func_name, static_cast(img_barrier), ((new_not_old) ? "new" : "old"), - string_VkImageLayout(layout), HandleToUint64(img_barrier->image), usage_flags); - } - return skip; -} - -// Verify image barriers are compatible with the images they reference. -bool ValidateBarriersToImages(layer_data *device_data, GLOBAL_CB_NODE const *cb_state, uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier *pImageMemoryBarriers, const char *func_name) { - bool skip = false; - - for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { - auto img_barrier = &pImageMemoryBarriers[i]; - if (!img_barrier) continue; - - auto image_state = GetImageState(device_data, img_barrier->image); - if (image_state) { - VkImageUsageFlags usage_flags = image_state->createInfo.usage; - skip |= ValidateBarrierLayoutToImageUsage(device_data, img_barrier, false, usage_flags, func_name); - skip |= ValidateBarrierLayoutToImageUsage(device_data, img_barrier, true, usage_flags, func_name); - - // Make sure layout is able to be transitioned, currently only presented shared presentable images are locked - if (image_state->layout_locked) { - // TODO: Add unique id for error when available - skip |= log_msg( - core_validation::GetReportData(device_data), VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 0, - "Attempting to transition shared presentable image 0x%" PRIx64 - " from layout %s to layout %s, but image has already been presented and cannot have its layout transitioned.", - HandleToUint64(img_barrier->image), string_VkImageLayout(img_barrier->oldLayout), - string_VkImageLayout(img_barrier->newLayout)); - } - } - - VkImageCreateInfo *image_create_info = &(GetImageState(device_data, img_barrier->image)->createInfo); - // For a Depth/Stencil image both aspects MUST be set - if (FormatIsDepthAndStencil(image_create_info->format)) { - auto const aspect_mask = img_barrier->subresourceRange.aspectMask; - auto const ds_mask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; - if ((aspect_mask & ds_mask) != (ds_mask)) { - skip |= - log_msg(core_validation::GetReportData(device_data), VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(img_barrier->image), VALIDATION_ERROR_0a00096e, - "%s: Image barrier 0x%p references image 0x%" PRIx64 - " of format %s that must have the depth and stencil aspects set, but its aspectMask is 0x%" PRIx32 ".", - func_name, static_cast(img_barrier), HandleToUint64(img_barrier->image), - string_VkFormat(image_create_info->format), aspect_mask); - } - } - uint32_t level_count = ResolveRemainingLevels(&img_barrier->subresourceRange, image_create_info->mipLevels); - uint32_t layer_count = ResolveRemainingLayers(&img_barrier->subresourceRange, image_create_info->arrayLayers); - - for (uint32_t j = 0; j < level_count; j++) { - uint32_t level = img_barrier->subresourceRange.baseMipLevel + j; - for (uint32_t k = 0; k < layer_count; k++) { - uint32_t layer = img_barrier->subresourceRange.baseArrayLayer + k; - skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_COLOR_BIT); - skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_DEPTH_BIT); - skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_STENCIL_BIT); - skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_METADATA_BIT); - if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, - VK_IMAGE_ASPECT_PLANE_0_BIT_KHR); - skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, - VK_IMAGE_ASPECT_PLANE_1_BIT_KHR); - skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, - VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - } - } - } - return skip; -} - -static bool IsReleaseOp(layer_data *device_data, GLOBAL_CB_NODE *cb_state, VkImageMemoryBarrier const *barrier) { - if (!IsTransferOp(barrier)) return false; - - auto pool = GetCommandPoolNode(device_data, cb_state->createInfo.commandPool); - return pool && IsReleaseOp(pool, barrier); -} - -void TransitionImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t memBarrierCount, - const VkImageMemoryBarrier *pImgMemBarriers) { - for (uint32_t i = 0; i < memBarrierCount; ++i) { - auto mem_barrier = &pImgMemBarriers[i]; - if (!mem_barrier) continue; - - // For ownership transfers, the barrier is specified twice; as a release - // operation on the yielding queue family, and as an acquire operation - // on the acquiring queue family. This barrier may also include a layout - // transition, which occurs 'between' the two operations. For validation - // purposes it doesn't seem important which side performs the layout - // transition, but it must not be performed twice. We'll arbitrarily - // choose to perform it as part of the acquire operation. - if (IsReleaseOp(device_data, cb_state, mem_barrier)) { - continue; - } - - VkImageCreateInfo *image_create_info = &(GetImageState(device_data, mem_barrier->image)->createInfo); - uint32_t level_count = ResolveRemainingLevels(&mem_barrier->subresourceRange, image_create_info->mipLevels); - uint32_t layer_count = ResolveRemainingLayers(&mem_barrier->subresourceRange, image_create_info->arrayLayers); - - // Special case for 3D images with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR flag bit, where and - // can potentially alias. When recording layout for the entire image, pre-emptively record layouts - // for all (potential) layer sub_resources. - if ((0 != (image_create_info->flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR)) && - (mem_barrier->subresourceRange.baseArrayLayer == 0) && (layer_count == 1)) { - layer_count = image_create_info->extent.depth; // Treat each depth slice as a layer subresource - } - - for (uint32_t j = 0; j < level_count; j++) { - uint32_t level = mem_barrier->subresourceRange.baseMipLevel + j; - for (uint32_t k = 0; k < layer_count; k++) { - uint32_t layer = mem_barrier->subresourceRange.baseArrayLayer + k; - TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_COLOR_BIT); - TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_DEPTH_BIT); - TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_STENCIL_BIT); - TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_METADATA_BIT); - if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR); - TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR); - TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - } - } - } -} - -bool VerifyImageLayout(layer_data const *device_data, GLOBAL_CB_NODE const *cb_node, IMAGE_STATE *image_state, - VkImageSubresourceLayers subLayers, VkImageLayout explicit_layout, VkImageLayout optimal_layout, - const char *caller, UNIQUE_VALIDATION_ERROR_CODE msg_code, bool *error) { - const auto report_data = core_validation::GetReportData(device_data); - const auto image = image_state->image; - bool skip = false; - - for (uint32_t i = 0; i < subLayers.layerCount; ++i) { - uint32_t layer = i + subLayers.baseArrayLayer; - VkImageSubresource sub = {subLayers.aspectMask, subLayers.mipLevel, layer}; - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (FindCmdBufLayout(device_data, cb_node, image, sub, node)) { - if (node.layout != explicit_layout) { - *error = true; - // TODO: Improve log message in the next pass - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_LAYOUT, - "%s: Cannot use image 0x%" PRIx64 " with specific layout %s that doesn't match the actual current layout %s.", - caller, HandleToUint64(image), string_VkImageLayout(explicit_layout), string_VkImageLayout(node.layout)); - } - } - } - // If optimal_layout is not UNDEFINED, check that layout matches optimal for this case - if ((VK_IMAGE_LAYOUT_UNDEFINED != optimal_layout) && (explicit_layout != optimal_layout)) { - if (VK_IMAGE_LAYOUT_GENERAL == explicit_layout) { - if (image_state->createInfo.tiling != VK_IMAGE_TILING_LINEAR) { - // LAYOUT_GENERAL is allowed, but may not be performance optimal, flag as perf warning. - skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(cb_node->commandBuffer), - DRAWSTATE_INVALID_IMAGE_LAYOUT, - "%s: For optimal performance image 0x%" PRIx64 " layout should be %s instead of GENERAL.", caller, - HandleToUint64(image), string_VkImageLayout(optimal_layout)); - } - } else if (GetDeviceExtensions(device_data)->vk_khr_shared_presentable_image) { - if (image_state->shared_presentable) { - if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR != explicit_layout) { - // TODO: Add unique error id when available. - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, msg_code, - "Layout for shared presentable image is %s but must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.", - string_VkImageLayout(optimal_layout)); - } - } - } else { - *error = true; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), msg_code, - "%s: Layout for image 0x%" PRIx64 " is %s but can only be %s or VK_IMAGE_LAYOUT_GENERAL.", caller, - HandleToUint64(image), string_VkImageLayout(explicit_layout), string_VkImageLayout(optimal_layout)); - } - } - return skip; -} - -void TransitionFinalSubpassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin, - FRAMEBUFFER_STATE *framebuffer_state) { - auto renderPass = GetRenderPassState(device_data, pRenderPassBegin->renderPass); - if (!renderPass) return; - - const VkRenderPassCreateInfo *pRenderPassInfo = renderPass->createInfo.ptr(); - if (framebuffer_state) { - for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) { - auto image_view = framebuffer_state->createInfo.pAttachments[i]; - SetImageViewLayout(device_data, pCB, image_view, pRenderPassInfo->pAttachments[i].finalLayout); - } - } -} - -bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkImage *pImage) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - if (pCreateInfo->format == VK_FORMAT_UNDEFINED) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0075e, "vkCreateImage: VkFormat for image must not be VK_FORMAT_UNDEFINED."); - - return skip; - } - - const char *format_string = string_VkFormat(pCreateInfo->format); - - if ((pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && (VK_IMAGE_TYPE_2D != pCreateInfo->imageType)) { - std::stringstream ss; - ss << "vkCreateImage: Image type must be VK_IMAGE_TYPE_2D when VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT flag bit is set"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0076a, "%s.", ss.str().c_str()); - } - - const VkPhysicalDeviceLimits *device_limits = &(GetPhysicalDeviceProperties(device_data)->limits); - VkImageFormatProperties format_limits; // Format limits may exceed general device limits - VkResult err = GetImageFormatProperties(device_data, pCreateInfo, &format_limits); - if (VK_SUCCESS != err) { - std::stringstream ss; - ss << "vkCreateImage: The combination of format, type, tiling, usage and flags supplied in the VkImageCreateInfo struct is " - "reported by vkGetPhysicalDeviceImageFormatProperties() as unsupported"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00758, "%s.", ss.str().c_str()); - return skip; - } - - if ((VK_IMAGE_TYPE_1D == pCreateInfo->imageType) && - (pCreateInfo->extent.width > std::max(device_limits->maxImageDimension1D, format_limits.maxExtent.width))) { - std::stringstream ss; - ss << "vkCreateImage: 1D image width exceeds maximum supported width for format " << format_string; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0076e, "%s.", ss.str().c_str()); - } - - if (VK_IMAGE_TYPE_2D == pCreateInfo->imageType) { - if (0 == (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) { - if (pCreateInfo->extent.width > std::max(device_limits->maxImageDimension2D, format_limits.maxExtent.width) || - pCreateInfo->extent.height > std::max(device_limits->maxImageDimension2D, format_limits.maxExtent.height)) { - std::stringstream ss; - ss << "vkCreateImage: 2D image extent exceeds maximum supported width or height for format " << format_string; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00770, "%s.", ss.str().c_str()); - } - } else { - if (pCreateInfo->extent.width > std::max(device_limits->maxImageDimensionCube, format_limits.maxExtent.width) || - pCreateInfo->extent.height > std::max(device_limits->maxImageDimensionCube, format_limits.maxExtent.height)) { - std::stringstream ss; - ss << "vkCreateImage: 2D image extent exceeds maximum supported width or height for cube-compatible images with " - "format " - << format_string; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00772, "%s.", ss.str().c_str()); - } - } - } - - if (VK_IMAGE_TYPE_3D == pCreateInfo->imageType) { - if ((pCreateInfo->extent.width > std::max(device_limits->maxImageDimension3D, format_limits.maxExtent.width)) || - (pCreateInfo->extent.height > std::max(device_limits->maxImageDimension3D, format_limits.maxExtent.height)) || - (pCreateInfo->extent.depth > std::max(device_limits->maxImageDimension3D, format_limits.maxExtent.depth))) { - std::stringstream ss; - ss << "vkCreateImage: 3D image extent exceeds maximum supported width, height, or depth for format " << format_string; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00776, "%s.", ss.str().c_str()); - } - } - - // NOTE: As of 1/30/2018 the spec VU language is as in the commented code below. I believe this is an - // error in the spec, and have submitted Gitlab Vulkan issue #1151 to have it changed to match the - // implementation shown. DJH - // - // if ((pCreateInfo->mipLevels > format_limits.maxMipLevels) && - // (std::max({ pCreateInfo->extent.width, pCreateInfo->extent.height, pCreateInfo->extent.depth }) > - // device_limits->maxImageDimension3D)) { - if (pCreateInfo->mipLevels > format_limits.maxMipLevels) { - std::stringstream ss; - ss << "vkCreateImage: Image mip levels exceed image format maxMipLevels for format " << format_string; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0077e, "%s.", ss.str().c_str()); - } - - VkImageUsageFlags attach_flags = 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; - if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.width > device_limits->maxFramebufferWidth)) { - std::stringstream ss; - ss << "vkCreateImage: Image usage flags include a frame buffer attachment bit and image width exceeds device " - "maxFramebufferWidth"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00788, "%s.", ss.str().c_str()); - } - - if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.height > device_limits->maxFramebufferHeight)) { - std::stringstream ss; - ss << "vkCreateImage: Image usage flags include a frame buffer attachment bit and image height exceeds device " - "maxFramebufferHeight"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0078a, "%s.", ss.str().c_str()); - } - - uint64_t total_size = (uint64_t)pCreateInfo->extent.width * (uint64_t)pCreateInfo->extent.height * - (uint64_t)pCreateInfo->extent.depth * (uint64_t)pCreateInfo->arrayLayers * - (uint64_t)pCreateInfo->samples * (uint64_t)FormatSize(pCreateInfo->format); - - // Round up to imageGranularity boundary - VkDeviceSize imageGranularity = GetPhysicalDeviceProperties(device_data)->limits.bufferImageGranularity; - uint64_t ig_mask = imageGranularity - 1; - total_size = (total_size + ig_mask) & ~ig_mask; - - if (total_size > format_limits.maxResourceSize) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, - IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, - "CreateImage resource size exceeds allowable maximum Image resource size = 0x%" PRIxLEAST64 - ", maximum resource size = 0x%" PRIxLEAST64 " ", - total_size, format_limits.maxResourceSize); - } - - if (pCreateInfo->arrayLayers > format_limits.maxArrayLayers) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, VALIDATION_ERROR_09e00780, - "CreateImage arrayLayers=%d exceeds allowable maximum supported by format of %d.", pCreateInfo->arrayLayers, - format_limits.maxArrayLayers); - } - - if ((pCreateInfo->samples & format_limits.sampleCounts) == 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, - VALIDATION_ERROR_09e0078e, "CreateImage samples %s is not supported by format 0x%.8X.", - string_VkSampleCountFlagBits(pCreateInfo->samples), format_limits.sampleCounts); - } - - if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) && (!GetEnabledFeatures(device_data)->sparseResidencyAliased)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_FEATURE, - "vkCreateImage(): the sparseResidencyAliased device feature is disabled: Images cannot be created with the " - "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT set."); - } - - if (GetDeviceExtensions(device_data)->vk_khr_maintenance2) { - if (pCreateInfo->flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR) { - if (!(FormatIsCompressed_BC(pCreateInfo->format) || FormatIsCompressed_ASTC_LDR(pCreateInfo->format) || - FormatIsCompressed_ETC2_EAC(pCreateInfo->format))) { - // TODO: Add Maintenance2 VUID - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_UNDEFINED, - "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, " - "format must be block, ETC or ASTC compressed, but is %s", - string_VkFormat(pCreateInfo->format)); - } - if (!(pCreateInfo->flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT)) { - // TODO: Add Maintenance2 VUID - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_UNDEFINED, - "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, " - "flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT."); - } - } - } - - return skip; -} - -void PostCallRecordCreateImage(layer_data *device_data, const VkImageCreateInfo *pCreateInfo, VkImage *pImage) { - IMAGE_LAYOUT_NODE image_state; - image_state.layout = pCreateInfo->initialLayout; - image_state.format = pCreateInfo->format; - GetImageMap(device_data)->insert(std::make_pair(*pImage, std::unique_ptr(new IMAGE_STATE(*pImage, pCreateInfo)))); - ImageSubresourcePair subpair{*pImage, false, VkImageSubresource()}; - (*core_validation::GetImageSubresourceMap(device_data))[*pImage].push_back(subpair); - (*core_validation::GetImageLayoutMap(device_data))[subpair] = image_state; -} - -bool PreCallValidateDestroyImage(layer_data *device_data, VkImage image, IMAGE_STATE **image_state, VK_OBJECT *obj_struct) { - const CHECK_DISABLED *disabled = core_validation::GetDisables(device_data); - *image_state = core_validation::GetImageState(device_data, image); - *obj_struct = {HandleToUint64(image), kVulkanObjectTypeImage}; - if (disabled->destroy_image) return false; - bool skip = false; - if (*image_state) { - skip |= core_validation::ValidateObjectNotInUse(device_data, *image_state, *obj_struct, "vkDestroyImage", - VALIDATION_ERROR_252007d0); - } - return skip; -} - -void PreCallRecordDestroyImage(layer_data *device_data, VkImage image, IMAGE_STATE *image_state, VK_OBJECT obj_struct) { - core_validation::invalidateCommandBuffers(device_data, image_state->cb_bindings, obj_struct); - // Clean up memory mapping, bindings and range references for image - for (auto mem_binding : image_state->GetBoundMemory()) { - auto mem_info = core_validation::GetMemObjInfo(device_data, mem_binding); - if (mem_info) { - core_validation::RemoveImageMemoryRange(obj_struct.handle, mem_info); - } - } - core_validation::ClearMemoryObjectBindings(device_data, obj_struct.handle, kVulkanObjectTypeImage); - // Remove image from imageMap - core_validation::GetImageMap(device_data)->erase(image); - std::unordered_map> *imageSubresourceMap = - core_validation::GetImageSubresourceMap(device_data); - - const auto &sub_entry = imageSubresourceMap->find(image); - if (sub_entry != imageSubresourceMap->end()) { - for (const auto &pair : sub_entry->second) { - core_validation::GetImageLayoutMap(device_data)->erase(pair); - } - imageSubresourceMap->erase(sub_entry); - } -} - -bool ValidateImageAttributes(layer_data *device_data, IMAGE_STATE *image_state, VkImageSubresourceRange range) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - if (range.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) { - char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), DRAWSTATE_INVALID_IMAGE_ASPECT, str); - } - - if (FormatIsDepthOrStencil(image_state->createInfo.format)) { - char const str[] = "vkCmdClearColorImage called with depth/stencil image."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_1880000e, "%s.", str); - } else if (FormatIsCompressed(image_state->createInfo.format)) { - char const str[] = "vkCmdClearColorImage called with compressed image."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_1880000e, "%s.", str); - } - - if (!(image_state->createInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) { - char const str[] = "vkCmdClearColorImage called with image created without VK_IMAGE_USAGE_TRANSFER_DST_BIT."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_18800004, "%s.", str); - } - return skip; -} - -uint32_t ResolveRemainingLevels(const VkImageSubresourceRange *range, uint32_t mip_levels) { - // Return correct number of mip levels taking into account VK_REMAINING_MIP_LEVELS - uint32_t mip_level_count = range->levelCount; - if (range->levelCount == VK_REMAINING_MIP_LEVELS) { - mip_level_count = mip_levels - range->baseMipLevel; - } - return mip_level_count; -} - -uint32_t ResolveRemainingLayers(const VkImageSubresourceRange *range, uint32_t layers) { - // Return correct number of layers taking into account VK_REMAINING_ARRAY_LAYERS - uint32_t array_layer_count = range->layerCount; - if (range->layerCount == VK_REMAINING_ARRAY_LAYERS) { - array_layer_count = layers - range->baseArrayLayer; - } - return array_layer_count; -} - -bool VerifyClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *image_state, - VkImageSubresourceRange range, VkImageLayout dest_image_layout, const char *func_name) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - uint32_t level_count = ResolveRemainingLevels(&range, image_state->createInfo.mipLevels); - uint32_t layer_count = ResolveRemainingLayers(&range, image_state->createInfo.arrayLayers); - - if (dest_image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) { - if (dest_image_layout == VK_IMAGE_LAYOUT_GENERAL) { - if (image_state->createInfo.tiling != VK_IMAGE_TILING_LINEAR) { - // LAYOUT_GENERAL is allowed, but may not be performance optimal, flag as perf warning. - skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), DRAWSTATE_INVALID_IMAGE_LAYOUT, - "%s: Layout for cleared image should be TRANSFER_DST_OPTIMAL instead of GENERAL.", func_name); - } - } else if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR == dest_image_layout) { - if (!GetDeviceExtensions(device_data)->vk_khr_shared_presentable_image) { - // TODO: Add unique error id when available. - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), 0, - "Must enable VK_KHR_shared_presentable_image extension before creating images with a layout type " - "of VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR."); - - } else { - if (image_state->shared_presentable) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), 0, - "Layout for shared presentable cleared image is %s but can only be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.", - string_VkImageLayout(dest_image_layout)); - } - } - } else { - UNIQUE_VALIDATION_ERROR_CODE error_code = VALIDATION_ERROR_1880000a; - if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) { - error_code = VALIDATION_ERROR_18a00018; - } else { - assert(strcmp(func_name, "vkCmdClearColorImage()") == 0); - } - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), error_code, - "%s: Layout for cleared image is %s but can only be TRANSFER_DST_OPTIMAL or GENERAL.", func_name, - string_VkImageLayout(dest_image_layout)); - } - } - - for (uint32_t level_index = 0; level_index < level_count; ++level_index) { - uint32_t level = level_index + range.baseMipLevel; - for (uint32_t layer_index = 0; layer_index < layer_count; ++layer_index) { - uint32_t layer = layer_index + range.baseArrayLayer; - VkImageSubresource sub = {range.aspectMask, level, layer}; - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (FindCmdBufLayout(device_data, cb_node, image_state->image, sub, node)) { - if (node.layout != dest_image_layout) { - UNIQUE_VALIDATION_ERROR_CODE error_code = VALIDATION_ERROR_18800008; - if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) { - error_code = VALIDATION_ERROR_18a00016; - } else { - assert(strcmp(func_name, "vkCmdClearColorImage()") == 0); - } - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - error_code, "%s: Cannot clear an image whose layout is %s and doesn't match the current layout %s.", - func_name, string_VkImageLayout(dest_image_layout), string_VkImageLayout(node.layout)); - } - } - } - } - - return skip; -} - -void RecordClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, VkImage image, VkImageSubresourceRange range, - VkImageLayout dest_image_layout) { - VkImageCreateInfo *image_create_info = &(GetImageState(device_data, image)->createInfo); - uint32_t level_count = ResolveRemainingLevels(&range, image_create_info->mipLevels); - uint32_t layer_count = ResolveRemainingLayers(&range, image_create_info->arrayLayers); - - for (uint32_t level_index = 0; level_index < level_count; ++level_index) { - uint32_t level = level_index + range.baseMipLevel; - for (uint32_t layer_index = 0; layer_index < layer_count; ++layer_index) { - uint32_t layer = layer_index + range.baseArrayLayer; - VkImageSubresource sub = {range.aspectMask, level, layer}; - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (!FindCmdBufLayout(device_data, cb_node, image, sub, node)) { - SetLayout(device_data, cb_node, image, sub, IMAGE_CMD_BUF_LAYOUT_NODE(dest_image_layout, dest_image_layout)); - } - } - } -} - -bool PreCallValidateCmdClearColorImage(layer_data *dev_data, VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - bool skip = false; - // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state - auto cb_node = GetCBNode(dev_data, commandBuffer); - auto image_state = GetImageState(dev_data, image); - if (cb_node && image_state) { - skip |= ValidateMemoryIsBoundToImage(dev_data, image_state, "vkCmdClearColorImage()", VALIDATION_ERROR_18800006); - skip |= ValidateCmdQueueFlags(dev_data, cb_node, "vkCmdClearColorImage()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_18802415); - skip |= ValidateCmd(dev_data, cb_node, CMD_CLEARCOLORIMAGE, "vkCmdClearColorImage()"); - if (GetApiVersion(dev_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(dev_data)->vk_khr_maintenance1) { - skip |= ValidateImageFormatFeatureFlags(dev_data, image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - "vkCmdClearColorImage", VALIDATION_ERROR_18800002, VALIDATION_ERROR_18800002); - } - skip |= insideRenderPass(dev_data, cb_node, "vkCmdClearColorImage()", VALIDATION_ERROR_18800017); - for (uint32_t i = 0; i < rangeCount; ++i) { - std::string param_name = "pRanges[" + std::to_string(i) + "]"; - skip |= ValidateCmdClearColorSubresourceRange(dev_data, image_state, pRanges[i], param_name.c_str()); - skip |= ValidateImageAttributes(dev_data, image_state, pRanges[i]); - skip |= VerifyClearImageLayout(dev_data, cb_node, image_state, pRanges[i], imageLayout, "vkCmdClearColorImage()"); - } - } - return skip; -} - -// This state recording routine is shared between ClearColorImage and ClearDepthStencilImage -void PreCallRecordCmdClearImage(layer_data *dev_data, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, - uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - auto cb_node = GetCBNode(dev_data, commandBuffer); - auto image_state = GetImageState(dev_data, image); - if (cb_node && image_state) { - AddCommandBufferBindingImage(dev_data, cb_node, image_state); - for (uint32_t i = 0; i < rangeCount; ++i) { - RecordClearImageLayout(dev_data, cb_node, image, pRanges[i], imageLayout); - } - } -} - -bool PreCallValidateCmdClearDepthStencilImage(layer_data *device_data, VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, uint32_t rangeCount, - const VkImageSubresourceRange *pRanges) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state - auto cb_node = GetCBNode(device_data, commandBuffer); - auto image_state = GetImageState(device_data, image); - if (cb_node && image_state) { - skip |= ValidateMemoryIsBoundToImage(device_data, image_state, "vkCmdClearDepthStencilImage()", VALIDATION_ERROR_18a00014); - skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdClearDepthStencilImage()", VK_QUEUE_GRAPHICS_BIT, - VALIDATION_ERROR_18a02415); - skip |= ValidateCmd(device_data, cb_node, CMD_CLEARDEPTHSTENCILIMAGE, "vkCmdClearDepthStencilImage()"); - if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - skip |= ValidateImageFormatFeatureFlags(device_data, image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - "vkCmdClearDepthStencilImage", VALIDATION_ERROR_18a00010, - VALIDATION_ERROR_18a00010); - } - skip |= insideRenderPass(device_data, cb_node, "vkCmdClearDepthStencilImage()", VALIDATION_ERROR_18a00017); - for (uint32_t i = 0; i < rangeCount; ++i) { - std::string param_name = "pRanges[" + std::to_string(i) + "]"; - skip |= ValidateCmdClearDepthSubresourceRange(device_data, image_state, pRanges[i], param_name.c_str()); - skip |= - VerifyClearImageLayout(device_data, cb_node, image_state, pRanges[i], imageLayout, "vkCmdClearDepthStencilImage()"); - // Image aspect must be depth or stencil or both - if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) && - ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) { - char const str[] = - "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_DEPTH_BIT " - "and/or VK_IMAGE_ASPECT_STENCIL_BIT"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT, str); - } - } - if (image_state && !FormatIsDepthOrStencil(image_state->createInfo.format)) { - char const str[] = "vkCmdClearDepthStencilImage called without a depth/stencil image."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_18a0001c, "%s.", str); - } - if (VK_IMAGE_USAGE_TRANSFER_DST_BIT != (VK_IMAGE_USAGE_TRANSFER_DST_BIT & image_state->createInfo.usage)) { - char const str[] = - "vkCmdClearDepthStencilImage() called with an image that was not created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT " - "set."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_18a00012, "%s.", str); - } - } - return skip; -} - -// Returns true if [x, xoffset] and [y, yoffset] overlap -static bool RangesIntersect(int32_t start, uint32_t start_offset, int32_t end, uint32_t end_offset) { - bool result = false; - uint32_t intersection_min = std::max(static_cast(start), static_cast(end)); - uint32_t intersection_max = std::min(static_cast(start) + start_offset, static_cast(end) + end_offset); - - if (intersection_max > intersection_min) { - result = true; - } - return result; -} - -// Returns true if source area of first copy region intersects dest area of second region -// It is assumed that these are copy regions within a single image (otherwise no possibility of collision) -static bool RegionIntersects(const VkImageCopy *rgn0, const VkImageCopy *rgn1, VkImageType type, bool is_multiplane) { - bool result = false; - - // Separate planes within a multiplane image cannot intersect - if (is_multiplane && (rgn0->srcSubresource.aspectMask != rgn1->dstSubresource.aspectMask)) { - return result; - } - - if ((rgn0->srcSubresource.mipLevel == rgn1->dstSubresource.mipLevel) && - (RangesIntersect(rgn0->srcSubresource.baseArrayLayer, rgn0->srcSubresource.layerCount, rgn1->dstSubresource.baseArrayLayer, - rgn1->dstSubresource.layerCount))) { - result = true; - switch (type) { - case VK_IMAGE_TYPE_3D: - result &= RangesIntersect(rgn0->srcOffset.z, rgn0->extent.depth, rgn1->dstOffset.z, rgn1->extent.depth); - // fall through - case VK_IMAGE_TYPE_2D: - result &= RangesIntersect(rgn0->srcOffset.y, rgn0->extent.height, rgn1->dstOffset.y, rgn1->extent.height); - // fall through - case VK_IMAGE_TYPE_1D: - result &= RangesIntersect(rgn0->srcOffset.x, rgn0->extent.width, rgn1->dstOffset.x, rgn1->extent.width); - break; - default: - // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation - assert(false); - } - } - return result; -} - -// Returns non-zero if offset and extent exceed image extents -static const uint32_t x_bit = 1; -static const uint32_t y_bit = 2; -static const uint32_t z_bit = 4; -static uint32_t ExceedsBounds(const VkOffset3D *offset, const VkExtent3D *extent, const VkExtent3D *image_extent) { - uint32_t result = 0; - // Extents/depths cannot be negative but checks left in for clarity - if ((offset->z + extent->depth > image_extent->depth) || (offset->z < 0) || - ((offset->z + static_cast(extent->depth)) < 0)) { - result |= z_bit; - } - if ((offset->y + extent->height > image_extent->height) || (offset->y < 0) || - ((offset->y + static_cast(extent->height)) < 0)) { - result |= y_bit; - } - if ((offset->x + extent->width > image_extent->width) || (offset->x < 0) || - ((offset->x + static_cast(extent->width)) < 0)) { - result |= x_bit; - } - return result; -} - -// Test if two VkExtent3D structs are equivalent -static inline bool IsExtentEqual(const VkExtent3D *extent, const VkExtent3D *other_extent) { - bool result = true; - if ((extent->width != other_extent->width) || (extent->height != other_extent->height) || - (extent->depth != other_extent->depth)) { - result = false; - } - return result; -} - -// For image copies between compressed/uncompressed formats, the extent is provided in source image texels -// Destination image texel extents must be adjusted by block size for the dest validation checks -VkExtent3D GetAdjustedDestImageExtent(VkFormat src_format, VkFormat dst_format, VkExtent3D extent) { - VkExtent3D adjusted_extent = extent; - if ((FormatIsCompressed(src_format) && (!FormatIsCompressed(dst_format)))) { - VkExtent3D block_size = FormatCompressedTexelBlockExtent(src_format); - adjusted_extent.width /= block_size.width; - adjusted_extent.height /= block_size.height; - adjusted_extent.depth /= block_size.depth; - } else if ((!FormatIsCompressed(src_format) && (FormatIsCompressed(dst_format)))) { - VkExtent3D block_size = FormatCompressedTexelBlockExtent(dst_format); - adjusted_extent.width *= block_size.width; - adjusted_extent.height *= block_size.height; - adjusted_extent.depth *= block_size.depth; - } - return adjusted_extent; -} - -// Returns the effective extent of an image subresource, adjusted for mip level and array depth. -static inline VkExtent3D GetImageSubresourceExtent(const IMAGE_STATE *img, const VkImageSubresourceLayers *subresource) { - const uint32_t mip = subresource->mipLevel; - - // Return zero extent if mip level doesn't exist - if (mip >= img->createInfo.mipLevels) { - return VkExtent3D{0, 0, 0}; - } - - // Don't allow mip adjustment to create 0 dim, but pass along a 0 if that's what subresource specified - VkExtent3D extent = img->createInfo.extent; - extent.width = (0 == extent.width ? 0 : std::max(1U, extent.width >> mip)); - extent.height = (0 == extent.height ? 0 : std::max(1U, extent.height >> mip)); - extent.depth = (0 == extent.depth ? 0 : std::max(1U, extent.depth >> mip)); - - // Image arrays have an effective z extent that isn't diminished by mip level - if (VK_IMAGE_TYPE_3D != img->createInfo.imageType) { - extent.depth = img->createInfo.arrayLayers; - } - - return extent; -} - -// Test if the extent argument has all dimensions set to 0. -static inline bool IsExtentAllZeroes(const VkExtent3D *extent) { - return ((extent->width == 0) && (extent->height == 0) && (extent->depth == 0)); -} - -// Test if the extent argument has any dimensions set to 0. -static inline bool IsExtentSizeZero(const VkExtent3D *extent) { - return ((extent->width == 0) || (extent->height == 0) || (extent->depth == 0)); -} - -// Returns the image transfer granularity for a specific image scaled by compressed block size if necessary. -static inline VkExtent3D GetScaledItg(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *img) { - // Default to (0, 0, 0) granularity in case we can't find the real granularity for the physical device. - VkExtent3D granularity = {0, 0, 0}; - auto pPool = GetCommandPoolNode(device_data, cb_node->createInfo.commandPool); - if (pPool) { - granularity = - GetPhysDevProperties(device_data)->queue_family_properties[pPool->queueFamilyIndex].minImageTransferGranularity; - if (FormatIsCompressed(img->createInfo.format)) { - auto block_size = FormatCompressedTexelBlockExtent(img->createInfo.format); - granularity.width *= block_size.width; - granularity.height *= block_size.height; - } - } - return granularity; -} - -// Test elements of a VkExtent3D structure against alignment constraints contained in another VkExtent3D structure -static inline bool IsExtentAligned(const VkExtent3D *extent, const VkExtent3D *granularity) { - bool valid = true; - if ((SafeModulo(extent->depth, granularity->depth) != 0) || (SafeModulo(extent->width, granularity->width) != 0) || - (SafeModulo(extent->height, granularity->height) != 0)) { - valid = false; - } - return valid; -} - -// Check elements of a VkOffset3D structure against a queue family's Image Transfer Granularity values -static inline bool CheckItgOffset(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const VkOffset3D *offset, - const VkExtent3D *granularity, const uint32_t i, const char *function, const char *member, - UNIQUE_VALIDATION_ERROR_CODE vuid) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - VkExtent3D offset_extent = {}; - offset_extent.width = static_cast(abs(offset->x)); - offset_extent.height = static_cast(abs(offset->y)); - offset_extent.depth = static_cast(abs(offset->z)); - if (IsExtentAllZeroes(granularity)) { - // If the queue family image transfer granularity is (0, 0, 0), then the offset must always be (0, 0, 0) - if (IsExtentAllZeroes(&offset_extent) == false) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), vuid, - "%s: pRegion[%d].%s (x=%d, y=%d, z=%d) must be (x=0, y=0, z=0) when the command buffer's queue family " - "image transfer granularity is (w=0, h=0, d=0).", - function, i, member, offset->x, offset->y, offset->z); - } - } else { - // If the queue family image transfer granularity is not (0, 0, 0), then the offset dimensions must always be even - // integer multiples of the image transfer granularity. - if (IsExtentAligned(&offset_extent, granularity) == false) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), vuid, - "%s: pRegion[%d].%s (x=%d, y=%d, z=%d) dimensions must be even integer multiples of this command " - "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d).", - function, i, member, offset->x, offset->y, offset->z, granularity->width, granularity->height, - granularity->depth); - } - } - return skip; -} - -// Check elements of a VkExtent3D structure against a queue family's Image Transfer Granularity values -static inline bool CheckItgExtent(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const VkExtent3D *extent, - const VkOffset3D *offset, const VkExtent3D *granularity, const VkExtent3D *subresource_extent, - const VkImageType image_type, const uint32_t i, const char *function, const char *member, - UNIQUE_VALIDATION_ERROR_CODE vuid) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - if (IsExtentAllZeroes(granularity)) { - // If the queue family image transfer granularity is (0, 0, 0), then the extent must always match the image - // subresource extent. - if (IsExtentEqual(extent, subresource_extent) == false) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), vuid, - "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d) " - "when the command buffer's queue family image transfer granularity is (w=0, h=0, d=0).", - function, i, member, extent->width, extent->height, extent->depth, subresource_extent->width, - subresource_extent->height, subresource_extent->depth); - } - } else { - // If the queue family image transfer granularity is not (0, 0, 0), then the extent dimensions must always be even - // integer multiples of the image transfer granularity or the offset + extent dimensions must always match the image - // subresource extent dimensions. - VkExtent3D offset_extent_sum = {}; - offset_extent_sum.width = static_cast(abs(offset->x)) + extent->width; - offset_extent_sum.height = static_cast(abs(offset->y)) + extent->height; - offset_extent_sum.depth = static_cast(abs(offset->z)) + extent->depth; - bool x_ok = true; - bool y_ok = true; - bool z_ok = true; - switch (image_type) { - case VK_IMAGE_TYPE_3D: - z_ok = ((0 == SafeModulo(extent->depth, granularity->depth)) || - (subresource_extent->depth == offset_extent_sum.depth)); - // fall through - case VK_IMAGE_TYPE_2D: - y_ok = ((0 == SafeModulo(extent->height, granularity->height)) || - (subresource_extent->height == offset_extent_sum.height)); - // fall through - case VK_IMAGE_TYPE_1D: - x_ok = ((0 == SafeModulo(extent->width, granularity->width)) || - (subresource_extent->width == offset_extent_sum.width)); - break; - default: - // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation - assert(false); - } - if (!(x_ok && y_ok && z_ok)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), vuid, - "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) dimensions must be even integer multiples of this command " - "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d) or offset (x=%d, y=%d, z=%d) + " - "extent (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d).", - function, i, member, extent->width, extent->height, extent->depth, granularity->width, - granularity->height, granularity->depth, offset->x, offset->y, offset->z, extent->width, extent->height, - extent->depth, subresource_extent->width, subresource_extent->height, subresource_extent->depth); - } - } - return skip; -} - -// Check valid usage Image Transfer Granularity requirements for elements of a VkBufferImageCopy structure -bool ValidateCopyBufferImageTransferGranularityRequirements(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, - const IMAGE_STATE *img, const VkBufferImageCopy *region, - const uint32_t i, const char *function, - UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip = false; - VkExtent3D granularity = GetScaledItg(device_data, cb_node, img); - skip |= CheckItgOffset(device_data, cb_node, ®ion->imageOffset, &granularity, i, function, "imageOffset", vuid); - VkExtent3D subresource_extent = GetImageSubresourceExtent(img, ®ion->imageSubresource); - skip |= CheckItgExtent(device_data, cb_node, ®ion->imageExtent, ®ion->imageOffset, &granularity, &subresource_extent, - img->createInfo.imageType, i, function, "imageExtent", vuid); - return skip; -} - -// Check valid usage Image Transfer Granularity requirements for elements of a VkImageCopy structure -bool ValidateCopyImageTransferGranularityRequirements(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, - const IMAGE_STATE *src_img, const IMAGE_STATE *dst_img, - const VkImageCopy *region, const uint32_t i, const char *function) { - bool skip = false; - // Source image checks - VkExtent3D granularity = GetScaledItg(device_data, cb_node, src_img); - skip |= - CheckItgOffset(device_data, cb_node, ®ion->srcOffset, &granularity, i, function, "srcOffset", VALIDATION_ERROR_19000dee); - VkExtent3D subresource_extent = GetImageSubresourceExtent(src_img, ®ion->srcSubresource); - const VkExtent3D extent = region->extent; - skip |= CheckItgExtent(device_data, cb_node, &extent, ®ion->srcOffset, &granularity, &subresource_extent, - src_img->createInfo.imageType, i, function, "extent", VALIDATION_ERROR_19000dee); - - // Destination image checks - granularity = GetScaledItg(device_data, cb_node, dst_img); - skip |= - CheckItgOffset(device_data, cb_node, ®ion->dstOffset, &granularity, i, function, "dstOffset", VALIDATION_ERROR_19000df0); - // Adjust dest extent, if necessary - const VkExtent3D dest_effective_extent = - GetAdjustedDestImageExtent(src_img->createInfo.format, dst_img->createInfo.format, extent); - subresource_extent = GetImageSubresourceExtent(dst_img, ®ion->dstSubresource); - skip |= CheckItgExtent(device_data, cb_node, &dest_effective_extent, ®ion->dstOffset, &granularity, &subresource_extent, - dst_img->createInfo.imageType, i, function, "extent", VALIDATION_ERROR_19000df0); - return skip; -} - -// Validate contents of a VkImageCopy struct -bool ValidateImageCopyData(const layer_data *device_data, const debug_report_data *report_data, const uint32_t regionCount, - const VkImageCopy *ic_regions, const IMAGE_STATE *src_state, const IMAGE_STATE *dst_state) { - bool skip = false; - - for (uint32_t i = 0; i < regionCount; i++) { - const VkImageCopy region = ic_regions[i]; - - // For comp<->uncomp copies, the copy extent for the dest image must be adjusted - const VkExtent3D src_copy_extent = region.extent; - const VkExtent3D dst_copy_extent = - GetAdjustedDestImageExtent(src_state->createInfo.format, dst_state->createInfo.format, region.extent); - - bool slice_override = false; - uint32_t depth_slices = 0; - - // Special case for copying between a 1D/2D array and a 3D image - // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up. - if ((VK_IMAGE_TYPE_3D == src_state->createInfo.imageType) && (VK_IMAGE_TYPE_3D != dst_state->createInfo.imageType)) { - depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource - slice_override = (depth_slices != 1); - } else if ((VK_IMAGE_TYPE_3D == dst_state->createInfo.imageType) && (VK_IMAGE_TYPE_3D != src_state->createInfo.imageType)) { - depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource - slice_override = (depth_slices != 1); - } - - // Do all checks on source image - // - if (src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) { - if ((0 != region.srcOffset.y) || (1 != src_copy_extent.height)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), VALIDATION_ERROR_09c00124, - "vkCmdCopyImage(): pRegion[%d] srcOffset.y is %d and extent.height is %d. For 1D images these must " - "be 0 and 1, respectively.", - i, region.srcOffset.y, src_copy_extent.height); - } - } - - // VUID-VkImageCopy-srcImage-01785 - if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.srcOffset.z) || (1 != src_copy_extent.depth))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), VALIDATION_ERROR_09c00df2, - "vkCmdCopyImage(): pRegion[%d] srcOffset.z is %d and extent.depth is %d. For 1D images " - "these must be 0 and 1, respectively.", - i, region.srcOffset.z, src_copy_extent.depth); - } - - // VUID-VkImageCopy-srcImage-01787 - if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.srcOffset.z)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), VALIDATION_ERROR_09c00df6, - "vkCmdCopyImage(): pRegion[%d] srcOffset.z is %d. For 2D images the z-offset must be 0.", i, - region.srcOffset.z); - } - - if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D) { - if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), VALIDATION_ERROR_09c0011a, - "vkCmdCopyImage(): pRegion[%d] srcSubresource.baseArrayLayer is %d and srcSubresource.layerCount " - "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.", - i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount); - } - } - } else { // Pre maint 1 - if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D || dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) { - if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), VALIDATION_ERROR_09c0011a, - "vkCmdCopyImage(): pRegion[%d] srcSubresource.baseArrayLayer is %d and " - "srcSubresource.layerCount is %d. For copies with either source or dest of type " - "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.", - i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount); - } - } - } - - // Source checks that apply only to compressed images (or to _422 images if ycbcr enabled) - bool ext_ycbcr = GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion; - if (FormatIsCompressed(src_state->createInfo.format) || - (ext_ycbcr && FormatIsSinglePlane_422(src_state->createInfo.format))) { - const VkExtent3D block_size = FormatCompressedTexelBlockExtent(src_state->createInfo.format); - // image offsets must be multiples of block dimensions - if ((SafeModulo(region.srcOffset.x, block_size.width) != 0) || - (SafeModulo(region.srcOffset.y, block_size.height) != 0) || - (SafeModulo(region.srcOffset.z, block_size.depth) != 0)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d7e : VALIDATION_ERROR_09c0013a; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] srcOffset (%d, %d) must be multiples of the compressed image's " - "texel width & height (%d, %d).", - i, region.srcOffset.x, region.srcOffset.y, block_size.width, block_size.height); - } - - const VkExtent3D mip_extent = GetImageSubresourceExtent(src_state, &(region.srcSubresource)); - if ((SafeModulo(src_copy_extent.width, block_size.width) != 0) && - (src_copy_extent.width + region.srcOffset.x != mip_extent.width)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d80 : VALIDATION_ERROR_09c0013c; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block " - "width (%d), or when added to srcOffset.x (%d) must equal the image subresource width (%d).", - i, src_copy_extent.width, block_size.width, region.srcOffset.x, mip_extent.width); - } - - // Extent height must be a multiple of block height, or extent+offset height must equal subresource height - if ((SafeModulo(src_copy_extent.height, block_size.height) != 0) && - (src_copy_extent.height + region.srcOffset.y != mip_extent.height)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d82 : VALIDATION_ERROR_09c0013e; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] extent height (%d) must be a multiple of the compressed texture block " - "height (%d), or when added to srcOffset.y (%d) must equal the image subresource height (%d).", - i, src_copy_extent.height, block_size.height, region.srcOffset.y, mip_extent.height); - } - - // Extent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth - uint32_t copy_depth = (slice_override ? depth_slices : src_copy_extent.depth); - if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.srcOffset.z != mip_extent.depth)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d84 : VALIDATION_ERROR_09c00140; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(src_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block " - "depth (%d), or when added to srcOffset.z (%d) must equal the image subresource depth (%d).", - i, src_copy_extent.depth, block_size.depth, region.srcOffset.z, mip_extent.depth); - } - } // Compressed - - // Do all checks on dest image - // - if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) { - if ((0 != region.dstOffset.y) || (1 != dst_copy_extent.height)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), VALIDATION_ERROR_09c00130, - "vkCmdCopyImage(): pRegion[%d] dstOffset.y is %d and dst_copy_extent.height is %d. For 1D images " - "these must be 0 and 1, respectively.", - i, region.dstOffset.y, dst_copy_extent.height); - } - } - - // VUID-VkImageCopy-dstImage-01786 - if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.dstOffset.z) || (1 != dst_copy_extent.depth))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), VALIDATION_ERROR_09c00df4, - "vkCmdCopyImage(): pRegion[%d] dstOffset.z is %d and extent.depth is %d. For 1D images these must be 0 " - "and 1, respectively.", - i, region.dstOffset.z, dst_copy_extent.depth); - } - - // VUID-VkImageCopy-dstImage-01788 - if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.dstOffset.z)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), VALIDATION_ERROR_09c00df8, - "vkCmdCopyImage(): pRegion[%d] dstOffset.z is %d. For 2D images the z-offset must be 0.", i, - region.dstOffset.z); - } - - if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) { - if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), VALIDATION_ERROR_09c0011a, - "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and dstSubresource.layerCount " - "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.", - i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount); - } - } - // VU01199 changed with mnt1 - if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) { - if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), VALIDATION_ERROR_09c0011a, - "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and dstSubresource.layerCount " - "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.", - i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount); - } - } - } else { // Pre maint 1 - if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D || dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) { - if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), VALIDATION_ERROR_09c0011a, - "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and " - "dstSubresource.layerCount is %d. For copies with either source or dest of type " - "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.", - i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount); - } - } - } - - // Dest checks that apply only to compressed images (or to _422 images if ycbcr enabled) - if (FormatIsCompressed(dst_state->createInfo.format) || - (ext_ycbcr && FormatIsSinglePlane_422(dst_state->createInfo.format))) { - const VkExtent3D block_size = FormatCompressedTexelBlockExtent(dst_state->createInfo.format); - - // image offsets must be multiples of block dimensions - if ((SafeModulo(region.dstOffset.x, block_size.width) != 0) || - (SafeModulo(region.dstOffset.y, block_size.height) != 0) || - (SafeModulo(region.dstOffset.z, block_size.depth) != 0)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d86 : VALIDATION_ERROR_09c00144; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] dstOffset (%d, %d) must be multiples of the compressed image's " - "texel width & height (%d, %d).", - i, region.dstOffset.x, region.dstOffset.y, block_size.width, block_size.height); - } - - const VkExtent3D mip_extent = GetImageSubresourceExtent(dst_state, &(region.dstSubresource)); - if ((SafeModulo(dst_copy_extent.width, block_size.width) != 0) && - (dst_copy_extent.width + region.dstOffset.x != mip_extent.width)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d88 : VALIDATION_ERROR_09c00146; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] dst_copy_extent width (%d) must be a multiple of the compressed texture " - "block width (%d), or when added to dstOffset.x (%d) must equal the image subresource width (%d).", - i, dst_copy_extent.width, block_size.width, region.dstOffset.x, mip_extent.width); - } - - // Extent height must be a multiple of block height, or dst_copy_extent+offset height must equal subresource height - if ((SafeModulo(dst_copy_extent.height, block_size.height) != 0) && - (dst_copy_extent.height + region.dstOffset.y != mip_extent.height)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d8a : VALIDATION_ERROR_09c00148; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] dst_copy_extent height (%d) must be a multiple of the compressed " - "texture block height (%d), or when added to dstOffset.y (%d) must equal the image subresource " - "height (%d).", - i, dst_copy_extent.height, block_size.height, region.dstOffset.y, mip_extent.height); - } - - // Extent depth must be a multiple of block depth, or dst_copy_extent+offset depth must equal subresource depth - uint32_t copy_depth = (slice_override ? depth_slices : dst_copy_extent.depth); - if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.dstOffset.z != mip_extent.depth)) { - UNIQUE_VALIDATION_ERROR_CODE vuid = ext_ycbcr ? VALIDATION_ERROR_09c00d8c : VALIDATION_ERROR_09c0014a; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(dst_state->image), vuid, - "vkCmdCopyImage(): pRegion[%d] dst_copy_extent width (%d) must be a multiple of the compressed texture " - "block depth (%d), or when added to dstOffset.z (%d) must equal the image subresource depth (%d).", - i, dst_copy_extent.depth, block_size.depth, region.dstOffset.z, mip_extent.depth); - } - } // Compressed - } - return skip; -} - -// vkCmdCopyImage checks that only apply if the multiplane extension is enabled -bool CopyImageMultiplaneValidation(const layer_data *dev_data, VkCommandBuffer command_buffer, const IMAGE_STATE *src_image_state, - const IMAGE_STATE *dst_image_state, const VkImageCopy region) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(dev_data); - - // Neither image is multiplane - if ((!FormatIsMultiplane(src_image_state->createInfo.format)) && (!FormatIsMultiplane(dst_image_state->createInfo.format))) { - // If neither image is multi-plane the aspectMask member of src and dst must match - if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) { - std::stringstream ss; - ss << "vkCmdCopyImage: Copy between non-multiplane images with differing aspectMasks ( 0x" << std::hex - << region.srcSubresource.aspectMask << " and 0x" << region.dstSubresource.aspectMask << " )"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00c1e, "%s.", ss.str().c_str()); - } - } else { - // Source image multiplane checks - uint32_t planes = FormatPlaneCount(src_image_state->createInfo.format); - VkImageAspectFlags aspect = region.srcSubresource.aspectMask; - if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Source image aspect mask (0x" << std::hex << aspect << ") is invalid for 2-plane format"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00c20, "%s.", ss.str().c_str()); - } - if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR) && - (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT_KHR)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Source image aspect mask (0x" << std::hex << aspect << ") is invalid for 3-plane format"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00c22, "%s.", ss.str().c_str()); - } - // Single-plane to multi-plane - if ((!FormatIsMultiplane(src_image_state->createInfo.format)) && (FormatIsMultiplane(dst_image_state->createInfo.format)) && - (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Source image aspect mask (0x" << std::hex << aspect << ") is not VK_IMAGE_ASPECT_COLOR_BIT"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00c2a, "%s.", ss.str().c_str()); - } - - // Dest image multiplane checks - planes = FormatPlaneCount(dst_image_state->createInfo.format); - aspect = region.dstSubresource.aspectMask; - if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Dest image aspect mask (0x" << std::hex << aspect << ") is invalid for 2-plane format"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00c24, "%s.", ss.str().c_str()); - } - if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR) && - (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT_KHR)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Dest image aspect mask (0x" << std::hex << aspect << ") is invalid for 3-plane format"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00c26, "%s.", ss.str().c_str()); - } - // Multi-plane to single-plane - if ((FormatIsMultiplane(src_image_state->createInfo.format)) && (!FormatIsMultiplane(dst_image_state->createInfo.format)) && - (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Dest image aspect mask (0x" << std::hex << aspect << ") is not VK_IMAGE_ASPECT_COLOR_BIT"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00c28, "%s.", ss.str().c_str()); - } - } - - return skip; -} - -bool PreCallValidateCmdCopyImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageCopy *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(device_data); - skip = ValidateImageCopyData(device_data, report_data, region_count, regions, src_image_state, dst_image_state); - - VkCommandBuffer command_buffer = cb_node->commandBuffer; - - for (uint32_t i = 0; i < region_count; i++) { - const VkImageCopy region = regions[i]; - - // For comp/uncomp copies, the copy extent for the dest image must be adjusted - VkExtent3D src_copy_extent = region.extent; - VkExtent3D dst_copy_extent = - GetAdjustedDestImageExtent(src_image_state->createInfo.format, dst_image_state->createInfo.format, region.extent); - - bool slice_override = false; - uint32_t depth_slices = 0; - - // Special case for copying between a 1D/2D array and a 3D image - // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up. - if ((VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType) && - (VK_IMAGE_TYPE_3D != dst_image_state->createInfo.imageType)) { - depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource - slice_override = (depth_slices != 1); - } else if ((VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType) && - (VK_IMAGE_TYPE_3D != src_image_state->createInfo.imageType)) { - depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource - slice_override = (depth_slices != 1); - } - - if (region.srcSubresource.layerCount == 0) { - std::stringstream ss; - ss << "vkCmdCopyImage: number of layers in pRegions[" << i << "] srcSubresource is zero"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), DRAWSTATE_INVALID_IMAGE_ASPECT, "%s", ss.str().c_str()); - } - - if (region.dstSubresource.layerCount == 0) { - std::stringstream ss; - ss << "vkCmdCopyImage: number of layers in pRegions[" << i << "] dstSubresource is zero"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), DRAWSTATE_INVALID_IMAGE_ASPECT, "%s", ss.str().c_str()); - } - - if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - // No chance of mismatch if we're overriding depth slice count - if (!slice_override) { - // The number of depth slices in srcSubresource and dstSubresource must match - // Depth comes from layerCount for 1D,2D resources, from extent.depth for 3D - uint32_t src_slices = - (VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType ? src_copy_extent.depth - : region.srcSubresource.layerCount); - uint32_t dst_slices = - (VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType ? dst_copy_extent.depth - : region.dstSubresource.layerCount); - if (src_slices != dst_slices) { - std::stringstream ss; - ss << "vkCmdCopyImage: number of depth slices in source and destination subresources for pRegions[" << i - << "] do not match"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00118, "%s.", ss.str().c_str()); - } - } - } else { - // For each region the layerCount member of srcSubresource and dstSubresource must match - if (region.srcSubresource.layerCount != region.dstSubresource.layerCount) { - std::stringstream ss; - ss << "vkCmdCopyImage: number of layers in source and destination subresources for pRegions[" << i - << "] do not match"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00118, "%s.", ss.str().c_str()); - } - } - - // Do multiplane-specific checks, if extension enabled - if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - skip |= CopyImageMultiplaneValidation(device_data, command_buffer, src_image_state, dst_image_state, region); - } - - if (!GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) { - // not multi-plane, the aspectMask member of srcSubresource and dstSubresource must match - if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) { - char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for each region must match"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00112, "%s.", str); - } - } - - // For each region, the aspectMask member of srcSubresource must be present in the source image - if (!VerifyAspectsPresent(region.srcSubresource.aspectMask, src_image_state->createInfo.format)) { - std::stringstream ss; - ss << "vkCmdCopyImage: pRegion[" << i - << "] srcSubresource.aspectMask cannot specify aspects not present in source image"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c0011c, "%s.", ss.str().c_str()); - } - - // For each region, the aspectMask member of dstSubresource must be present in the destination image - if (!VerifyAspectsPresent(region.dstSubresource.aspectMask, dst_image_state->createInfo.format)) { - std::stringstream ss; - ss << "vkCmdCopyImage: pRegion[" << i << "] dstSubresource.aspectMask cannot specify aspects not present in dest image"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c0011e, "%s.", ss.str().c_str()); - } - - // AspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT - if ((region.srcSubresource.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT) || - (region.dstSubresource.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT)) { - std::stringstream ss; - ss << "vkCmdCopyImage: pRegions[" << i << "] may not specify aspectMask containing VK_IMAGE_ASPECT_METADATA_BIT"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_0a600150, "%s.", ss.str().c_str()); - } - - // For each region, if aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of - // VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT - if ((region.srcSubresource.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) && - (region.srcSubresource.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) { - char const str[] = "vkCmdCopyImage aspectMask cannot specify both COLOR and DEPTH/STENCIL aspects"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_0a60014e, "%s.", str); - } - - // MipLevel must be less than the mipLevels specified in VkImageCreateInfo when the image was created - if (region.srcSubresource.mipLevel >= src_image_state->createInfo.mipLevels) { - std::stringstream ss; - ss << "vkCmdCopyImage: pRegions[" << i - << "] specifies a src mipLevel greater than the number specified when the srcImage was created."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_19000d40, "%s.", ss.str().c_str()); - } - if (region.dstSubresource.mipLevel >= dst_image_state->createInfo.mipLevels) { - std::stringstream ss; - ss << "vkCmdCopyImage: pRegions[" << i - << "] specifies a dst mipLevel greater than the number specified when the dstImage was created."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_19000d42, "%s.", ss.str().c_str()); - } - - // (baseArrayLayer + layerCount) must be less than or equal to the arrayLayers specified in VkImageCreateInfo when the - // image was created - if ((region.srcSubresource.baseArrayLayer + region.srcSubresource.layerCount) > src_image_state->createInfo.arrayLayers) { - std::stringstream ss; - ss << "vkCmdCopyImage: srcImage arrayLayers was " << src_image_state->createInfo.arrayLayers << " but subRegion[" << i - << "] baseArrayLayer + layerCount is " << (region.srcSubresource.baseArrayLayer + region.srcSubresource.layerCount); - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_19000d44, "%s.", ss.str().c_str()); - } - if ((region.dstSubresource.baseArrayLayer + region.dstSubresource.layerCount) > dst_image_state->createInfo.arrayLayers) { - std::stringstream ss; - ss << "vkCmdCopyImage: dstImage arrayLayers was " << dst_image_state->createInfo.arrayLayers << " but subRegion[" << i - << "] baseArrayLayer + layerCount is " << (region.dstSubresource.baseArrayLayer + region.dstSubresource.layerCount); - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_19000d46, "%s.", ss.str().c_str()); - } - - // Check region extents for 1D-1D, 2D-2D, and 3D-3D copies - if (src_image_state->createInfo.imageType == dst_image_state->createInfo.imageType) { - // The source region specified by a given element of regions must be a region that is contained within srcImage - VkExtent3D img_extent = GetImageSubresourceExtent(src_image_state, &(region.srcSubresource)); - if (0 != ExceedsBounds(®ion.srcOffset, &src_copy_extent, &img_extent)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Source pRegion[" << i << "] with mipLevel [ " << region.srcSubresource.mipLevel - << " ], offset [ " << region.srcOffset.x << ", " << region.srcOffset.y << ", " << region.srcOffset.z - << " ], extent [ " << src_copy_extent.width << ", " << src_copy_extent.height << ", " << src_copy_extent.depth - << " ] exceeds the source image dimensions"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_190000f4, "%s.", ss.str().c_str()); - } - - // The destination region specified by a given element of regions must be a region that is contained within dst_image - img_extent = GetImageSubresourceExtent(dst_image_state, &(region.dstSubresource)); - if (0 != ExceedsBounds(®ion.dstOffset, &dst_copy_extent, &img_extent)) { - std::stringstream ss; - ss << "vkCmdCopyImage: Dest pRegion[" << i << "] with mipLevel [ " << region.dstSubresource.mipLevel - << " ], offset [ " << region.dstOffset.x << ", " << region.dstOffset.y << ", " << region.dstOffset.z - << " ], extent [ " << dst_copy_extent.width << ", " << dst_copy_extent.height << ", " << dst_copy_extent.depth - << " ] exceeds the destination image dimensions"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_190000f6, "%s.", ss.str().c_str()); - } - } - - // Each dimension offset + extent limits must fall with image subresource extent - VkExtent3D subresource_extent = GetImageSubresourceExtent(src_image_state, &(region.srcSubresource)); - if (slice_override) src_copy_extent.depth = depth_slices; - uint32_t extent_check = ExceedsBounds(&(region.srcOffset), &src_copy_extent, &subresource_extent); - if (extent_check & x_bit) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00120, - "vkCmdCopyImage: Source image pRegion %1d x-dimension offset [%1d] + extent [%1d] exceeds subResource " - "width [%1d].", - i, region.srcOffset.x, src_copy_extent.width, subresource_extent.width); - } - - if (extent_check & y_bit) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00122, - "vkCmdCopyImage: Source image pRegion %1d y-dimension offset [%1d] + extent [%1d] exceeds subResource " - "height [%1d].", - i, region.srcOffset.y, src_copy_extent.height, subresource_extent.height); - } - if (extent_check & z_bit) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00126, - "vkCmdCopyImage: Source image pRegion %1d z-dimension offset [%1d] + extent [%1d] exceeds subResource " - "depth [%1d].", - i, region.srcOffset.z, src_copy_extent.depth, subresource_extent.depth); - } - - // Adjust dest extent if necessary - subresource_extent = GetImageSubresourceExtent(dst_image_state, &(region.dstSubresource)); - if (slice_override) dst_copy_extent.depth = depth_slices; - - extent_check = ExceedsBounds(&(region.dstOffset), &dst_copy_extent, &subresource_extent); - if (extent_check & x_bit) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c0012c, - "vkCmdCopyImage: Dest image pRegion %1d x-dimension offset [%1d] + extent [%1d] exceeds subResource " - "width [%1d].", - i, region.dstOffset.x, dst_copy_extent.width, subresource_extent.width); - } - if (extent_check & y_bit) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c0012e, - "vkCmdCopyImage: Dest image pRegion %1d y-dimension offset [%1d] + extent [%1d] exceeds subResource " - "height [%1d].", - i, region.dstOffset.y, dst_copy_extent.height, subresource_extent.height); - } - if (extent_check & z_bit) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_09c00132, - "vkCmdCopyImage: Dest image pRegion %1d z-dimension offset [%1d] + extent [%1d] exceeds subResource " - "depth [%1d].", - i, region.dstOffset.z, dst_copy_extent.depth, subresource_extent.depth); - } - - // The union of all source regions, and the union of all destination regions, specified by the elements of regions, - // must not overlap in memory - if (src_image_state->image == dst_image_state->image) { - for (uint32_t j = 0; j < region_count; j++) { - if (RegionIntersects(®ion, ®ions[j], src_image_state->createInfo.imageType, - FormatIsMultiplane(src_image_state->createInfo.format))) { - std::stringstream ss; - ss << "vkCmdCopyImage: pRegions[" << i << "] src overlaps with pRegions[" << j << "]."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_190000f8, "%s.", ss.str().c_str()); - } - } - } - } - - // The formats of src_image and dst_image must be compatible. Formats are considered compatible if their texel size in bytes - // is the same between both formats. For example, VK_FORMAT_R8G8B8A8_UNORM is compatible with VK_FORMAT_R32_UINT because - // because both texels are 4 bytes in size. Depth/stencil formats must match exactly. - if (FormatIsDepthOrStencil(src_image_state->createInfo.format) || FormatIsDepthOrStencil(dst_image_state->createInfo.format)) { - if (src_image_state->createInfo.format != dst_image_state->createInfo.format) { - char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), DRAWSTATE_MISMATCHED_IMAGE_FORMAT, str); - } - } else { - size_t srcSize = FormatSize(src_image_state->createInfo.format); - size_t destSize = FormatSize(dst_image_state->createInfo.format); - if (srcSize != destSize) { - char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_1900010e, "%s.", str); - } - } - - // Source and dest image sample counts must match - if (src_image_state->createInfo.samples != dst_image_state->createInfo.samples) { - char const str[] = "vkCmdCopyImage() called on image pair with non-identical sample counts."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), VALIDATION_ERROR_19000110, "%s", str); - } - - skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdCopyImage()", VALIDATION_ERROR_190000fe); - skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdCopyImage()", VALIDATION_ERROR_19000108); - // Validate that SRC & DST images have correct usage flags set - skip |= ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, VALIDATION_ERROR_190000fc, - "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); - skip |= ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, VALIDATION_ERROR_19000106, - "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); - if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - "vkCmdCopyImage()", VALIDATION_ERROR_190000fa, VALIDATION_ERROR_190000fa); - skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - "vkCmdCopyImage()", VALIDATION_ERROR_19000104, VALIDATION_ERROR_19000104); - } - skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdCopyImage()", - VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, VALIDATION_ERROR_19002415); - skip |= ValidateCmd(device_data, cb_node, CMD_COPYIMAGE, "vkCmdCopyImage()"); - skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyImage()", VALIDATION_ERROR_19000017); - bool hit_error = false; - for (uint32_t i = 0; i < region_count; ++i) { - skip |= VerifyImageLayout(device_data, cb_node, src_image_state, regions[i].srcSubresource, src_image_layout, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdCopyImage()", VALIDATION_ERROR_19000102, &hit_error); - skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, regions[i].dstSubresource, dst_image_layout, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdCopyImage()", VALIDATION_ERROR_1900010c, &hit_error); - skip |= ValidateCopyImageTransferGranularityRequirements(device_data, cb_node, src_image_state, dst_image_state, - ®ions[i], i, "vkCmdCopyImage()"); - } - - return skip; -} - -void PreCallRecordCmdCopyImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageCopy *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout) { - // Make sure that all image slices are updated to correct layout - for (uint32_t i = 0; i < region_count; ++i) { - SetImageLayout(device_data, cb_node, src_image_state, regions[i].srcSubresource, src_image_layout); - SetImageLayout(device_data, cb_node, dst_image_state, regions[i].dstSubresource, dst_image_layout); - } - // Update bindings between images and cmd buffer - AddCommandBufferBindingImage(device_data, cb_node, src_image_state); - AddCommandBufferBindingImage(device_data, cb_node, dst_image_state); -} - -// Returns true if sub_rect is entirely contained within rect -static inline bool ContainsRect(VkRect2D rect, VkRect2D sub_rect) { - if ((sub_rect.offset.x < rect.offset.x) || (sub_rect.offset.x + sub_rect.extent.width > rect.offset.x + rect.extent.width) || - (sub_rect.offset.y < rect.offset.y) || (sub_rect.offset.y + sub_rect.extent.height > rect.offset.y + rect.extent.height)) - return false; - return true; -} - -bool PreCallValidateCmdClearAttachments(layer_data *device_data, VkCommandBuffer commandBuffer, uint32_t attachmentCount, - const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects) { - GLOBAL_CB_NODE *cb_node = GetCBNode(device_data, commandBuffer); - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - bool skip = false; - if (cb_node) { - skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdClearAttachments()", VK_QUEUE_GRAPHICS_BIT, - VALIDATION_ERROR_18602415); - skip |= ValidateCmd(device_data, cb_node, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()"); - // Warn if this is issued prior to Draw Cmd and clearing the entire attachment - if (!cb_node->hasDrawCmd && (cb_node->activeRenderPassBeginInfo.renderArea.extent.width == pRects[0].rect.extent.width) && - (cb_node->activeRenderPassBeginInfo.renderArea.extent.height == pRects[0].rect.extent.height)) { - // There are times where app needs to use ClearAttachments (generally when reusing a buffer inside of a render pass) - // This warning should be made more specific. It'd be best to avoid triggering this test if it's a use that must call - // CmdClearAttachments. - skip |= log_msg( - report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, - "vkCmdClearAttachments() issued on command buffer object 0x%" PRIx64 - " prior to any Draw Cmds. It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", - HandleToUint64(commandBuffer)); - } - skip |= outsideRenderPass(device_data, cb_node, "vkCmdClearAttachments()", VALIDATION_ERROR_18600017); - } - - // Validate that attachment is in reference list of active subpass - if (cb_node->activeRenderPass) { - const VkRenderPassCreateInfo *renderpass_create_info = cb_node->activeRenderPass->createInfo.ptr(); - const VkSubpassDescription *subpass_desc = &renderpass_create_info->pSubpasses[cb_node->activeSubpass]; - auto framebuffer = GetFramebufferState(device_data, cb_node->activeFramebuffer); - - for (uint32_t i = 0; i < attachmentCount; i++) { - auto clear_desc = &pAttachments[i]; - VkImageView image_view = VK_NULL_HANDLE; - - if (0 == clear_desc->aspectMask) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_01c00c03, " "); - } else if (clear_desc->aspectMask & VK_IMAGE_ASPECT_METADATA_BIT) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_01c00028, " "); - } else if (clear_desc->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) { - if (clear_desc->colorAttachment >= subpass_desc->colorAttachmentCount) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1860001e, - "vkCmdClearAttachments() color attachment index %d out of range for active subpass %d.", - clear_desc->colorAttachment, cb_node->activeSubpass); - } else if (subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment == VK_ATTACHMENT_UNUSED) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer), - DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, - "vkCmdClearAttachments() color attachment index %d is VK_ATTACHMENT_UNUSED; ignored.", - clear_desc->colorAttachment); - } else { - image_view = framebuffer->createInfo - .pAttachments[subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment]; - } - if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) || - (clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) { - char const str[] = - "vkCmdClearAttachments() aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_01c00026, str, i); - } - } else { // Must be depth and/or stencil - if (((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) && - ((clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) { - char const str[] = "vkCmdClearAttachments() aspectMask [%d] is not a valid combination of bits."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_01c00c01, str, i); - } - if (!subpass_desc->pDepthStencilAttachment || - (subpass_desc->pDepthStencilAttachment->attachment == VK_ATTACHMENT_UNUSED)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, - "vkCmdClearAttachments() depth/stencil clear with no depth/stencil attachment in subpass; ignored"); - } else { - image_view = framebuffer->createInfo.pAttachments[subpass_desc->pDepthStencilAttachment->attachment]; - } - } - if (image_view) { - auto image_view_state = GetImageViewState(device_data, image_view); - for (uint32_t j = 0; j < rectCount; j++) { - // The rectangular region specified by a given element of pRects must be contained within the render area of - // the current render pass instance - if (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) { - if (false == ContainsRect(cb_node->activeRenderPassBeginInfo.renderArea, pRects[j].rect)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_18600020, - "vkCmdClearAttachments(): The area defined by pRects[%d] is not contained in the area of " - "the current render pass instance.", - j); - } - } else { - const auto local_rect = - pRects[j].rect; // local copy of rect captured by value below to preserve original contents - cb_node->cmd_execute_commands_functions.emplace_back([=](GLOBAL_CB_NODE *prim_cb, VkFramebuffer fb) { - if (false == ContainsRect(prim_cb->activeRenderPassBeginInfo.renderArea, local_rect)) { - return log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_18600020, - "vkCmdClearAttachments(): The area defined by pRects[%d] is not contained in the area of " - "the current render pass instance.", - j); - } - return false; - }); - } - // The layers specified by a given element of pRects must be contained within every attachment that - // pAttachments refers to - auto attachment_layer_count = image_view_state->create_info.subresourceRange.layerCount; - if ((pRects[j].baseArrayLayer >= attachment_layer_count) || - (pRects[j].baseArrayLayer + pRects[j].layerCount > attachment_layer_count)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_18600022, - "vkCmdClearAttachments(): The layers defined in pRects[%d] are not contained in the layers " - "of pAttachment[%d].", - j, i); - } - } - } - } - } - return skip; -} - -bool PreCallValidateCmdResolveImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t regionCount, const VkImageResolve *pRegions) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - if (cb_node && src_image_state && dst_image_state) { - skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdResolveImage()", VALIDATION_ERROR_1c800200); - skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdResolveImage()", VALIDATION_ERROR_1c800204); - skip |= - ValidateCmdQueueFlags(device_data, cb_node, "vkCmdResolveImage()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1c802415); - skip |= ValidateCmd(device_data, cb_node, CMD_RESOLVEIMAGE, "vkCmdResolveImage()"); - skip |= insideRenderPass(device_data, cb_node, "vkCmdResolveImage()", VALIDATION_ERROR_1c800017); - skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, - "vkCmdResolveImage()", VALIDATION_ERROR_1c800210, VALIDATION_ERROR_1c800212); - - // For each region, the number of layers in the image subresource should not be zero - // For each region, src and dest image aspect must be color only - for (uint32_t i = 0; i < regionCount; i++) { - if (pRegions[i].srcSubresource.layerCount == 0) { - char const str[] = "vkCmdResolveImage: number of layers in source subresource is zero"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str); - } - if (pRegions[i].dstSubresource.layerCount == 0) { - char const str[] = "vkCmdResolveImage: number of layers in destination subresource is zero"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str); - } - if (pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_0a200216, - "vkCmdResolveImage: layerCount in source and destination subresource of pRegions[%d] does not match.", i); - } - if ((pRegions[i].srcSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) || - (pRegions[i].dstSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT)) { - char const str[] = - "vkCmdResolveImage: src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_0a200214, "%s.", str); - } - } - - if (src_image_state->createInfo.format != dst_image_state->createInfo.format) { - char const str[] = "vkCmdResolveImage called with unmatched source and dest formats."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_FORMAT, str); - } - if (src_image_state->createInfo.imageType != dst_image_state->createInfo.imageType) { - char const str[] = "vkCmdResolveImage called with unmatched source and dest image types."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_TYPE, str); - } - if (src_image_state->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) { - char const str[] = "vkCmdResolveImage called with source sample count less than 2."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_1c800202, "%s.", str); - } - if (dst_image_state->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) { - char const str[] = "vkCmdResolveImage called with dest sample count greater than 1."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_1c800206, "%s.", str); - } - // TODO: Need to validate image layouts, which will include layout validation for shared presentable images - } else { - assert(0); - } - return skip; -} - -void PreCallRecordCmdResolveImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state) { - // Update bindings between images and cmd buffer - AddCommandBufferBindingImage(device_data, cb_node, src_image_state); - AddCommandBufferBindingImage(device_data, cb_node, dst_image_state); -} - -bool PreCallValidateCmdBlitImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageBlit *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout, VkFilter filter) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - bool skip = false; - if (cb_node) { - skip |= ValidateCmd(device_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()"); - } - if (cb_node && src_image_state && dst_image_state) { - skip |= ValidateImageSampleCount(device_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): srcImage", - VALIDATION_ERROR_184001d2); - skip |= ValidateImageSampleCount(device_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): dstImage", - VALIDATION_ERROR_184001d4); - skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdBlitImage()", VALIDATION_ERROR_184001b8); - skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdBlitImage()", VALIDATION_ERROR_184001c2); - skip |= ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, - VALIDATION_ERROR_184001b6, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); - skip |= ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, - VALIDATION_ERROR_184001c0, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); - skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdBlitImage()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_18402415); - skip |= ValidateCmd(device_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()"); - skip |= insideRenderPass(device_data, cb_node, "vkCmdBlitImage()", VALIDATION_ERROR_18400017); - skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_BLIT_SRC_BIT, "vkCmdBlitImage()", - VALIDATION_ERROR_184001b4, VALIDATION_ERROR_184001b4); - skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_BLIT_DST_BIT, "vkCmdBlitImage()", - VALIDATION_ERROR_184001be, VALIDATION_ERROR_184001be); - - // TODO: Need to validate image layouts, which will include layout validation for shared presentable images - - VkFormat src_format = src_image_state->createInfo.format; - VkFormat dst_format = dst_image_state->createInfo.format; - VkImageType src_type = src_image_state->createInfo.imageType; - VkImageType dst_type = dst_image_state->createInfo.imageType; - - if (VK_FILTER_LINEAR == filter) { - skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, - "vkCmdBlitImage()", VALIDATION_ERROR_184001d6, VALIDATION_ERROR_184001d6); - } else if (VK_FILTER_CUBIC_IMG == filter) { - skip |= - ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, - "vkCmdBlitImage()", VALIDATION_ERROR_184001d8, VALIDATION_ERROR_184001d8); - } - - if ((VK_FILTER_CUBIC_IMG == filter) && (VK_IMAGE_TYPE_3D != src_type)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001da, - "vkCmdBlitImage: source image type must be VK_IMAGE_TYPE_3D when cubic filtering is specified."); - } - - if ((VK_SAMPLE_COUNT_1_BIT != src_image_state->createInfo.samples) || - (VK_SAMPLE_COUNT_1_BIT != dst_image_state->createInfo.samples)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001c8, - "vkCmdBlitImage: source or dest image has sample count other than VK_SAMPLE_COUNT_1_BIT."); - } - - // Validate consistency for unsigned formats - if (FormatIsUInt(src_format) != FormatIsUInt(dst_format)) { - std::stringstream ss; - ss << "vkCmdBlitImage: If one of srcImage and dstImage images has unsigned integer format, " - << "the other one must also have unsigned integer format. " - << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format); - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001cc, "%s.", ss.str().c_str()); - } - - // Validate consistency for signed formats - if (FormatIsSInt(src_format) != FormatIsSInt(dst_format)) { - std::stringstream ss; - ss << "vkCmdBlitImage: If one of srcImage and dstImage images has signed integer format, " - << "the other one must also have signed integer format. " - << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format); - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001ca, "%s.", ss.str().c_str()); - } - - // Validate filter for Depth/Stencil formats - if (FormatIsDepthOrStencil(src_format) && (filter != VK_FILTER_NEAREST)) { - std::stringstream ss; - ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, or depth stencil " - << "then filter must be VK_FILTER_NEAREST."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001d0, "%s.", ss.str().c_str()); - } - - // Validate aspect bits and formats for depth/stencil images - if (FormatIsDepthOrStencil(src_format) || FormatIsDepthOrStencil(dst_format)) { - if (src_format != dst_format) { - std::stringstream ss; - ss << "vkCmdBlitImage: If one of srcImage and dstImage images has a format of depth, stencil or depth " - << "stencil, the other one must have exactly the same format. " - << "Source format is " << string_VkFormat(src_format) << " Destination format is " - << string_VkFormat(dst_format); - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001ce, "%s.", ss.str().c_str()); - } - -#if 0 // TODO: Cannot find VU statements or spec language for these in CmdBlitImage. Verify or remove. - for (uint32_t i = 0; i < regionCount; i++) { - VkImageAspectFlags srcAspect = pRegions[i].srcSubresource.aspectMask; - - if (FormatIsDepthAndStencil(src_format)) { - if ((srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT)) { - std::stringstream ss; - ss << "vkCmdBlitImage: Combination depth/stencil image formats must have only one of VK_IMAGE_ASPECT_DEPTH_BIT " - << "and VK_IMAGE_ASPECT_STENCIL_BIT set in srcImage and dstImage"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT, - "%s", ss.str().c_str()); - } - } - else if (FormatIsStencilOnly(src_format)) { - if (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT) { - std::stringstream ss; - ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT " - << "set in both the srcImage and dstImage"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT, - "%s", ss.str().c_str()); - } - } - else if (FormatIsDepthOnly(src_format)) { - if (srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) { - std::stringstream ss; - ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH " - << "set in both the srcImage and dstImage"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT, - "%s", ss.str().c_str()); - } - } - } -#endif - } // Depth or Stencil - - // Do per-region checks - for (uint32_t i = 0; i < region_count; i++) { - const VkImageBlit rgn = regions[i]; - bool hit_error = false; - skip |= - VerifyImageLayout(device_data, cb_node, src_image_state, rgn.srcSubresource, src_image_layout, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdBlitImage()", VALIDATION_ERROR_184001bc, &hit_error); - skip |= - VerifyImageLayout(device_data, cb_node, dst_image_state, rgn.dstSubresource, dst_image_layout, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdBlitImage()", VALIDATION_ERROR_184001c6, &hit_error); - - // Warn for zero-sized regions - if ((rgn.srcOffsets[0].x == rgn.srcOffsets[1].x) || (rgn.srcOffsets[0].y == rgn.srcOffsets[1].y) || - (rgn.srcOffsets[0].z == rgn.srcOffsets[1].z)) { - std::stringstream ss; - ss << "vkCmdBlitImage: pRegions[" << i << "].srcOffsets specify a zero-volume area."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_EXTENTS, "%s", ss.str().c_str()); - } - if ((rgn.dstOffsets[0].x == rgn.dstOffsets[1].x) || (rgn.dstOffsets[0].y == rgn.dstOffsets[1].y) || - (rgn.dstOffsets[0].z == rgn.dstOffsets[1].z)) { - std::stringstream ss; - ss << "vkCmdBlitImage: pRegions[" << i << "].dstOffsets specify a zero-volume area."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_EXTENTS, "%s", ss.str().c_str()); - } - if (rgn.srcSubresource.layerCount == 0) { - char const str[] = "vkCmdBlitImage: number of layers in source subresource is zero"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str); - } - if (rgn.dstSubresource.layerCount == 0) { - char const str[] = "vkCmdBlitImage: number of layers in destination subresource is zero"; - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str); - } - - // Check that src/dst layercounts match - if (rgn.srcSubresource.layerCount != rgn.dstSubresource.layerCount) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001de, - "vkCmdBlitImage: layerCount in source and destination subresource of pRegions[%d] does not match.", i); - } - - if (rgn.srcSubresource.aspectMask != rgn.dstSubresource.aspectMask) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001dc, - "vkCmdBlitImage: aspectMask members for pRegion[%d] do not match.", i); - } - - if (!VerifyAspectsPresent(rgn.srcSubresource.aspectMask, src_format)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001e2, - "vkCmdBlitImage: region [%d] source aspectMask (0x%x) specifies aspects not present in source " - "image format %s.", - i, rgn.srcSubresource.aspectMask, string_VkFormat(src_format)); - } - - if (!VerifyAspectsPresent(rgn.dstSubresource.aspectMask, dst_format)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001e4, - "vkCmdBlitImage: region [%d] dest aspectMask (0x%x) specifies aspects not present in dest image format %s.", i, - rgn.dstSubresource.aspectMask, string_VkFormat(dst_format)); - } - - // Validate source image offsets - VkExtent3D src_extent = GetImageSubresourceExtent(src_image_state, &(rgn.srcSubresource)); - if (VK_IMAGE_TYPE_1D == src_type) { - if ((0 != rgn.srcOffsets[0].y) || (1 != rgn.srcOffsets[1].y)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001ea, - "vkCmdBlitImage: region [%d], source image of type VK_IMAGE_TYPE_1D with srcOffset[].y values " - "of (%1d, %1d). These must be (0, 1).", - i, rgn.srcOffsets[0].y, rgn.srcOffsets[1].y); - } - } - - if ((VK_IMAGE_TYPE_1D == src_type) || (VK_IMAGE_TYPE_2D == src_type)) { - if ((0 != rgn.srcOffsets[0].z) || (1 != rgn.srcOffsets[1].z)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001ee, - "vkCmdBlitImage: region [%d], source image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with " - "srcOffset[].z values of (%1d, %1d). These must be (0, 1).", - i, rgn.srcOffsets[0].z, rgn.srcOffsets[1].z); - } - } - - bool oob = false; - if ((rgn.srcOffsets[0].x < 0) || (rgn.srcOffsets[0].x > static_cast(src_extent.width)) || - (rgn.srcOffsets[1].x < 0) || (rgn.srcOffsets[1].x > static_cast(src_extent.width))) { - oob = true; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001e6, - "vkCmdBlitImage: region [%d] srcOffset[].x values (%1d, %1d) exceed srcSubresource width extent (%1d).", - i, rgn.srcOffsets[0].x, rgn.srcOffsets[1].x, src_extent.width); - } - if ((rgn.srcOffsets[0].y < 0) || (rgn.srcOffsets[0].y > static_cast(src_extent.height)) || - (rgn.srcOffsets[1].y < 0) || (rgn.srcOffsets[1].y > static_cast(src_extent.height))) { - oob = true; - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001e8, - "vkCmdBlitImage: region [%d] srcOffset[].y values (%1d, %1d) exceed srcSubresource height extent (%1d).", i, - rgn.srcOffsets[0].y, rgn.srcOffsets[1].y, src_extent.height); - } - if ((rgn.srcOffsets[0].z < 0) || (rgn.srcOffsets[0].z > static_cast(src_extent.depth)) || - (rgn.srcOffsets[1].z < 0) || (rgn.srcOffsets[1].z > static_cast(src_extent.depth))) { - oob = true; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001ec, - "vkCmdBlitImage: region [%d] srcOffset[].z values (%1d, %1d) exceed srcSubresource depth extent (%1d).", - i, rgn.srcOffsets[0].z, rgn.srcOffsets[1].z, src_extent.depth); - } - if (rgn.srcSubresource.mipLevel >= src_image_state->createInfo.mipLevels) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001ae, - "vkCmdBlitImage: region [%d] source image, attempt to access a non-existant mip level %1d.", i, - rgn.srcSubresource.mipLevel); - } else if (oob) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001ae, - "vkCmdBlitImage: region [%d] source image blit region exceeds image dimensions.", i); - } - - // Validate dest image offsets - VkExtent3D dst_extent = GetImageSubresourceExtent(dst_image_state, &(rgn.dstSubresource)); - if (VK_IMAGE_TYPE_1D == dst_type) { - if ((0 != rgn.dstOffsets[0].y) || (1 != rgn.dstOffsets[1].y)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001f4, - "vkCmdBlitImage: region [%d], dest image of type VK_IMAGE_TYPE_1D with dstOffset[].y values of " - "(%1d, %1d). These must be (0, 1).", - i, rgn.dstOffsets[0].y, rgn.dstOffsets[1].y); - } - } - - if ((VK_IMAGE_TYPE_1D == dst_type) || (VK_IMAGE_TYPE_2D == dst_type)) { - if ((0 != rgn.dstOffsets[0].z) || (1 != rgn.dstOffsets[1].z)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001f8, - "vkCmdBlitImage: region [%d], dest image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with " - "dstOffset[].z values of (%1d, %1d). These must be (0, 1).", - i, rgn.dstOffsets[0].z, rgn.dstOffsets[1].z); - } - } - - oob = false; - if ((rgn.dstOffsets[0].x < 0) || (rgn.dstOffsets[0].x > static_cast(dst_extent.width)) || - (rgn.dstOffsets[1].x < 0) || (rgn.dstOffsets[1].x > static_cast(dst_extent.width))) { - oob = true; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001f0, - "vkCmdBlitImage: region [%d] dstOffset[].x values (%1d, %1d) exceed dstSubresource width extent (%1d).", - i, rgn.dstOffsets[0].x, rgn.dstOffsets[1].x, dst_extent.width); - } - if ((rgn.dstOffsets[0].y < 0) || (rgn.dstOffsets[0].y > static_cast(dst_extent.height)) || - (rgn.dstOffsets[1].y < 0) || (rgn.dstOffsets[1].y > static_cast(dst_extent.height))) { - oob = true; - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001f2, - "vkCmdBlitImage: region [%d] dstOffset[].y values (%1d, %1d) exceed dstSubresource height extent (%1d).", i, - rgn.dstOffsets[0].y, rgn.dstOffsets[1].y, dst_extent.height); - } - if ((rgn.dstOffsets[0].z < 0) || (rgn.dstOffsets[0].z > static_cast(dst_extent.depth)) || - (rgn.dstOffsets[1].z < 0) || (rgn.dstOffsets[1].z > static_cast(dst_extent.depth))) { - oob = true; - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001f6, - "vkCmdBlitImage: region [%d] dstOffset[].z values (%1d, %1d) exceed dstSubresource depth extent (%1d).", - i, rgn.dstOffsets[0].z, rgn.dstOffsets[1].z, dst_extent.depth); - } - if (rgn.dstSubresource.mipLevel >= dst_image_state->createInfo.mipLevels) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001b0, - "vkCmdBlitImage: region [%d] destination image, attempt to access a non-existant mip level %1d.", i, - rgn.dstSubresource.mipLevel); - } else if (oob) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_184001b0, - "vkCmdBlitImage: region [%d] destination image blit region exceeds image dimensions.", i); - } - - if ((VK_IMAGE_TYPE_3D == src_type) || (VK_IMAGE_TYPE_3D == dst_type)) { - if ((0 != rgn.srcSubresource.baseArrayLayer) || (1 != rgn.srcSubresource.layerCount) || - (0 != rgn.dstSubresource.baseArrayLayer) || (1 != rgn.dstSubresource.layerCount)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), VALIDATION_ERROR_09a001e0, - "vkCmdBlitImage: region [%d] blit to/from a 3D image type with a non-zero baseArrayLayer, or a " - "layerCount other than 1.", - i); - } - } - } // per-region checks - } else { - assert(0); - } - return skip; -} - -void PreCallRecordCmdBlitImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageBlit *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout) { - // Make sure that all image slices are updated to correct layout - for (uint32_t i = 0; i < region_count; ++i) { - SetImageLayout(device_data, cb_node, src_image_state, regions[i].srcSubresource, src_image_layout); - SetImageLayout(device_data, cb_node, dst_image_state, regions[i].dstSubresource, dst_image_layout); - } - // Update bindings between images and cmd buffer - AddCommandBufferBindingImage(device_data, cb_node, src_image_state); - AddCommandBufferBindingImage(device_data, cb_node, dst_image_state); -} - -// This validates that the initial layout specified in the command buffer for -// the IMAGE is the same -// as the global IMAGE layout -bool ValidateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, - std::unordered_map const &globalImageLayoutMap, - std::unordered_map &overlayLayoutMap) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(device_data); - for (auto cb_image_data : pCB->imageLayoutMap) { - VkImageLayout imageLayout; - - if (FindLayout(device_data, overlayLayoutMap, cb_image_data.first, imageLayout) || - FindLayout(device_data, globalImageLayoutMap, cb_image_data.first, imageLayout)) { - if (cb_image_data.second.initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) { - // TODO: Set memory invalid which is in mem_tracker currently - } else if (imageLayout != cb_image_data.second.initialLayout) { - if (cb_image_data.first.hasSubresource) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Cannot submit cmd buffer using image (0x%" PRIx64 - ") [sub-resource: aspectMask 0x%X array layer %u, mip level %u], with layout %s when first use is %s.", - HandleToUint64(cb_image_data.first.image), cb_image_data.first.subresource.aspectMask, - cb_image_data.first.subresource.arrayLayer, cb_image_data.first.subresource.mipLevel, - string_VkImageLayout(imageLayout), string_VkImageLayout(cb_image_data.second.initialLayout)); - } else { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Cannot submit cmd buffer using image (0x%" PRIx64 ") with layout %s when first use is %s.", - HandleToUint64(cb_image_data.first.image), string_VkImageLayout(imageLayout), - string_VkImageLayout(cb_image_data.second.initialLayout)); - } - } - SetLayout(overlayLayoutMap, cb_image_data.first, cb_image_data.second.layout); - } - } - return skip; -} - -void UpdateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB) { - for (auto cb_image_data : pCB->imageLayoutMap) { - VkImageLayout imageLayout; - FindGlobalLayout(device_data, cb_image_data.first, imageLayout); - SetGlobalLayout(device_data, cb_image_data.first, cb_image_data.second.layout); - } -} - -// Print readable FlagBits in FlagMask -static std::string string_VkAccessFlags(VkAccessFlags accessMask) { - std::string result; - std::string separator; - - if (accessMask == 0) { - result = "[None]"; - } else { - result = "["; - for (auto i = 0; i < 32; i++) { - if (accessMask & (1 << i)) { - result = result + separator + string_VkAccessFlagBits((VkAccessFlagBits)(1 << i)); - separator = " | "; - } - } - result = result + "]"; - } - return result; -} - -// AccessFlags MUST have 'required_bit' set, and may have one or more of 'optional_bits' set. If required_bit is zero, accessMask -// must have at least one of 'optional_bits' set -// TODO: Add tracking to ensure that at least one barrier has been set for these layout transitions -static bool ValidateMaskBits(core_validation::layer_data *device_data, VkCommandBuffer cmdBuffer, const VkAccessFlags &accessMask, - const VkImageLayout &layout, VkAccessFlags required_bit, VkAccessFlags optional_bits, - const char *type) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - - if ((accessMask & required_bit) || (!required_bit && (accessMask & optional_bits))) { - if (accessMask & ~(required_bit | optional_bits)) { - // TODO: Verify against Valid Use - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cmdBuffer), DRAWSTATE_INVALID_BARRIER, - "Additional bits in %s accessMask 0x%X %s are specified when layout is %s.", type, accessMask, - string_VkAccessFlags(accessMask).c_str(), string_VkImageLayout(layout)); - } - } else { - if (!required_bit) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cmdBuffer), DRAWSTATE_INVALID_BARRIER, - "%s AccessMask %d %s must contain at least one of access bits %d %s when layout is %s, unless the app " - "has previously added a barrier for this transition.", - type, accessMask, string_VkAccessFlags(accessMask).c_str(), optional_bits, - string_VkAccessFlags(optional_bits).c_str(), string_VkImageLayout(layout)); - } else { - std::string opt_bits; - if (optional_bits != 0) { - std::stringstream ss; - ss << optional_bits; - opt_bits = "and may have optional bits " + ss.str() + ' ' + string_VkAccessFlags(optional_bits); - } - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cmdBuffer), DRAWSTATE_INVALID_BARRIER, - "%s AccessMask %d %s must have required access bit %d %s %s when layout is %s, unless the app has " - "previously added a barrier for this transition.", - type, accessMask, string_VkAccessFlags(accessMask).c_str(), required_bit, - string_VkAccessFlags(required_bit).c_str(), opt_bits.c_str(), string_VkImageLayout(layout)); - } - } - return skip; -} - -// ValidateLayoutVsAttachmentDescription is a general function where we can validate various state associated with the -// VkAttachmentDescription structs that are used by the sub-passes of a renderpass. Initial check is to make sure that READ_ONLY -// layout attachments don't have CLEAR as their loadOp. -bool ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, const VkImageLayout first_layout, - const uint32_t attachment, const VkAttachmentDescription &attachment_description) { - bool skip = false; - // Verify that initial loadOp on READ_ONLY attachments is not CLEAR - if (attachment_description.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) { - if ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) || - (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_12200688, "Cannot clear attachment %d with invalid first layout %s.", attachment, - string_VkImageLayout(first_layout)); - } - } - if (attachment_description.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) { - if (first_layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_12200c3c, "Cannot clear attachment %d with invalid first layout %s.", attachment, - string_VkImageLayout(first_layout)); - } - } - - if (attachment_description.stencilLoadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) { - if (first_layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_12200c3e, "Cannot clear attachment %d with invalid first layout %s.", attachment, - string_VkImageLayout(first_layout)); - } - } - return skip; -} - -bool ValidateLayouts(core_validation::layer_data *device_data, VkDevice device, const VkRenderPassCreateInfo *pCreateInfo) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - VkFormat format = pCreateInfo->pAttachments[i].format; - if (pCreateInfo->pAttachments[i].initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) { - if ((FormatIsColor(format) || FormatHasDepth(format)) && - pCreateInfo->pAttachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, - "Render pass has an attachment with loadOp == VK_ATTACHMENT_LOAD_OP_LOAD and initialLayout == " - "VK_IMAGE_LAYOUT_UNDEFINED. This is probably not what you intended. Consider using " - "VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the image truely is undefined at the start of the " - "render pass."); - } - if (FormatHasStencil(format) && pCreateInfo->pAttachments[i].stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, - "Render pass has an attachment with stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD and initialLayout " - "== VK_IMAGE_LAYOUT_UNDEFINED. This is probably not what you intended. Consider using " - "VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the image truely is undefined at the start of the " - "render pass."); - } - } - } - - // Track when we're observing the first use of an attachment - std::vector attach_first_use(pCreateInfo->attachmentCount, true); - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[i]; - - // Check input attachments first, so we can detect first-use-as-input for VU #00349 - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - auto attach_index = subpass.pInputAttachments[j].attachment; - if (attach_index == VK_ATTACHMENT_UNUSED) continue; - - switch (subpass.pInputAttachments[j].layout) { - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: - case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: - // These are ideal. - break; - - case VK_IMAGE_LAYOUT_GENERAL: - // May not be optimal. TODO: reconsider this warning based on other constraints. - skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Layout for input attachment is GENERAL but should be READ_ONLY_OPTIMAL."); - break; - - default: - // No other layouts are acceptable - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Layout for input attachment is %s but can only be READ_ONLY_OPTIMAL or GENERAL.", - string_VkImageLayout(subpass.pInputAttachments[j].layout)); - } - - if (attach_first_use[attach_index]) { - skip |= ValidateLayoutVsAttachmentDescription(report_data, subpass.pInputAttachments[j].layout, attach_index, - pCreateInfo->pAttachments[attach_index]); - - bool used_as_depth = - (subpass.pDepthStencilAttachment != NULL && subpass.pDepthStencilAttachment->attachment == attach_index); - bool used_as_color = false; - for (uint32_t k = 0; !used_as_depth && !used_as_color && k < subpass.colorAttachmentCount; ++k) { - used_as_color = (subpass.pColorAttachments[k].attachment == attach_index); - } - if (!used_as_depth && !used_as_color && - pCreateInfo->pAttachments[attach_index].loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1400069c, - "CreateRenderPass: attachment %u is first used as an input attachment in subpass %u with loadOp=CLEAR.", - attach_index, attach_index); - } - } - attach_first_use[attach_index] = false; - } - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - auto attach_index = subpass.pColorAttachments[j].attachment; - if (attach_index == VK_ATTACHMENT_UNUSED) continue; - - // TODO: Need a way to validate shared presentable images here, currently just allowing - // VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR - // as an acceptable layout, but need to make sure shared presentable images ONLY use that layout - switch (subpass.pColorAttachments[j].layout) { - case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: - // This is ideal. - case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: - // TODO: See note above, just assuming that attachment is shared presentable and allowing this for now. - break; - - case VK_IMAGE_LAYOUT_GENERAL: - // May not be optimal; TODO: reconsider this warning based on other constraints? - skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Layout for color attachment is GENERAL but should be COLOR_ATTACHMENT_OPTIMAL."); - break; - - default: - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Layout for color attachment is %s but can only be COLOR_ATTACHMENT_OPTIMAL or GENERAL.", - string_VkImageLayout(subpass.pColorAttachments[j].layout)); - } - - if (attach_first_use[attach_index]) { - skip |= ValidateLayoutVsAttachmentDescription(report_data, subpass.pColorAttachments[j].layout, attach_index, - pCreateInfo->pAttachments[attach_index]); - } - attach_first_use[attach_index] = false; - } - - if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - switch (subpass.pDepthStencilAttachment->layout) { - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: - // These are ideal. - break; - - case VK_IMAGE_LAYOUT_GENERAL: - // May not be optimal; TODO: reconsider this warning based on other constraints? GENERAL can be better than - // doing a bunch of transitions. - skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, - "GENERAL layout for depth attachment may not give optimal performance."); - break; - - case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: - case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: - if (GetDeviceExtensions(device_data)->vk_khr_maintenance2) { - break; - } else { - // Intentionally fall through to generic error message - } - // fall through - default: - // No other layouts are acceptable - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Layout for depth attachment is %s but can only be DEPTH_STENCIL_ATTACHMENT_OPTIMAL, " - "DEPTH_STENCIL_READ_ONLY_OPTIMAL or GENERAL.", - string_VkImageLayout(subpass.pDepthStencilAttachment->layout)); - } - - auto attach_index = subpass.pDepthStencilAttachment->attachment; - if (attach_first_use[attach_index]) { - skip |= ValidateLayoutVsAttachmentDescription(report_data, subpass.pDepthStencilAttachment->layout, attach_index, - pCreateInfo->pAttachments[attach_index]); - } - attach_first_use[attach_index] = false; - } - } - return skip; -} - -// For any image objects that overlap mapped memory, verify that their layouts are PREINIT or GENERAL -bool ValidateMapImageLayouts(core_validation::layer_data *device_data, VkDevice device, DEVICE_MEM_INFO const *mem_info, - VkDeviceSize offset, VkDeviceSize end_offset) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - // Iterate over all bound image ranges and verify that for any that overlap the map ranges, the layouts are - // VK_IMAGE_LAYOUT_PREINITIALIZED or VK_IMAGE_LAYOUT_GENERAL - // TODO : This can be optimized if we store ranges based on starting address and early exit when we pass our range - for (auto image_handle : mem_info->bound_images) { - auto img_it = mem_info->bound_ranges.find(image_handle); - if (img_it != mem_info->bound_ranges.end()) { - if (rangesIntersect(device_data, &img_it->second, offset, end_offset)) { - std::vector layouts; - if (FindLayouts(device_data, VkImage(image_handle), layouts)) { - for (auto layout : layouts) { - if (layout != VK_IMAGE_LAYOUT_PREINITIALIZED && layout != VK_IMAGE_LAYOUT_GENERAL) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem_info->mem), DRAWSTATE_INVALID_IMAGE_LAYOUT, - "Mapping an image with layout %s can result in undefined behavior if this memory is used " - "by the device. Only GENERAL or PREINITIALIZED should be used.", - string_VkImageLayout(layout)); - } - } - } - } - } - } - return skip; -} - -// Helper function to validate correct usage bits set for buffers or images. Verify that (actual & desired) flags != 0 or, if strict -// is true, verify that (actual & desired) flags == desired -static bool validate_usage_flags(layer_data *device_data, VkFlags actual, VkFlags desired, VkBool32 strict, uint64_t obj_handle, - VulkanObjectType obj_type, int32_t const msgCode, char const *func_name, char const *usage_str) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - bool correct_usage = false; - bool skip = false; - const char *type_str = object_string[obj_type]; - if (strict) { - correct_usage = ((actual & desired) == desired); - } else { - correct_usage = ((actual & desired) != 0); - } - if (!correct_usage) { - if (msgCode == -1) { - // TODO: Fix callers with msgCode == -1 to use correct validation checks. - skip = - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[obj_type], obj_handle, - MEMTRACK_INVALID_USAGE_FLAG, - "Invalid usage flag for %s 0x%" PRIx64 " used by %s. In this case, %s should have %s set during creation.", - type_str, obj_handle, func_name, type_str, usage_str); - } else { - skip = - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[obj_type], obj_handle, msgCode, - "Invalid usage flag for %s 0x%" PRIx64 " used by %s. In this case, %s should have %s set during creation.", - type_str, obj_handle, func_name, type_str, usage_str); - } - } - return skip; -} - -// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above -// where an error will be flagged if usage is not correct -bool ValidateImageUsageFlags(layer_data *device_data, IMAGE_STATE const *image_state, VkFlags desired, bool strict, - int32_t const msgCode, char const *func_name, char const *usage_string) { - return validate_usage_flags(device_data, image_state->createInfo.usage, desired, strict, HandleToUint64(image_state->image), - kVulkanObjectTypeImage, msgCode, func_name, usage_string); -} - -bool ValidateImageFormatFeatureFlags(layer_data *dev_data, IMAGE_STATE const *image_state, VkFormatFeatureFlags desired, - char const *func_name, UNIQUE_VALIDATION_ERROR_CODE linear_vuid, - UNIQUE_VALIDATION_ERROR_CODE optimal_vuid) { - VkFormatProperties format_properties = GetFormatProperties(dev_data, image_state->createInfo.format); - const debug_report_data *report_data = core_validation::GetReportData(dev_data); - bool skip = false; - if (image_state->createInfo.tiling == VK_IMAGE_TILING_LINEAR) { - if ((format_properties.linearTilingFeatures & desired) != desired) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), linear_vuid, - "In %s, invalid linearTilingFeatures (0x%08X) for format %u used by image %" PRIx64 ".", func_name, - format_properties.linearTilingFeatures, image_state->createInfo.format, HandleToUint64(image_state->image)); - } - } else if (image_state->createInfo.tiling == VK_IMAGE_TILING_OPTIMAL) { - if ((format_properties.optimalTilingFeatures & desired) != desired) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), optimal_vuid, - "In %s, invalid optimalTilingFeatures (0x%08X) for format %u used by image %" PRIx64 ".", func_name, - format_properties.optimalTilingFeatures, image_state->createInfo.format, - HandleToUint64(image_state->image)); - } - } - return skip; -} - -// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above -// where an error will be flagged if usage is not correct -bool ValidateBufferUsageFlags(layer_data *device_data, BUFFER_STATE const *buffer_state, VkFlags desired, bool strict, - int32_t const msgCode, char const *func_name, char const *usage_string) { - return validate_usage_flags(device_data, buffer_state->createInfo.usage, desired, strict, HandleToUint64(buffer_state->buffer), - kVulkanObjectTypeBuffer, msgCode, func_name, usage_string); -} - -bool PreCallValidateCreateBuffer(layer_data *device_data, const VkBufferCreateInfo *pCreateInfo) { - bool skip = false; - const debug_report_data *report_data = core_validation::GetReportData(device_data); - - // TODO: Add check for VALIDATION_ERROR_1ec0071e (sparse address space accounting) - - if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) && (!GetEnabledFeatures(device_data)->sparseBinding)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_01400726, - "vkCreateBuffer(): the sparseBinding device feature is disabled: Buffers cannot be created with the " - "VK_BUFFER_CREATE_SPARSE_BINDING_BIT set."); - } - - if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) && (!GetEnabledFeatures(device_data)->sparseResidencyBuffer)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_01400728, - "vkCreateBuffer(): the sparseResidencyBuffer device feature is disabled: Buffers cannot be created with " - "the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT set."); - } - - if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) && (!GetEnabledFeatures(device_data)->sparseResidencyAliased)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0140072a, - "vkCreateBuffer(): the sparseResidencyAliased device feature is disabled: Buffers cannot be created with " - "the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT set."); - } - return skip; -} - -void PostCallRecordCreateBuffer(layer_data *device_data, const VkBufferCreateInfo *pCreateInfo, VkBuffer *pBuffer) { - // TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid - GetBufferMap(device_data) - ->insert(std::make_pair(*pBuffer, std::unique_ptr(new BUFFER_STATE(*pBuffer, pCreateInfo)))); -} - -bool PreCallValidateCreateBufferView(layer_data *device_data, const VkBufferViewCreateInfo *pCreateInfo) { - bool skip = false; - BUFFER_STATE *buffer_state = GetBufferState(device_data, pCreateInfo->buffer); - // If this isn't a sparse buffer, it needs to have memory backing it at CreateBufferView time - if (buffer_state) { - skip |= ValidateMemoryIsBoundToBuffer(device_data, buffer_state, "vkCreateBufferView()", VALIDATION_ERROR_01a0074e); - // In order to create a valid buffer view, the buffer must have been created with at least one of the following flags: - // UNIFORM_TEXEL_BUFFER_BIT or STORAGE_TEXEL_BUFFER_BIT - skip |= ValidateBufferUsageFlags( - device_data, buffer_state, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, false, - VALIDATION_ERROR_01a00748, "vkCreateBufferView()", "VK_BUFFER_USAGE_[STORAGE|UNIFORM]_TEXEL_BUFFER_BIT"); - } - return skip; -} - -void PostCallRecordCreateBufferView(layer_data *device_data, const VkBufferViewCreateInfo *pCreateInfo, VkBufferView *pView) { - (*GetBufferViewMap(device_data))[*pView] = std::unique_ptr(new BUFFER_VIEW_STATE(*pView, pCreateInfo)); -} - -// For the given format verify that the aspect masks make sense -bool ValidateImageAspectMask(layer_data *device_data, VkImage image, VkFormat format, VkImageAspectFlags aspect_mask, - const char *func_name) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - if (FormatIsColor(format)) { - if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set.", func_name); - } else if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != aspect_mask) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set.", func_name); - } - } else if (FormatIsDepthAndStencil(format)) { - if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Depth/stencil image formats must have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and " - "VK_IMAGE_ASPECT_STENCIL_BIT set.", - func_name); - } else if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspect_mask) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and " - "VK_IMAGE_ASPECT_STENCIL_BIT set.", - func_name); - } - } else if (FormatIsDepthOnly(format)) { - if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set.", func_name); - } else if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspect_mask) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set.", func_name); - } - } else if (FormatIsStencilOnly(format)) { - if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set.", func_name); - } else if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspect_mask) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set.", func_name); - } - } else if (FormatIsMultiplane(format)) { - VkImageAspectFlags valid_flags = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT; - if (3 == FormatPlaneCount(format)) { - valid_flags = valid_flags | VK_IMAGE_ASPECT_PLANE_2_BIT; - } - if ((aspect_mask & valid_flags) != aspect_mask) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "%s: Multi-plane image formats may have only VK_IMAGE_ASPECT_COLOR_BIT or VK_IMAGE_ASPECT_PLANE_n_BITs " - "set, where n = [0, 1, 2].", - func_name); - } - } - return skip; -} - -struct SubresourceRangeErrorCodes { - UNIQUE_VALIDATION_ERROR_CODE base_mip_err, mip_count_err, base_layer_err, layer_count_err; -}; - -bool ValidateImageSubresourceRange(const layer_data *device_data, const uint32_t image_mip_count, const uint32_t image_layer_count, - const VkImageSubresourceRange &subresourceRange, const char *cmd_name, const char *param_name, - const char *image_layer_count_var_name, const uint64_t image_handle, - SubresourceRangeErrorCodes errorCodes) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - - // Validate mip levels - if (subresourceRange.baseMipLevel >= image_mip_count) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle, - errorCodes.base_mip_err, - "%s: %s.baseMipLevel (= %" PRIu32 - ") is greater or equal to the mip level count of the image (i.e. greater or equal to %" PRIu32 ").", - cmd_name, param_name, subresourceRange.baseMipLevel, image_mip_count); - } - - if (subresourceRange.levelCount != VK_REMAINING_MIP_LEVELS) { - if (subresourceRange.levelCount == 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle, - errorCodes.mip_count_err, "%s: %s.levelCount is 0.", cmd_name, param_name); - } else { - const uint64_t necessary_mip_count = uint64_t{subresourceRange.baseMipLevel} + uint64_t{subresourceRange.levelCount}; - - if (necessary_mip_count > image_mip_count) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle, - errorCodes.mip_count_err, - "%s: %s.baseMipLevel + .levelCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64 - ") is greater than the mip level count of the image (i.e. greater than %" PRIu32 ").", - cmd_name, param_name, subresourceRange.baseMipLevel, subresourceRange.levelCount, - necessary_mip_count, image_mip_count); - } - } - } - - // Validate array layers - if (subresourceRange.baseArrayLayer >= image_layer_count) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle, - errorCodes.base_layer_err, - "%s: %s.baseArrayLayer (= %" PRIu32 - ") is greater or equal to the %s of the image when it was created (i.e. greater or equal to %" PRIu32 ").", - cmd_name, param_name, subresourceRange.baseArrayLayer, image_layer_count_var_name, image_layer_count); - } - - if (subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS) { - if (subresourceRange.layerCount == 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle, - errorCodes.layer_count_err, "%s: %s.layerCount is 0.", cmd_name, param_name); - } else { - const uint64_t necessary_layer_count = - uint64_t{subresourceRange.baseArrayLayer} + uint64_t{subresourceRange.layerCount}; - - if (necessary_layer_count > image_layer_count) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle, - errorCodes.layer_count_err, - "%s: %s.baseArrayLayer + .layerCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64 - ") is greater than the %s of the image when it was created (i.e. greater than %" PRIu32 ").", - cmd_name, param_name, subresourceRange.baseArrayLayer, subresourceRange.layerCount, - necessary_layer_count, image_layer_count_var_name, image_layer_count); - } - } - } - - return skip; -} - -bool ValidateCreateImageViewSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - bool is_imageview_2d_type, const VkImageSubresourceRange &subresourceRange) { - bool is_khr_maintenance1 = GetDeviceExtensions(device_data)->vk_khr_maintenance1; - bool is_image_slicable = image_state->createInfo.imageType == VK_IMAGE_TYPE_3D && - (image_state->createInfo.flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR); - bool is_3D_to_2D_map = is_khr_maintenance1 && is_image_slicable && is_imageview_2d_type; - - const auto image_layer_count = is_3D_to_2D_map ? image_state->createInfo.extent.depth : image_state->createInfo.arrayLayers; - const auto image_layer_count_var_name = is_3D_to_2D_map ? "extent.depth" : "arrayLayers"; - - SubresourceRangeErrorCodes subresourceRangeErrorCodes = {}; - subresourceRangeErrorCodes.base_mip_err = VALIDATION_ERROR_0ac00b8c; - subresourceRangeErrorCodes.mip_count_err = VALIDATION_ERROR_0ac00d6c; - subresourceRangeErrorCodes.base_layer_err = - is_khr_maintenance1 ? (is_3D_to_2D_map ? VALIDATION_ERROR_0ac00b98 : VALIDATION_ERROR_0ac00b94) : VALIDATION_ERROR_0ac00b90; - subresourceRangeErrorCodes.layer_count_err = - is_khr_maintenance1 ? (is_3D_to_2D_map ? VALIDATION_ERROR_0ac00b9a : VALIDATION_ERROR_0ac00b96) : VALIDATION_ERROR_0ac00d6e; - - return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_layer_count, subresourceRange, - "vkCreateImageView", "pCreateInfo->subresourceRange", image_layer_count_var_name, - HandleToUint64(image_state->image), subresourceRangeErrorCodes); -} - -bool ValidateCmdClearColorSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - const VkImageSubresourceRange &subresourceRange, const char *param_name) { - SubresourceRangeErrorCodes subresourceRangeErrorCodes = {}; - subresourceRangeErrorCodes.base_mip_err = VALIDATION_ERROR_18800b7c; - subresourceRangeErrorCodes.mip_count_err = VALIDATION_ERROR_18800d38; - subresourceRangeErrorCodes.base_layer_err = VALIDATION_ERROR_18800b80; - subresourceRangeErrorCodes.layer_count_err = VALIDATION_ERROR_18800d3a; - - return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers, - subresourceRange, "vkCmdClearColorImage", param_name, "arrayLayers", - HandleToUint64(image_state->image), subresourceRangeErrorCodes); -} - -bool ValidateCmdClearDepthSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - const VkImageSubresourceRange &subresourceRange, const char *param_name) { - SubresourceRangeErrorCodes subresourceRangeErrorCodes = {}; - subresourceRangeErrorCodes.base_mip_err = VALIDATION_ERROR_18a00b84; - subresourceRangeErrorCodes.mip_count_err = VALIDATION_ERROR_18a00d3c; - subresourceRangeErrorCodes.base_layer_err = VALIDATION_ERROR_18a00b88; - subresourceRangeErrorCodes.layer_count_err = VALIDATION_ERROR_18a00d3e; - - return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers, - subresourceRange, "vkCmdClearDepthStencilImage", param_name, "arrayLayers", - HandleToUint64(image_state->image), subresourceRangeErrorCodes); -} - -bool ValidateImageBarrierSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - const VkImageSubresourceRange &subresourceRange, const char *cmd_name, - const char *param_name) { - SubresourceRangeErrorCodes subresourceRangeErrorCodes = {}; - subresourceRangeErrorCodes.base_mip_err = VALIDATION_ERROR_0a000b9c; - subresourceRangeErrorCodes.mip_count_err = VALIDATION_ERROR_0a000d78; - subresourceRangeErrorCodes.base_layer_err = VALIDATION_ERROR_0a000ba0; - subresourceRangeErrorCodes.layer_count_err = VALIDATION_ERROR_0a000d7a; - - return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers, - subresourceRange, cmd_name, param_name, "arrayLayers", HandleToUint64(image_state->image), - subresourceRangeErrorCodes); -} - -bool PreCallValidateCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - IMAGE_STATE *image_state = GetImageState(device_data, create_info->image); - if (image_state) { - skip |= ValidateImageUsageFlags( - device_data, image_state, - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - false, -1, "vkCreateImageView()", - "VK_IMAGE_USAGE_[SAMPLED|STORAGE|COLOR_ATTACHMENT|DEPTH_STENCIL_ATTACHMENT|INPUT_ATTACHMENT]_BIT"); - // If this isn't a sparse image, it needs to have memory backing it at CreateImageView time - skip |= ValidateMemoryIsBoundToImage(device_data, image_state, "vkCreateImageView()", VALIDATION_ERROR_0ac007f8); - // Checks imported from image layer - skip |= ValidateCreateImageViewSubresourceRange( - device_data, image_state, - create_info->viewType == VK_IMAGE_VIEW_TYPE_2D || create_info->viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY, - create_info->subresourceRange); - - VkImageCreateFlags image_flags = image_state->createInfo.flags; - VkFormat image_format = image_state->createInfo.format; - VkImageUsageFlags image_usage = image_state->createInfo.usage; - VkImageTiling image_tiling = image_state->createInfo.tiling; - VkFormat view_format = create_info->format; - VkImageAspectFlags aspect_mask = create_info->subresourceRange.aspectMask; - VkImageType image_type = image_state->createInfo.imageType; - VkImageViewType view_type = create_info->viewType; - - // If there's a chained VkImageViewUsageCreateInfo struct, modify image_usage to match - auto chained_ivuci_struct = lvl_find_in_chain(create_info->pNext); - if (chained_ivuci_struct) { - if (chained_ivuci_struct->usage & ~image_usage) { - std::stringstream ss; - ss << "vkCreateImageView(): Chained VkImageViewUsageCreateInfo usage field (0x" << std::hex - << chained_ivuci_struct->usage << ") must not include flags not present in underlying image's usage (0x" - << image_usage << ")."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_3f200c66, "%s", ss.str().c_str()); - } - - image_usage = chained_ivuci_struct->usage; - } - - // Validate VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT state, if view/image formats differ - if ((image_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) && (image_format != view_format)) { - if (FormatIsMultiplane(image_format)) { - // View format must match the multiplane compatible format - uint32_t plane = 3; // invalid - switch (aspect_mask) { - case VK_IMAGE_ASPECT_PLANE_0_BIT: - plane = 0; - break; - case VK_IMAGE_ASPECT_PLANE_1_BIT: - plane = 1; - break; - case VK_IMAGE_ASPECT_PLANE_2_BIT: - plane = 2; - break; - default: - break; - } - - VkFormat compat_format = FindMultiplaneCompatibleFormat(image_format, plane); - if (view_format != compat_format) { - std::stringstream ss; - ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format) - << " is not compatible with plane " << plane << " of underlying image format " - << string_VkFormat(image_format) << ", must be " << string_VkFormat(compat_format) << "."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac00c64, "%s", ss.str().c_str()); - } - } else { - if ((!GetDeviceExtensions(device_data)->vk_khr_maintenance2 || - !(image_flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR))) { - // Format MUST be compatible (in the same format compatibility class) as the format the image was created with - if (FormatCompatibilityClass(image_format) != FormatCompatibilityClass(view_format)) { - std::stringstream ss; - ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format) - << " is not in the same format compatibility class as image (" << HandleToUint64(create_info->image) - << ") format " << string_VkFormat(image_format) - << ". Images created with the VK_IMAGE_CREATE_MUTABLE_FORMAT BIT " - << "can support ImageViews with differing formats but they must be in the same compatibility class."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007f4, "%s", ss.str().c_str()); - } - } - } - } else { - // Format MUST be IDENTICAL to the format the image was created with - if (image_format != view_format) { - std::stringstream ss; - ss << "vkCreateImageView() format " << string_VkFormat(view_format) << " differs from image " - << HandleToUint64(create_info->image) << " format " << string_VkFormat(image_format) - << ". Formats MUST be IDENTICAL unless VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image creation."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007f6, "%s", ss.str().c_str()); - } - } - - // Validate correct image aspect bits for desired formats and format consistency - skip |= ValidateImageAspectMask(device_data, image_state->image, image_format, aspect_mask, "vkCreateImageView()"); - - switch (image_type) { - case VK_IMAGE_TYPE_1D: - if (view_type != VK_IMAGE_VIEW_TYPE_1D && view_type != VK_IMAGE_VIEW_TYPE_1D_ARRAY) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007fa, - "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.", - string_VkImageViewType(view_type), string_VkImageType(image_type)); - } - break; - case VK_IMAGE_TYPE_2D: - if (view_type != VK_IMAGE_VIEW_TYPE_2D && view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) { - if ((view_type == VK_IMAGE_VIEW_TYPE_CUBE || view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) && - !(image_flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007d6, - "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.", - string_VkImageViewType(view_type), string_VkImageType(image_type)); - } else if (view_type != VK_IMAGE_VIEW_TYPE_CUBE && view_type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007fa, - "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.", - string_VkImageViewType(view_type), string_VkImageType(image_type)); - } - } - break; - case VK_IMAGE_TYPE_3D: - if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - if (view_type != VK_IMAGE_VIEW_TYPE_3D) { - if ((view_type == VK_IMAGE_VIEW_TYPE_2D || view_type == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) { - if (!(image_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007da, - "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.", - string_VkImageViewType(view_type), string_VkImageType(image_type)); - } else if ((image_flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT))) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007fa, - "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s " - "when the VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or " - "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flags are enabled.", - string_VkImageViewType(view_type), string_VkImageType(image_type)); - } - } else { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007fa, - "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.", - string_VkImageViewType(view_type), string_VkImageType(image_type)); - } - } - } else { - if (view_type != VK_IMAGE_VIEW_TYPE_3D) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0ac007fa, - "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.", - string_VkImageViewType(view_type), string_VkImageType(image_type)); - } - } - break; - default: - break; - } - - VkFormatProperties format_properties = GetFormatProperties(device_data, view_format); - bool check_tiling_features = false; - VkFormatFeatureFlags tiling_features = 0; - UNIQUE_VALIDATION_ERROR_CODE linear_error_codes[] = { - VALIDATION_ERROR_0ac007dc, VALIDATION_ERROR_0ac007e0, VALIDATION_ERROR_0ac007e2, - VALIDATION_ERROR_0ac007e4, VALIDATION_ERROR_0ac007e6, - }; - UNIQUE_VALIDATION_ERROR_CODE optimal_error_codes[] = { - VALIDATION_ERROR_0ac007e8, VALIDATION_ERROR_0ac007ea, VALIDATION_ERROR_0ac007ec, - VALIDATION_ERROR_0ac007ee, VALIDATION_ERROR_0ac007f0, - }; - UNIQUE_VALIDATION_ERROR_CODE *error_codes = nullptr; - if (image_tiling == VK_IMAGE_TILING_LINEAR) { - tiling_features = format_properties.linearTilingFeatures; - error_codes = linear_error_codes; - check_tiling_features = true; - } else if (image_tiling == VK_IMAGE_TILING_OPTIMAL) { - tiling_features = format_properties.optimalTilingFeatures; - error_codes = optimal_error_codes; - check_tiling_features = true; - } - - if (check_tiling_features) { - if (tiling_features == 0) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, error_codes[0], - "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s flag set.", - string_VkFormat(view_format), string_VkImageTiling(image_tiling)); - } else if ((image_usage & VK_IMAGE_USAGE_SAMPLED_BIT) && !(tiling_features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, error_codes[1], - "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and " - "VK_IMAGE_USAGE_SAMPLED_BIT flags set.", - string_VkFormat(view_format), string_VkImageTiling(image_tiling)); - } else if ((image_usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(tiling_features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, error_codes[2], - "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and " - "VK_IMAGE_USAGE_STORAGE_BIT flags set.", - string_VkFormat(view_format), string_VkImageTiling(image_tiling)); - } else if ((image_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && - !(tiling_features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, error_codes[3], - "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and " - "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT flags set.", - string_VkFormat(view_format), string_VkImageTiling(image_tiling)); - } else if ((image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && - !(tiling_features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, error_codes[4], - "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and " - "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT flags set.", - string_VkFormat(view_format), string_VkImageTiling(image_tiling)); - } - } - } - return skip; -} - -void PostCallRecordCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info, VkImageView view) { - auto image_view_map = GetImageViewMap(device_data); - (*image_view_map)[view] = std::unique_ptr(new IMAGE_VIEW_STATE(view, create_info)); - - auto image_state = GetImageState(device_data, create_info->image); - auto &sub_res_range = (*image_view_map)[view].get()->create_info.subresourceRange; - sub_res_range.levelCount = ResolveRemainingLevels(&sub_res_range, image_state->createInfo.mipLevels); - sub_res_range.layerCount = ResolveRemainingLayers(&sub_res_range, image_state->createInfo.arrayLayers); -} - -bool PreCallValidateCmdCopyBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state, - BUFFER_STATE *dst_buffer_state) { - bool skip = false; - skip |= ValidateMemoryIsBoundToBuffer(device_data, src_buffer_state, "vkCmdCopyBuffer()", VALIDATION_ERROR_18c000ee); - skip |= ValidateMemoryIsBoundToBuffer(device_data, dst_buffer_state, "vkCmdCopyBuffer()", VALIDATION_ERROR_18c000f2); - // Validate that SRC & DST buffers have correct usage flags set - skip |= ValidateBufferUsageFlags(device_data, src_buffer_state, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, - VALIDATION_ERROR_18c000ec, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); - skip |= ValidateBufferUsageFlags(device_data, dst_buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, - VALIDATION_ERROR_18c000f0, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); - skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdCopyBuffer()", - VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, VALIDATION_ERROR_18c02415); - skip |= ValidateCmd(device_data, cb_node, CMD_COPYBUFFER, "vkCmdCopyBuffer()"); - skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyBuffer()", VALIDATION_ERROR_18c00017); - return skip; -} - -void PreCallRecordCmdCopyBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state, - BUFFER_STATE *dst_buffer_state) { - // Update bindings between buffers and cmd buffer - AddCommandBufferBindingBuffer(device_data, cb_node, src_buffer_state); - AddCommandBufferBindingBuffer(device_data, cb_node, dst_buffer_state); -} - -static bool validateIdleBuffer(layer_data *device_data, VkBuffer buffer) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = false; - auto buffer_state = GetBufferState(device_data, buffer); - if (!buffer_state) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, HandleToUint64(buffer), - DRAWSTATE_DOUBLE_DESTROY, "Cannot free buffer 0x%" PRIx64 " that has not been allocated.", - HandleToUint64(buffer)); - } else { - if (buffer_state->in_use.load()) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - HandleToUint64(buffer), VALIDATION_ERROR_23c00734, - "Cannot free buffer 0x%" PRIx64 " that is in use by a command buffer.", HandleToUint64(buffer)); - } - } - return skip; -} - -bool PreCallValidateDestroyImageView(layer_data *device_data, VkImageView image_view, IMAGE_VIEW_STATE **image_view_state, - VK_OBJECT *obj_struct) { - *image_view_state = GetImageViewState(device_data, image_view); - *obj_struct = {HandleToUint64(image_view), kVulkanObjectTypeImageView}; - if (GetDisables(device_data)->destroy_image_view) return false; - bool skip = false; - if (*image_view_state) { - skip |= - ValidateObjectNotInUse(device_data, *image_view_state, *obj_struct, "vkDestroyImageView", VALIDATION_ERROR_25400804); - } - return skip; -} - -void PreCallRecordDestroyImageView(layer_data *device_data, VkImageView image_view, IMAGE_VIEW_STATE *image_view_state, - VK_OBJECT obj_struct) { - // Any bound cmd buffers are now invalid - invalidateCommandBuffers(device_data, image_view_state->cb_bindings, obj_struct); - (*GetImageViewMap(device_data)).erase(image_view); -} - -bool PreCallValidateDestroyBuffer(layer_data *device_data, VkBuffer buffer, BUFFER_STATE **buffer_state, VK_OBJECT *obj_struct) { - *buffer_state = GetBufferState(device_data, buffer); - *obj_struct = {HandleToUint64(buffer), kVulkanObjectTypeBuffer}; - if (GetDisables(device_data)->destroy_buffer) return false; - bool skip = false; - if (*buffer_state) { - skip |= validateIdleBuffer(device_data, buffer); - } - return skip; -} - -void PreCallRecordDestroyBuffer(layer_data *device_data, VkBuffer buffer, BUFFER_STATE *buffer_state, VK_OBJECT obj_struct) { - invalidateCommandBuffers(device_data, buffer_state->cb_bindings, obj_struct); - for (auto mem_binding : buffer_state->GetBoundMemory()) { - auto mem_info = GetMemObjInfo(device_data, mem_binding); - if (mem_info) { - core_validation::RemoveBufferMemoryRange(HandleToUint64(buffer), mem_info); - } - } - ClearMemoryObjectBindings(device_data, HandleToUint64(buffer), kVulkanObjectTypeBuffer); - GetBufferMap(device_data)->erase(buffer_state->buffer); -} - -bool PreCallValidateDestroyBufferView(layer_data *device_data, VkBufferView buffer_view, BUFFER_VIEW_STATE **buffer_view_state, - VK_OBJECT *obj_struct) { - *buffer_view_state = GetBufferViewState(device_data, buffer_view); - *obj_struct = {HandleToUint64(buffer_view), kVulkanObjectTypeBufferView}; - if (GetDisables(device_data)->destroy_buffer_view) return false; - bool skip = false; - if (*buffer_view_state) { - skip |= - ValidateObjectNotInUse(device_data, *buffer_view_state, *obj_struct, "vkDestroyBufferView", VALIDATION_ERROR_23e00750); - } - return skip; -} - -void PreCallRecordDestroyBufferView(layer_data *device_data, VkBufferView buffer_view, BUFFER_VIEW_STATE *buffer_view_state, - VK_OBJECT obj_struct) { - // Any bound cmd buffers are now invalid - invalidateCommandBuffers(device_data, buffer_view_state->cb_bindings, obj_struct); - GetBufferViewMap(device_data)->erase(buffer_view); -} - -bool PreCallValidateCmdFillBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *buffer_state) { - bool skip = false; - skip |= ValidateMemoryIsBoundToBuffer(device_data, buffer_state, "vkCmdFillBuffer()", VALIDATION_ERROR_1b40003e); - skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdFillBuffer()", - VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, VALIDATION_ERROR_1b402415); - skip |= ValidateCmd(device_data, cb_node, CMD_FILLBUFFER, "vkCmdFillBuffer()"); - // Validate that DST buffer has correct usage flags set - skip |= ValidateBufferUsageFlags(device_data, buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, VALIDATION_ERROR_1b40003a, - "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); - skip |= insideRenderPass(device_data, cb_node, "vkCmdFillBuffer()", VALIDATION_ERROR_1b400017); - return skip; -} - -void PreCallRecordCmdFillBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *buffer_state) { - // Update bindings between buffer and cmd buffer - AddCommandBufferBindingBuffer(device_data, cb_node, buffer_state); -} - -bool ValidateBufferImageCopyData(const debug_report_data *report_data, uint32_t regionCount, const VkBufferImageCopy *pRegions, - IMAGE_STATE *image_state, const char *function) { - bool skip = false; - - for (uint32_t i = 0; i < regionCount; i++) { - if (image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) { - if ((pRegions[i].imageOffset.y != 0) || (pRegions[i].imageExtent.height != 1)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_0160018e, - "%s(): pRegion[%d] imageOffset.y is %d and imageExtent.height is %d. For 1D images these must be 0 " - "and 1, respectively.", - function, i, pRegions[i].imageOffset.y, pRegions[i].imageExtent.height); - } - } - - if ((image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) || (image_state->createInfo.imageType == VK_IMAGE_TYPE_2D)) { - if ((pRegions[i].imageOffset.z != 0) || (pRegions[i].imageExtent.depth != 1)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_01600192, - "%s(): pRegion[%d] imageOffset.z is %d and imageExtent.depth is %d. For 1D and 2D images these " - "must be 0 and 1, respectively.", - function, i, pRegions[i].imageOffset.z, pRegions[i].imageExtent.depth); - } - } - - if (image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) { - if ((0 != pRegions[i].imageSubresource.baseArrayLayer) || (1 != pRegions[i].imageSubresource.layerCount)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_016001aa, - "%s(): pRegion[%d] imageSubresource.baseArrayLayer is %d and imageSubresource.layerCount is %d. " - "For 3D images these must be 0 and 1, respectively.", - function, i, pRegions[i].imageSubresource.baseArrayLayer, pRegions[i].imageSubresource.layerCount); - } - } - - // If the the calling command's VkImage parameter's format is not a depth/stencil format, - // then bufferOffset must be a multiple of the calling command's VkImage parameter's texel size - auto texel_size = FormatSize(image_state->createInfo.format); - if (!FormatIsDepthAndStencil(image_state->createInfo.format) && SafeModulo(pRegions[i].bufferOffset, texel_size) != 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_01600182, - "%s(): pRegion[%d] bufferOffset 0x%" PRIxLEAST64 - " must be a multiple of this format's texel size (" PRINTF_SIZE_T_SPECIFIER ").", - function, i, pRegions[i].bufferOffset, texel_size); - } - - // BufferOffset must be a multiple of 4 - if (SafeModulo(pRegions[i].bufferOffset, 4) != 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_01600184, - "%s(): pRegion[%d] bufferOffset 0x%" PRIxLEAST64 " must be a multiple of 4.", function, i, - pRegions[i].bufferOffset); - } - - // BufferRowLength must be 0, or greater than or equal to the width member of imageExtent - if ((pRegions[i].bufferRowLength != 0) && (pRegions[i].bufferRowLength < pRegions[i].imageExtent.width)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_01600186, - "%s(): pRegion[%d] bufferRowLength (%d) must be zero or greater-than-or-equal-to imageExtent.width (%d).", - function, i, pRegions[i].bufferRowLength, pRegions[i].imageExtent.width); - } - - // BufferImageHeight must be 0, or greater than or equal to the height member of imageExtent - if ((pRegions[i].bufferImageHeight != 0) && (pRegions[i].bufferImageHeight < pRegions[i].imageExtent.height)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_01600188, - "%s(): pRegion[%d] bufferImageHeight (%d) must be zero or greater-than-or-equal-to imageExtent.height (%d).", - function, i, pRegions[i].bufferImageHeight, pRegions[i].imageExtent.height); - } - - // subresource aspectMask must have exactly 1 bit set - const int num_bits = sizeof(VkFlags) * CHAR_BIT; - std::bitset aspect_mask_bits(pRegions[i].imageSubresource.aspectMask); - if (aspect_mask_bits.count() != 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_016001a8, - "%s: aspectMasks for imageSubresource in each region must have only a single bit set.", function); - } - - // image subresource aspect bit must match format - if (!VerifyAspectsPresent(pRegions[i].imageSubresource.aspectMask, image_state->createInfo.format)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_016001a6, - "%s(): pRegion[%d] subresource aspectMask 0x%x specifies aspects that are not present in image format 0x%x.", - function, i, pRegions[i].imageSubresource.aspectMask, image_state->createInfo.format); - } - - // Checks that apply only to compressed images - if (FormatIsCompressed(image_state->createInfo.format) || FormatIsSinglePlane_422(image_state->createInfo.format)) { - auto block_size = FormatCompressedTexelBlockExtent(image_state->createInfo.format); - - // BufferRowLength must be a multiple of block width - if (SafeModulo(pRegions[i].bufferRowLength, block_size.width) != 0) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_01600196, - "%s(): pRegion[%d] bufferRowLength (%d) must be a multiple of the compressed image's texel width (%d)..", - function, i, pRegions[i].bufferRowLength, block_size.width); - } - - // BufferRowHeight must be a multiple of block height - if (SafeModulo(pRegions[i].bufferImageHeight, block_size.height) != 0) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_01600198, - "%s(): pRegion[%d] bufferImageHeight (%d) must be a multiple of the compressed image's texel height (%d)..", - function, i, pRegions[i].bufferImageHeight, block_size.height); - } - - // image offsets must be multiples of block dimensions - if ((SafeModulo(pRegions[i].imageOffset.x, block_size.width) != 0) || - (SafeModulo(pRegions[i].imageOffset.y, block_size.height) != 0) || - (SafeModulo(pRegions[i].imageOffset.z, block_size.depth) != 0)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_0160019a, - "%s(): pRegion[%d] imageOffset(x,y) (%d, %d) must be multiples of the compressed image's texel " - "width & height (%d, %d)..", - function, i, pRegions[i].imageOffset.x, pRegions[i].imageOffset.y, block_size.width, block_size.height); - } - - // bufferOffset must be a multiple of block size (linear bytes) - size_t block_size_in_bytes = FormatSize(image_state->createInfo.format); - if (SafeModulo(pRegions[i].bufferOffset, block_size_in_bytes) != 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_0160019c, - "%s(): pRegion[%d] bufferOffset (0x%" PRIxLEAST64 - ") must be a multiple of the compressed image's texel block size (" PRINTF_SIZE_T_SPECIFIER ")..", - function, i, pRegions[i].bufferOffset, block_size_in_bytes); - } - - // imageExtent width must be a multiple of block width, or extent+offset width must equal subresource width - VkExtent3D mip_extent = GetImageSubresourceExtent(image_state, &(pRegions[i].imageSubresource)); - if ((SafeModulo(pRegions[i].imageExtent.width, block_size.width) != 0) && - (pRegions[i].imageExtent.width + pRegions[i].imageOffset.x != mip_extent.width)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_0160019e, - "%s(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block width " - "(%d), or when added to offset.x (%d) must equal the image subresource width (%d)..", - function, i, pRegions[i].imageExtent.width, block_size.width, pRegions[i].imageOffset.x, - mip_extent.width); - } - - // imageExtent height must be a multiple of block height, or extent+offset height must equal subresource height - if ((SafeModulo(pRegions[i].imageExtent.height, block_size.height) != 0) && - (pRegions[i].imageExtent.height + pRegions[i].imageOffset.y != mip_extent.height)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_016001a0, - "%s(): pRegion[%d] extent height (%d) must be a multiple of the compressed texture block height " - "(%d), or when added to offset.y (%d) must equal the image subresource height (%d)..", - function, i, pRegions[i].imageExtent.height, block_size.height, pRegions[i].imageOffset.y, - mip_extent.height); - } - - // imageExtent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth - if ((SafeModulo(pRegions[i].imageExtent.depth, block_size.depth) != 0) && - (pRegions[i].imageExtent.depth + pRegions[i].imageOffset.z != mip_extent.depth)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), VALIDATION_ERROR_016001a2, - "%s(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block depth " - "(%d), or when added to offset.z (%d) must equal the image subresource depth (%d)..", - function, i, pRegions[i].imageExtent.depth, block_size.depth, pRegions[i].imageOffset.z, - mip_extent.depth); - } - } - } - - return skip; -} - -static bool ValidateImageBounds(const debug_report_data *report_data, const IMAGE_STATE *image_state, const uint32_t regionCount, - const VkBufferImageCopy *pRegions, const char *func_name, UNIQUE_VALIDATION_ERROR_CODE msg_code) { - bool skip = false; - const VkImageCreateInfo *image_info = &(image_state->createInfo); - - for (uint32_t i = 0; i < regionCount; i++) { - VkExtent3D extent = pRegions[i].imageExtent; - VkOffset3D offset = pRegions[i].imageOffset; - - if (IsExtentSizeZero(&extent)) // Warn on zero area subresource - { - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)0, IMAGE_ZERO_AREA_SUBREGION, "%s: pRegion[%d] imageExtent of {%1d, %1d, %1d} has zero area", - func_name, i, extent.width, extent.height, extent.depth); - } - - VkExtent3D image_extent = GetImageSubresourceExtent(image_state, &(pRegions[i].imageSubresource)); - - // If we're using a compressed format, valid extent is rounded up to multiple of block size (per 18.1) - if (FormatIsCompressed(image_info->format)) { - auto block_extent = FormatCompressedTexelBlockExtent(image_info->format); - if (image_extent.width % block_extent.width) { - image_extent.width += (block_extent.width - (image_extent.width % block_extent.width)); - } - if (image_extent.height % block_extent.height) { - image_extent.height += (block_extent.height - (image_extent.height % block_extent.height)); - } - if (image_extent.depth % block_extent.depth) { - image_extent.depth += (block_extent.depth - (image_extent.depth % block_extent.depth)); - } - } - - if (0 != ExceedsBounds(&offset, &extent, &image_extent)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)0, - msg_code, "%s: pRegion[%d] exceeds image bounds..", func_name, i); - } - } - - return skip; -} - -static inline bool ValidateBufferBounds(const debug_report_data *report_data, IMAGE_STATE *image_state, BUFFER_STATE *buff_state, - uint32_t regionCount, const VkBufferImageCopy *pRegions, const char *func_name, - UNIQUE_VALIDATION_ERROR_CODE msg_code) { - bool skip = false; - - VkDeviceSize buffer_size = buff_state->createInfo.size; - - for (uint32_t i = 0; i < regionCount; i++) { - VkExtent3D copy_extent = pRegions[i].imageExtent; - - VkDeviceSize buffer_width = (0 == pRegions[i].bufferRowLength ? copy_extent.width : pRegions[i].bufferRowLength); - VkDeviceSize buffer_height = (0 == pRegions[i].bufferImageHeight ? copy_extent.height : pRegions[i].bufferImageHeight); - VkDeviceSize unit_size = FormatSize(image_state->createInfo.format); // size (bytes) of texel or block - - // Handle special buffer packing rules for specific depth/stencil formats - if (pRegions[i].imageSubresource.aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) { - unit_size = FormatSize(VK_FORMAT_S8_UINT); - } else if (pRegions[i].imageSubresource.aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) { - switch (image_state->createInfo.format) { - case VK_FORMAT_D16_UNORM_S8_UINT: - unit_size = FormatSize(VK_FORMAT_D16_UNORM); - break; - case VK_FORMAT_D32_SFLOAT_S8_UINT: - unit_size = FormatSize(VK_FORMAT_D32_SFLOAT); - break; - case VK_FORMAT_X8_D24_UNORM_PACK32: // Fall through - case VK_FORMAT_D24_UNORM_S8_UINT: - unit_size = 4; - break; - default: - break; - } - } - - if (FormatIsCompressed(image_state->createInfo.format)) { - // Switch to texel block units, rounding up for any partially-used blocks - auto block_dim = FormatCompressedTexelBlockExtent(image_state->createInfo.format); - buffer_width = (buffer_width + block_dim.width - 1) / block_dim.width; - buffer_height = (buffer_height + block_dim.height - 1) / block_dim.height; - - copy_extent.width = (copy_extent.width + block_dim.width - 1) / block_dim.width; - copy_extent.height = (copy_extent.height + block_dim.height - 1) / block_dim.height; - copy_extent.depth = (copy_extent.depth + block_dim.depth - 1) / block_dim.depth; - } - - // Either depth or layerCount may be greater than 1 (not both). This is the number of 'slices' to copy - uint32_t z_copies = std::max(copy_extent.depth, pRegions[i].imageSubresource.layerCount); - if (IsExtentSizeZero(©_extent) || (0 == z_copies)) { - // TODO: Issue warning here? Already warned in ValidateImageBounds()... - } else { - // Calculate buffer offset of final copied byte, + 1. - VkDeviceSize max_buffer_offset = (z_copies - 1) * buffer_height * buffer_width; // offset to slice - max_buffer_offset += ((copy_extent.height - 1) * buffer_width) + copy_extent.width; // add row,col - max_buffer_offset *= unit_size; // convert to bytes - max_buffer_offset += pRegions[i].bufferOffset; // add initial offset (bytes) - - if (buffer_size < max_buffer_offset) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)0, - msg_code, "%s: pRegion[%d] exceeds buffer size of %" PRIu64 " bytes..", func_name, i, buffer_size); - } - } - } - - return skip; -} - -bool PreCallValidateCmdCopyImageToBuffer(layer_data *device_data, VkImageLayout srcImageLayout, GLOBAL_CB_NODE *cb_node, - IMAGE_STATE *src_image_state, BUFFER_STATE *dst_buffer_state, uint32_t regionCount, - const VkBufferImageCopy *pRegions, const char *func_name) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, src_image_state, "vkCmdCopyImageToBuffer"); - - // Validate command buffer state - skip |= ValidateCmd(device_data, cb_node, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()"); - - // Command pool must support graphics, compute, or transfer operations - auto pPool = GetCommandPoolNode(device_data, cb_node->createInfo.commandPool); - - VkQueueFlags queue_flags = GetPhysDevProperties(device_data)->queue_family_properties[pPool->queueFamilyIndex].queueFlags; - if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->createInfo.commandPool), VALIDATION_ERROR_19202415, - "Cannot call vkCmdCopyImageToBuffer() on a command buffer allocated from a pool without graphics, compute, " - "or transfer capabilities.."); - } - skip |= ValidateImageBounds(report_data, src_image_state, regionCount, pRegions, "vkCmdCopyImageToBuffer()", - VALIDATION_ERROR_1920016c); - skip |= ValidateBufferBounds(report_data, src_image_state, dst_buffer_state, regionCount, pRegions, "vkCmdCopyImageToBuffer()", - VALIDATION_ERROR_1920016e); - - skip |= ValidateImageSampleCount(device_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyImageToBuffer(): srcImage", - VALIDATION_ERROR_19200178); - skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdCopyImageToBuffer()", VALIDATION_ERROR_19200176); - skip |= ValidateMemoryIsBoundToBuffer(device_data, dst_buffer_state, "vkCmdCopyImageToBuffer()", VALIDATION_ERROR_19200180); - - // Validate that SRC image & DST buffer have correct usage flags set - skip |= ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, VALIDATION_ERROR_19200174, - "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); - skip |= ValidateBufferUsageFlags(device_data, dst_buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, - VALIDATION_ERROR_1920017e, "vkCmdCopyImageToBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); - if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - "vkCmdCopyImageToBuffer()", VALIDATION_ERROR_19200172, VALIDATION_ERROR_19200172); - } - skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyImageToBuffer()", VALIDATION_ERROR_19200017); - bool hit_error = false; - for (uint32_t i = 0; i < regionCount; ++i) { - skip |= VerifyImageLayout(device_data, cb_node, src_image_state, pRegions[i].imageSubresource, srcImageLayout, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdCopyImageToBuffer()", VALIDATION_ERROR_1920017c, - &hit_error); - skip |= ValidateCopyBufferImageTransferGranularityRequirements(device_data, cb_node, src_image_state, &pRegions[i], i, - "vkCmdCopyImageToBuffer()", VALIDATION_ERROR_19200e04); - } - return skip; -} - -void PreCallRecordCmdCopyImageToBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - BUFFER_STATE *dst_buffer_state, uint32_t region_count, const VkBufferImageCopy *regions, - VkImageLayout src_image_layout) { - // Make sure that all image slices are updated to correct layout - for (uint32_t i = 0; i < region_count; ++i) { - SetImageLayout(device_data, cb_node, src_image_state, regions[i].imageSubresource, src_image_layout); - } - // Update bindings between buffer/image and cmd buffer - AddCommandBufferBindingImage(device_data, cb_node, src_image_state); - AddCommandBufferBindingBuffer(device_data, cb_node, dst_buffer_state); -} - -bool PreCallValidateCmdCopyBufferToImage(layer_data *device_data, VkImageLayout dstImageLayout, GLOBAL_CB_NODE *cb_node, - BUFFER_STATE *src_buffer_state, IMAGE_STATE *dst_image_state, uint32_t regionCount, - const VkBufferImageCopy *pRegions, const char *func_name) { - const debug_report_data *report_data = core_validation::GetReportData(device_data); - bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, dst_image_state, "vkCmdCopyBufferToImage"); - - // Validate command buffer state - skip |= ValidateCmd(device_data, cb_node, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()"); - - // Command pool must support graphics, compute, or transfer operations - auto pPool = GetCommandPoolNode(device_data, cb_node->createInfo.commandPool); - VkQueueFlags queue_flags = GetPhysDevProperties(device_data)->queue_family_properties[pPool->queueFamilyIndex].queueFlags; - if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->createInfo.commandPool), VALIDATION_ERROR_18e02415, - "Cannot call vkCmdCopyBufferToImage() on a command buffer allocated from a pool without graphics, compute, " - "or transfer capabilities.."); - } - skip |= ValidateImageBounds(report_data, dst_image_state, regionCount, pRegions, "vkCmdCopyBufferToImage()", - VALIDATION_ERROR_18e00158); - skip |= ValidateBufferBounds(report_data, dst_image_state, src_buffer_state, regionCount, pRegions, "vkCmdCopyBufferToImage()", - VALIDATION_ERROR_18e00156); - skip |= ValidateImageSampleCount(device_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyBufferToImage(): dstImage", - VALIDATION_ERROR_18e00166); - skip |= ValidateMemoryIsBoundToBuffer(device_data, src_buffer_state, "vkCmdCopyBufferToImage()", VALIDATION_ERROR_18e00160); - skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdCopyBufferToImage()", VALIDATION_ERROR_18e00164); - skip |= ValidateBufferUsageFlags(device_data, src_buffer_state, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, - VALIDATION_ERROR_18e0015c, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); - skip |= ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, VALIDATION_ERROR_18e00162, - "vkCmdCopyBufferToImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); - if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) { - skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - "vkCmdCopyBufferToImage()", VALIDATION_ERROR_18e0015e, VALIDATION_ERROR_18e0015e); - } - skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyBufferToImage()", VALIDATION_ERROR_18e00017); - bool hit_error = false; - for (uint32_t i = 0; i < regionCount; ++i) { - skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, pRegions[i].imageSubresource, dstImageLayout, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdCopyBufferToImage()", VALIDATION_ERROR_18e0016a, - &hit_error); - skip |= ValidateCopyBufferImageTransferGranularityRequirements(device_data, cb_node, dst_image_state, &pRegions[i], i, - "vkCmdCopyBufferToImage()", VALIDATION_ERROR_18e00e02); - } - return skip; -} - -void PreCallRecordCmdCopyBufferToImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkBufferImageCopy *regions, - VkImageLayout dst_image_layout) { - // Make sure that all image slices are updated to correct layout - for (uint32_t i = 0; i < region_count; ++i) { - SetImageLayout(device_data, cb_node, dst_image_state, regions[i].imageSubresource, dst_image_layout); - } - AddCommandBufferBindingBuffer(device_data, cb_node, src_buffer_state); - AddCommandBufferBindingImage(device_data, cb_node, dst_image_state); -} - -bool PreCallValidateGetImageSubresourceLayout(layer_data *device_data, VkImage image, const VkImageSubresource *pSubresource) { - const auto report_data = core_validation::GetReportData(device_data); - bool skip = false; - const VkImageAspectFlags sub_aspect = pSubresource->aspectMask; - - // The aspectMask member of pSubresource must only have a single bit set - const int num_bits = sizeof(sub_aspect) * CHAR_BIT; - std::bitset aspect_mask_bits(sub_aspect); - if (aspect_mask_bits.count() != 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), - VALIDATION_ERROR_2a6007ca, - "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask must have exactly 1 bit set."); - } - - IMAGE_STATE *image_entry = GetImageState(device_data, image); - if (!image_entry) { - return skip; - } - - // image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR - if (image_entry->createInfo.tiling != VK_IMAGE_TILING_LINEAR) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), - VALIDATION_ERROR_2a6007c8, "vkGetImageSubresourceLayout(): Image must have tiling of VK_IMAGE_TILING_LINEAR."); - } - - // mipLevel must be less than the mipLevels specified in VkImageCreateInfo when the image was created - if (pSubresource->mipLevel >= image_entry->createInfo.mipLevels) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), - VALIDATION_ERROR_2a600d68, "vkGetImageSubresourceLayout(): pSubresource.mipLevel (%d) must be less than %d.", - pSubresource->mipLevel, image_entry->createInfo.mipLevels); - } - - // arrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when the image was created - if (pSubresource->arrayLayer >= image_entry->createInfo.arrayLayers) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), - VALIDATION_ERROR_2a600d6a, "vkGetImageSubresourceLayout(): pSubresource.arrayLayer (%d) must be less than %d.", - pSubresource->arrayLayer, image_entry->createInfo.arrayLayers); - } - - // subresource's aspect must be compatible with image's format. - const VkFormat img_format = image_entry->createInfo.format; - if (FormatIsMultiplane(img_format)) { - VkImageAspectFlags allowed_flags = (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR); - UNIQUE_VALIDATION_ERROR_CODE vuid = VALIDATION_ERROR_2a600c5a; // 2-plane version - if (FormatPlaneCount(img_format) > 2u) { - allowed_flags |= VK_IMAGE_ASPECT_PLANE_2_BIT_KHR; - vuid = VALIDATION_ERROR_2a600c5c; // 3-plane version - } - if (sub_aspect != (sub_aspect & allowed_flags)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), vuid, - "vkGetImageSubresourceLayout(): For multi-planar images, VkImageSubresource.aspectMask (0x%" PRIx32 - ") must be a single-plane specifier flag.", - sub_aspect); - } - } else if (FormatIsColor(img_format)) { - if (sub_aspect != VK_IMAGE_ASPECT_COLOR_BIT) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), - VALIDATION_ERROR_0a400c01, - "vkGetImageSubresourceLayout(): For color formats, VkImageSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR."); - } - } else if (FormatIsDepthOrStencil(img_format)) { - if ((sub_aspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (sub_aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image), VALIDATION_ERROR_0a400c01, - "vkGetImageSubresourceLayout(): For depth/stencil formats, VkImageSubresource.aspectMask must be " - "either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT."); - } - } - return skip; -} diff --git a/layers/buffer_validation.h b/layers/buffer_validation.h deleted file mode 100644 index d7a3682e..00000000 --- a/layers/buffer_validation.h +++ /dev/null @@ -1,265 +0,0 @@ -/* 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. - * - * Mark Lobodzinski - */ -#ifndef CORE_VALIDATION_BUFFER_VALIDATION_H_ -#define CORE_VALIDATION_BUFFER_VALIDATION_H_ - -#include "core_validation_types.h" -#include "core_validation_error_enums.h" -#include "descriptor_sets.h" -#include "vulkan/vk_layer.h" -#include -#include -#include -#include -#include -#include -#include - -using core_validation::layer_data; - -bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkImage *pImage); - -void PostCallRecordCreateImage(layer_data *device_data, const VkImageCreateInfo *pCreateInfo, VkImage *pImage); - -void PreCallRecordDestroyImage(layer_data *device_data, VkImage image, IMAGE_STATE *image_state, VK_OBJECT obj_struct); - -bool PreCallValidateDestroyImage(layer_data *device_data, VkImage image, IMAGE_STATE **image_state, VK_OBJECT *obj_struct); - -bool ValidateImageAttributes(layer_data *device_data, IMAGE_STATE *image_state, VkImageSubresourceRange range); - -uint32_t ResolveRemainingLevels(const VkImageSubresourceRange *range, uint32_t mip_levels); - -uint32_t ResolveRemainingLayers(const VkImageSubresourceRange *range, uint32_t layers); - -bool VerifyClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *image_state, - VkImageSubresourceRange range, VkImageLayout dest_image_layout, const char *func_name); - -bool VerifyImageLayout(layer_data const *device_data, GLOBAL_CB_NODE const *cb_node, IMAGE_STATE *image_state, - VkImageSubresourceLayers subLayers, VkImageLayout explicit_layout, VkImageLayout optimal_layout, - const char *caller, UNIQUE_VALIDATION_ERROR_CODE msg_code, bool *error); - -void RecordClearImageLayout(layer_data *dev_data, GLOBAL_CB_NODE *cb_node, VkImage image, VkImageSubresourceRange range, - VkImageLayout dest_image_layout); - -bool PreCallValidateCmdClearColorImage(layer_data *dev_data, VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, uint32_t rangeCount, const VkImageSubresourceRange *pRanges); - -void PreCallRecordCmdClearImage(layer_data *dev_data, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, - uint32_t rangeCount, const VkImageSubresourceRange *pRanges); - -bool PreCallValidateCmdClearDepthStencilImage(layer_data *dev_data, VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, uint32_t rangeCount, - const VkImageSubresourceRange *pRanges); - -bool FindLayoutVerifyNode(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, ImageSubresourcePair imgpair, - IMAGE_CMD_BUF_LAYOUT_NODE &node, const VkImageAspectFlags aspectMask); - -bool FindLayoutVerifyLayout(layer_data const *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout, - const VkImageAspectFlags aspectMask); - -bool FindCmdBufLayout(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, VkImage image, VkImageSubresource range, - IMAGE_CMD_BUF_LAYOUT_NODE &node); - -bool FindGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout); - -bool FindLayouts(layer_data *device_data, VkImage image, std::vector &layouts); - -bool FindLayout(const std::unordered_map &imageLayoutMap, ImageSubresourcePair imgpair, - VkImageLayout &layout, const VkImageAspectFlags aspectMask); - -bool FindLayout(layer_data *device_data, const std::unordered_map &imageLayoutMap, - ImageSubresourcePair imgpair, VkImageLayout &layout); - -void SetGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, const VkImageLayout &layout); - -void SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const IMAGE_CMD_BUF_LAYOUT_NODE &node); - -void SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const VkImageLayout &layout); - -void SetLayout(std::unordered_map &imageLayoutMap, ImageSubresourcePair imgpair, - VkImageLayout layout); - -void SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, VkImageView imageView, const VkImageLayout &layout); - -bool VerifyFramebufferAndRenderPassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin, - const FRAMEBUFFER_STATE *framebuffer_state); - -void TransitionAttachmentRefLayout(layer_data *dev_data, GLOBAL_CB_NODE *pCB, FRAMEBUFFER_STATE *pFramebuffer, - VkAttachmentReference ref); - -void TransitionSubpassLayouts(layer_data *, GLOBAL_CB_NODE *, const RENDER_PASS_STATE *, const int, FRAMEBUFFER_STATE *); - -void TransitionBeginRenderPassLayouts(layer_data *, GLOBAL_CB_NODE *, const RENDER_PASS_STATE *, FRAMEBUFFER_STATE *); - -bool ValidateImageAspectLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, const VkImageMemoryBarrier *mem_barrier, - uint32_t level, uint32_t layer, VkImageAspectFlags aspect); - -void TransitionImageAspectLayout(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkImageMemoryBarrier *mem_barrier, uint32_t level, - uint32_t layer, VkImageAspectFlags aspect); - -bool ValidateBarrierLayoutToImageUsage(layer_data *device_data, const VkImageMemoryBarrier *img_barrier, bool new_not_old, - VkImageUsageFlags usage, const char *func_name); - -bool ValidateBarriersToImages(layer_data *device_data, GLOBAL_CB_NODE const *cb_state, uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier *pImageMemoryBarriers, const char *func_name); - -void TransitionImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t memBarrierCount, - const VkImageMemoryBarrier *pImgMemBarriers); - -bool VerifySourceImageLayout(layer_data *dev_data, GLOBAL_CB_NODE *cb_node, VkImage srcImage, VkImageSubresourceLayers subLayers, - VkImageLayout srcImageLayout, UNIQUE_VALIDATION_ERROR_CODE msgCode); - -bool VerifyDestImageLayout(layer_data *dev_data, GLOBAL_CB_NODE *cb_node, VkImage destImage, VkImageSubresourceLayers subLayers, - VkImageLayout destImageLayout, UNIQUE_VALIDATION_ERROR_CODE msgCode); - -void TransitionFinalSubpassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin, - FRAMEBUFFER_STATE *framebuffer_state); - -bool PreCallValidateCmdCopyImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageCopy *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout); - -bool PreCallValidateCmdClearAttachments(layer_data *device_data, VkCommandBuffer commandBuffer, uint32_t attachmentCount, - const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects); - -bool PreCallValidateCmdResolveImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t regionCount, const VkImageResolve *pRegions); - -void PreCallRecordCmdResolveImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state); - -bool PreCallValidateCmdBlitImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageBlit *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout, VkFilter filter); - -void PreCallRecordCmdBlitImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageBlit *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout); - -bool ValidateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, - std::unordered_map const &globalImageLayoutMap, - std::unordered_map &overlayLayoutMap); - -void UpdateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB); - -bool ValidateMaskBitsFromLayouts(core_validation::layer_data *device_data, VkCommandBuffer cmdBuffer, - const VkAccessFlags &accessMask, const VkImageLayout &layout, const char *type); - -bool ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, const VkImageLayout first_layout, - const uint32_t attachment, const VkAttachmentDescription &attachment_description); - -bool ValidateLayouts(core_validation::layer_data *dev_data, VkDevice device, const VkRenderPassCreateInfo *pCreateInfo); - -bool ValidateMapImageLayouts(core_validation::layer_data *dev_data, VkDevice device, DEVICE_MEM_INFO const *mem_info, - VkDeviceSize offset, VkDeviceSize end_offset); - -bool ValidateImageUsageFlags(layer_data *dev_data, IMAGE_STATE const *image_state, VkFlags desired, bool strict, - int32_t const msgCode, char const *func_name, char const *usage_string); - -bool ValidateImageFormatFeatureFlags(layer_data *dev_data, IMAGE_STATE const *image_state, VkFormatFeatureFlags desired, - char const *func_name, UNIQUE_VALIDATION_ERROR_CODE linear_vuid, - UNIQUE_VALIDATION_ERROR_CODE optimal_vuid); - -bool ValidateBufferUsageFlags(layer_data *dev_data, BUFFER_STATE const *buffer_state, VkFlags desired, bool strict, - int32_t const msgCode, char const *func_name, char const *usage_string); - -bool PreCallValidateCreateBuffer(layer_data *dev_data, const VkBufferCreateInfo *pCreateInfo); - -void PostCallRecordCreateBuffer(layer_data *device_data, const VkBufferCreateInfo *pCreateInfo, VkBuffer *pBuffer); - -bool PreCallValidateCreateBufferView(layer_data *dev_data, const VkBufferViewCreateInfo *pCreateInfo); - -void PostCallRecordCreateBufferView(layer_data *device_data, const VkBufferViewCreateInfo *pCreateInfo, VkBufferView *pView); - -bool ValidateImageAspectMask(layer_data *device_data, VkImage image, VkFormat format, VkImageAspectFlags aspect_mask, - const char *func_name); - -bool ValidateCreateImageViewSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - bool is_imageview_2d_type, const VkImageSubresourceRange &subresourceRange); - -bool ValidateCmdClearColorSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - const VkImageSubresourceRange &subresourceRange, const char *param_name); - -bool ValidateCmdClearDepthSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - const VkImageSubresourceRange &subresourceRange, const char *param_name); - -bool ValidateImageBarrierSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state, - const VkImageSubresourceRange &subresourceRange, const char *cmd_name, - const char *param_name); - -bool PreCallValidateCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info); - -void PostCallRecordCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info, VkImageView view); - -bool ValidateCopyBufferImageTransferGranularityRequirements(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, - const IMAGE_STATE *img, const VkBufferImageCopy *region, - const uint32_t i, const char *function, - UNIQUE_VALIDATION_ERROR_CODE vuid); - -void PreCallRecordCmdCopyImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageCopy *regions, - VkImageLayout src_image_layout, VkImageLayout dst_image_layout); - -bool PreCallValidateCmdCopyBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state, - BUFFER_STATE *dst_buffer_state); - -void PreCallRecordCmdCopyBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state, - BUFFER_STATE *dst_buffer_state); - -bool PreCallValidateDestroyImageView(layer_data *device_data, VkImageView image_view, IMAGE_VIEW_STATE **image_view_state, - VK_OBJECT *obj_struct); - -void PreCallRecordDestroyImageView(layer_data *device_data, VkImageView image_view, IMAGE_VIEW_STATE *image_view_state, - VK_OBJECT obj_struct); - -bool PreCallValidateDestroyBuffer(layer_data *device_data, VkBuffer buffer, BUFFER_STATE **buffer_state, VK_OBJECT *obj_struct); - -void PreCallRecordDestroyBuffer(layer_data *device_data, VkBuffer buffer, BUFFER_STATE *buffer_state, VK_OBJECT obj_struct); - -bool PreCallValidateDestroyBufferView(layer_data *device_data, VkBufferView buffer_view, BUFFER_VIEW_STATE **buffer_view_state, - VK_OBJECT *obj_struct); - -void PreCallRecordDestroyBufferView(layer_data *device_data, VkBufferView buffer_view, BUFFER_VIEW_STATE *buffer_view_state, - VK_OBJECT obj_struct); - -bool PreCallValidateCmdFillBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *buffer_state); - -void PreCallRecordCmdFillBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *buffer_state); - -bool PreCallValidateCmdCopyImageToBuffer(layer_data *device_data, VkImageLayout srcImageLayout, GLOBAL_CB_NODE *cb_node, - IMAGE_STATE *src_image_state, BUFFER_STATE *dst_buff_state, uint32_t regionCount, - const VkBufferImageCopy *pRegions, const char *func_name); - -void PreCallRecordCmdCopyImageToBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state, - BUFFER_STATE *dst_buff_state, uint32_t region_count, const VkBufferImageCopy *regions, - VkImageLayout src_image_layout); - -bool PreCallValidateCmdCopyBufferToImage(layer_data *dev_data, VkImageLayout dstImageLayout, GLOBAL_CB_NODE *cb_node, - BUFFER_STATE *src_buff_state, IMAGE_STATE *dst_image_state, uint32_t regionCount, - const VkBufferImageCopy *pRegions, const char *func_name); - -void PreCallRecordCmdCopyBufferToImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buff_state, - IMAGE_STATE *dst_image_state, uint32_t region_count, const VkBufferImageCopy *regions, - VkImageLayout dst_image_layout); - -bool PreCallValidateGetImageSubresourceLayout(layer_data *device_data, VkImage image, const VkImageSubresource *pSubresource); - -#endif // CORE_VALIDATION_BUFFER_VALIDATION_H_ diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp deleted file mode 100644 index 8f6ee29d..00000000 --- a/layers/core_validation.cpp +++ /dev/null @@ -1,12868 +0,0 @@ -/* 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: Cody Northrop - * Author: Michael Lentine - * Author: Tobin Ehlis - * Author: Chia-I Wu - * Author: Chris Forbes - * Author: Mark Lobodzinski - * Author: Ian Elliott - * Author: Dave Houlton - * Author: Dustin Graves - * Author: Jeremy Hayes - * Author: Jon Ashburn - * Author: Karl Schultz - * Author: Mark Young - * Author: Mike Schuchardt - * Author: Mike Weiblen - * Author: Tony Barbour - */ - -// Allow use of STL min and max functions in Windows -#define NOMINMAX - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "vk_loader_platform.h" -#include "vk_dispatch_table_helper.h" -#include "vk_enum_string_helper.h" -#if defined(__GNUC__) -#pragma GCC diagnostic ignored "-Wwrite-strings" -#endif -#if defined(__GNUC__) -#pragma GCC diagnostic warning "-Wwrite-strings" -#endif -#include "core_validation.h" -#include "buffer_validation.h" -#include "shader_validation.h" -#include "vk_layer_table.h" -#include "vk_layer_data.h" -#include "vk_layer_extension_utils.h" -#include "vk_layer_utils.h" -#include "vk_typemap_helper.h" - -#if defined __ANDROID__ -#include -#define LOGCONSOLE(...) ((void)__android_log_print(ANDROID_LOG_INFO, "CORE_VALIDATION", __VA_ARGS__)) -#else -#define LOGCONSOLE(...) \ - { \ - printf(__VA_ARGS__); \ - printf("\n"); \ - } -#endif - -// This intentionally includes a cpp file -#include "vk_safe_struct.cpp" - -using mutex_t = std::mutex; -using lock_guard_t = std::lock_guard; -using unique_lock_t = std::unique_lock; - -// These functions are defined *outside* the core_validation namespace as their type -// is also defined outside that namespace -size_t PipelineLayoutCompatDef::hash() const { - hash_util::HashCombiner hc; - // The set number is integral to the CompatDef's distinctiveness - hc << set << push_constant_ranges.get(); - const auto &descriptor_set_layouts = *set_layouts_id.get(); - for (uint32_t i = 0; i <= set; i++) { - hc << descriptor_set_layouts[i].get(); - } - return hc.Value(); -} - -bool PipelineLayoutCompatDef::operator==(const PipelineLayoutCompatDef &other) const { - if ((set != other.set) || (push_constant_ranges != other.push_constant_ranges)) { - return false; - } - - if (set_layouts_id == other.set_layouts_id) { - // if it's the same set_layouts_id, then *any* subset will match - return true; - } - - // They aren't exactly the same PipelineLayoutSetLayouts, so we need to check if the required subsets match - const auto &descriptor_set_layouts = *set_layouts_id.get(); - assert(set < descriptor_set_layouts.size()); - const auto &other_ds_layouts = *other.set_layouts_id.get(); - assert(set < other_ds_layouts.size()); - for (uint32_t i = 0; i <= set; i++) { - if (descriptor_set_layouts[i] != other_ds_layouts[i]) { - return false; - } - } - return true; -} - -namespace core_validation { - -using std::max; -using std::string; -using std::stringstream; -using std::unique_ptr; -using std::unordered_map; -using std::unordered_set; -using std::vector; - -// WSI Image Objects bypass usual Image Object creation methods. A special Memory -// Object value will be used to identify them internally. -static const VkDeviceMemory MEMTRACKER_SWAP_CHAIN_IMAGE_KEY = (VkDeviceMemory)(-1); -// 2nd special memory handle used to flag object as unbound from memory -static const VkDeviceMemory MEMORY_UNBOUND = VkDeviceMemory(~((uint64_t)(0)) - 1); - -struct instance_layer_data { - VkInstance instance = VK_NULL_HANDLE; - debug_report_data *report_data = nullptr; - vector logging_callback; - vector logging_messenger; - VkLayerInstanceDispatchTable dispatch_table; - - CALL_STATE vkEnumeratePhysicalDevicesState = UNCALLED; - uint32_t physical_devices_count = 0; - CALL_STATE vkEnumeratePhysicalDeviceGroupsState = UNCALLED; - uint32_t physical_device_groups_count = 0; - CHECK_DISABLED disabled = {}; - - unordered_map physical_device_map; - unordered_map surface_map; - - InstanceExtensions extensions; - uint32_t api_version; -}; - -struct layer_data { - debug_report_data *report_data = nullptr; - VkLayerDispatchTable dispatch_table; - - DeviceExtensions extensions = {}; - unordered_set queues; // All queues under given device - // Layer specific data - unordered_map> samplerMap; - unordered_map> imageViewMap; - unordered_map> imageMap; - unordered_map> bufferViewMap; - unordered_map> bufferMap; - unordered_map> pipelineMap; - unordered_map commandPoolMap; - unordered_map descriptorPoolMap; - unordered_map setMap; - unordered_map> descriptorSetLayoutMap; - unordered_map pipelineLayoutMap; - unordered_map> memObjMap; - unordered_map fenceMap; - unordered_map queueMap; - unordered_map eventMap; - unordered_map queryToStateMap; - unordered_map queryPoolMap; - unordered_map semaphoreMap; - unordered_map commandBufferMap; - unordered_map> frameBufferMap; - unordered_map> imageSubresourceMap; - unordered_map imageLayoutMap; - unordered_map> renderPassMap; - unordered_map> shaderModuleMap; - unordered_map> desc_template_map; - unordered_map> swapchainMap; - - VkDevice device = VK_NULL_HANDLE; - VkPhysicalDevice physical_device = VK_NULL_HANDLE; - - instance_layer_data *instance_data = nullptr; // from device to enclosing instance - - safe_VkPhysicalDeviceFeatures2 enabled_features2 = {}; - // Device specific data - PHYS_DEV_PROPERTIES_NODE phys_dev_properties = {}; - VkPhysicalDeviceMemoryProperties phys_dev_mem_props = {}; - VkPhysicalDeviceProperties phys_dev_props = {}; - // Device extension properties -- storing properties gathered from VkPhysicalDeviceProperties2KHR::pNext chain - struct DeviceExtensionProperties { - uint32_t max_push_descriptors; // from VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors - VkPhysicalDeviceDescriptorIndexingPropertiesEXT descriptor_indexing_props; - VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing_features; - }; - DeviceExtensionProperties phys_dev_ext_props = {}; - bool external_sync_warning = false; - uint32_t api_version = 0; -}; - -// TODO : Do we need to guard access to layer_data_map w/ lock? -static unordered_map layer_data_map; -static unordered_map instance_layer_data_map; - -static uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - -static const VkLayerProperties global_layer = { - "VK_LAYER_LUNARG_core_validation", - VK_LAYER_API_VERSION, - 1, - "LunarG Validation Layer", -}; - -static const VkExtensionProperties device_extensions[] = { - {VK_EXT_VALIDATION_CACHE_EXTENSION_NAME, VK_EXT_VALIDATION_CACHE_SPEC_VERSION}, -}; - -template -void ValidateLayerOrdering(const TCreateInfo &createInfo) { - bool foundLayer = false; - for (uint32_t i = 0; i < createInfo.enabledLayerCount; ++i) { - if (!strcmp(createInfo.ppEnabledLayerNames[i], global_layer.layerName)) { - foundLayer = true; - } - // This has to be logged to console as we don't have a callback at this point. - if (!foundLayer && !strcmp(createInfo.ppEnabledLayerNames[0], "VK_LAYER_GOOGLE_unique_objects")) { - LOGCONSOLE("Cannot activate layer VK_LAYER_GOOGLE_unique_objects prior to activating %s.", global_layer.layerName); - } - } -} - -// TODO : This can be much smarter, using separate locks for separate global data -static mutex_t global_lock; - -// Return IMAGE_VIEW_STATE ptr for specified imageView or else NULL -IMAGE_VIEW_STATE *GetImageViewState(const layer_data *dev_data, VkImageView image_view) { - auto iv_it = dev_data->imageViewMap.find(image_view); - if (iv_it == dev_data->imageViewMap.end()) { - return nullptr; - } - return iv_it->second.get(); -} -// Return sampler node ptr for specified sampler or else NULL -SAMPLER_STATE *GetSamplerState(const layer_data *dev_data, VkSampler sampler) { - auto sampler_it = dev_data->samplerMap.find(sampler); - if (sampler_it == dev_data->samplerMap.end()) { - return nullptr; - } - return sampler_it->second.get(); -} -// Return image state ptr for specified image or else NULL -IMAGE_STATE *GetImageState(const layer_data *dev_data, VkImage image) { - auto img_it = dev_data->imageMap.find(image); - if (img_it == dev_data->imageMap.end()) { - return nullptr; - } - return img_it->second.get(); -} -// Return buffer state ptr for specified buffer or else NULL -BUFFER_STATE *GetBufferState(const layer_data *dev_data, VkBuffer buffer) { - auto buff_it = dev_data->bufferMap.find(buffer); - if (buff_it == dev_data->bufferMap.end()) { - return nullptr; - } - return buff_it->second.get(); -} -// Return swapchain node for specified swapchain or else NULL -SWAPCHAIN_NODE *GetSwapchainNode(const layer_data *dev_data, VkSwapchainKHR swapchain) { - auto swp_it = dev_data->swapchainMap.find(swapchain); - if (swp_it == dev_data->swapchainMap.end()) { - return nullptr; - } - return swp_it->second.get(); -} -// Return buffer node ptr for specified buffer or else NULL -BUFFER_VIEW_STATE *GetBufferViewState(const layer_data *dev_data, VkBufferView buffer_view) { - auto bv_it = dev_data->bufferViewMap.find(buffer_view); - if (bv_it == dev_data->bufferViewMap.end()) { - return nullptr; - } - return bv_it->second.get(); -} - -FENCE_NODE *GetFenceNode(layer_data *dev_data, VkFence fence) { - auto it = dev_data->fenceMap.find(fence); - if (it == dev_data->fenceMap.end()) { - return nullptr; - } - return &it->second; -} - -EVENT_STATE *GetEventNode(layer_data *dev_data, VkEvent event) { - auto it = dev_data->eventMap.find(event); - if (it == dev_data->eventMap.end()) { - return nullptr; - } - return &it->second; -} - -QUERY_POOL_NODE *GetQueryPoolNode(layer_data *dev_data, VkQueryPool query_pool) { - auto it = dev_data->queryPoolMap.find(query_pool); - if (it == dev_data->queryPoolMap.end()) { - return nullptr; - } - return &it->second; -} - -QUEUE_STATE *GetQueueState(layer_data *dev_data, VkQueue queue) { - auto it = dev_data->queueMap.find(queue); - if (it == dev_data->queueMap.end()) { - return nullptr; - } - return &it->second; -} - -SEMAPHORE_NODE *GetSemaphoreNode(layer_data *dev_data, VkSemaphore semaphore) { - auto it = dev_data->semaphoreMap.find(semaphore); - if (it == dev_data->semaphoreMap.end()) { - return nullptr; - } - return &it->second; -} - -COMMAND_POOL_NODE *GetCommandPoolNode(layer_data *dev_data, VkCommandPool pool) { - auto it = dev_data->commandPoolMap.find(pool); - if (it == dev_data->commandPoolMap.end()) { - return nullptr; - } - return &it->second; -} - -PHYSICAL_DEVICE_STATE *GetPhysicalDeviceState(instance_layer_data *instance_data, VkPhysicalDevice phys) { - auto it = instance_data->physical_device_map.find(phys); - if (it == instance_data->physical_device_map.end()) { - return nullptr; - } - return &it->second; -} - -SURFACE_STATE *GetSurfaceState(instance_layer_data *instance_data, VkSurfaceKHR surface) { - auto it = instance_data->surface_map.find(surface); - if (it == instance_data->surface_map.end()) { - return nullptr; - } - return &it->second; -} - -// Return ptr to memory binding for given handle of specified type -static BINDABLE *GetObjectMemBinding(layer_data *dev_data, uint64_t handle, VulkanObjectType type) { - switch (type) { - case kVulkanObjectTypeImage: - return GetImageState(dev_data, VkImage(handle)); - case kVulkanObjectTypeBuffer: - return GetBufferState(dev_data, VkBuffer(handle)); - default: - break; - } - return nullptr; -} -// prototype -GLOBAL_CB_NODE *GetCBNode(layer_data const *, const VkCommandBuffer); - -// Return ptr to info in map container containing mem, or NULL if not found -// Calls to this function should be wrapped in mutex -DEVICE_MEM_INFO *GetMemObjInfo(const layer_data *dev_data, const VkDeviceMemory mem) { - auto mem_it = dev_data->memObjMap.find(mem); - if (mem_it == dev_data->memObjMap.end()) { - return NULL; - } - return mem_it->second.get(); -} - -static void add_mem_obj_info(layer_data *dev_data, void *object, const VkDeviceMemory mem, - const VkMemoryAllocateInfo *pAllocateInfo) { - assert(object != NULL); - - auto *mem_info = new DEVICE_MEM_INFO(object, mem, pAllocateInfo); - dev_data->memObjMap[mem] = unique_ptr(mem_info); - - auto dedicated = lvl_find_in_chain(pAllocateInfo->pNext); - if (dedicated) { - mem_info->is_dedicated = true; - mem_info->dedicated_buffer = dedicated->buffer; - mem_info->dedicated_image = dedicated->image; - } -} - -// Create binding link between given sampler and command buffer node -void AddCommandBufferBindingSampler(GLOBAL_CB_NODE *cb_node, SAMPLER_STATE *sampler_state) { - sampler_state->cb_bindings.insert(cb_node); - cb_node->object_bindings.insert({HandleToUint64(sampler_state->sampler), kVulkanObjectTypeSampler}); -} - -// Create binding link between given image node and command buffer node -void AddCommandBufferBindingImage(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *image_state) { - // Skip validation if this image was created through WSI - if (image_state->binding.mem != MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) { - // First update CB binding in MemObj mini CB list - for (auto mem_binding : image_state->GetBoundMemory()) { - DEVICE_MEM_INFO *pMemInfo = GetMemObjInfo(dev_data, mem_binding); - if (pMemInfo) { - pMemInfo->cb_bindings.insert(cb_node); - // Now update CBInfo's Mem reference list - cb_node->memObjs.insert(mem_binding); - } - } - // Now update cb binding for image - cb_node->object_bindings.insert({HandleToUint64(image_state->image), kVulkanObjectTypeImage}); - image_state->cb_bindings.insert(cb_node); - } -} - -// Create binding link between given image view node and its image with command buffer node -void AddCommandBufferBindingImageView(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, IMAGE_VIEW_STATE *view_state) { - // First add bindings for imageView - view_state->cb_bindings.insert(cb_node); - cb_node->object_bindings.insert({HandleToUint64(view_state->image_view), kVulkanObjectTypeImageView}); - auto image_state = GetImageState(dev_data, view_state->create_info.image); - // Add bindings for image within imageView - if (image_state) { - AddCommandBufferBindingImage(dev_data, cb_node, image_state); - } -} - -// Create binding link between given buffer node and command buffer node -void AddCommandBufferBindingBuffer(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *buffer_state) { - // First update CB binding in MemObj mini CB list - for (auto mem_binding : buffer_state->GetBoundMemory()) { - DEVICE_MEM_INFO *pMemInfo = GetMemObjInfo(dev_data, mem_binding); - if (pMemInfo) { - pMemInfo->cb_bindings.insert(cb_node); - // Now update CBInfo's Mem reference list - cb_node->memObjs.insert(mem_binding); - } - } - // Now update cb binding for buffer - cb_node->object_bindings.insert({HandleToUint64(buffer_state->buffer), kVulkanObjectTypeBuffer}); - buffer_state->cb_bindings.insert(cb_node); -} - -// Create binding link between given buffer view node and its buffer with command buffer node -void AddCommandBufferBindingBufferView(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, BUFFER_VIEW_STATE *view_state) { - // First add bindings for bufferView - view_state->cb_bindings.insert(cb_node); - cb_node->object_bindings.insert({HandleToUint64(view_state->buffer_view), kVulkanObjectTypeBufferView}); - auto buffer_state = GetBufferState(dev_data, view_state->create_info.buffer); - // Add bindings for buffer within bufferView - if (buffer_state) { - AddCommandBufferBindingBuffer(dev_data, cb_node, buffer_state); - } -} - -// For every mem obj bound to particular CB, free bindings related to that CB -static void clear_cmd_buf_and_mem_references(layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - if (cb_node) { - if (cb_node->memObjs.size() > 0) { - for (auto mem : cb_node->memObjs) { - DEVICE_MEM_INFO *pInfo = GetMemObjInfo(dev_data, mem); - if (pInfo) { - pInfo->cb_bindings.erase(cb_node); - } - } - cb_node->memObjs.clear(); - } - } -} - -// Clear a single object binding from given memory object, or report error if binding is missing -static bool ClearMemoryObjectBinding(layer_data *dev_data, uint64_t handle, VulkanObjectType type, VkDeviceMemory mem) { - DEVICE_MEM_INFO *mem_info = GetMemObjInfo(dev_data, mem); - // This obj is bound to a memory object. Remove the reference to this object in that memory object's list - if (mem_info) { - mem_info->obj_bindings.erase({handle, type}); - } - return false; -} - -// ClearMemoryObjectBindings clears the binding of objects to memory -// For the given object it pulls the memory bindings and makes sure that the bindings -// no longer refer to the object being cleared. This occurs when objects are destroyed. -bool ClearMemoryObjectBindings(layer_data *dev_data, uint64_t handle, VulkanObjectType type) { - bool skip = false; - BINDABLE *mem_binding = GetObjectMemBinding(dev_data, handle, type); - if (mem_binding) { - if (!mem_binding->sparse) { - skip = ClearMemoryObjectBinding(dev_data, handle, type, mem_binding->binding.mem); - } else { // Sparse, clear all bindings - for (auto &sparse_mem_binding : mem_binding->sparse_bindings) { - skip |= ClearMemoryObjectBinding(dev_data, handle, type, sparse_mem_binding.mem); - } - } - } - return skip; -} - -// For given mem object, verify that it is not null or UNBOUND, if it is, report error. Return skip value. -bool VerifyBoundMemoryIsValid(const layer_data *dev_data, VkDeviceMemory mem, uint64_t handle, const char *api_name, - const char *type_name, UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool result = false; - if (VK_NULL_HANDLE == mem) { - result = - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, handle, error_code, - "%s: Vk%s object 0x%" PRIx64 " used with no memory bound. Memory should be bound by calling vkBind%sMemory().", - api_name, type_name, handle, type_name); - } else if (MEMORY_UNBOUND == mem) { - result = - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, handle, error_code, - "%s: Vk%s object 0x%" PRIx64 - " used with no memory bound and previously bound memory was freed. Memory must not be freed prior to this " - "operation.", - api_name, type_name, handle); - } - return result; -} - -// Check to see if memory was ever bound to this image -bool ValidateMemoryIsBoundToImage(const layer_data *dev_data, const IMAGE_STATE *image_state, const char *api_name, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool result = false; - if (0 == (static_cast(image_state->createInfo.flags) & VK_IMAGE_CREATE_SPARSE_BINDING_BIT)) { - result = VerifyBoundMemoryIsValid(dev_data, image_state->binding.mem, HandleToUint64(image_state->image), api_name, "Image", - error_code); - } - return result; -} - -// Check to see if memory was bound to this buffer -bool ValidateMemoryIsBoundToBuffer(const layer_data *dev_data, const BUFFER_STATE *buffer_state, const char *api_name, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool result = false; - if (0 == (static_cast(buffer_state->createInfo.flags) & VK_BUFFER_CREATE_SPARSE_BINDING_BIT)) { - result = VerifyBoundMemoryIsValid(dev_data, buffer_state->binding.mem, HandleToUint64(buffer_state->buffer), api_name, - "Buffer", error_code); - } - return result; -} - -// SetMemBinding is used to establish immutable, non-sparse binding between a single image/buffer object and memory object. -// Corresponding valid usage checks are in ValidateSetMemBinding(). -static void SetMemBinding(layer_data *dev_data, VkDeviceMemory mem, BINDABLE *mem_binding, VkDeviceSize memory_offset, - uint64_t handle, VulkanObjectType type, const char *apiName) { - assert(mem_binding); - mem_binding->binding.mem = mem; - mem_binding->UpdateBoundMemorySet(); // force recreation of cached set - mem_binding->binding.offset = memory_offset; - mem_binding->binding.size = mem_binding->requirements.size; - - if (mem != VK_NULL_HANDLE) { - DEVICE_MEM_INFO *mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - mem_info->obj_bindings.insert({handle, type}); - // For image objects, make sure default memory state is correctly set - // TODO : What's the best/correct way to handle this? - if (kVulkanObjectTypeImage == type) { - auto const image_state = reinterpret_cast(mem_binding); - if (image_state) { - VkImageCreateInfo ici = image_state->createInfo; - if (ici.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) { - // TODO:: More memory state transition stuff. - } - } - } - } - } -} - -// Valid usage checks for a call to SetMemBinding(). -// For NULL mem case, output warning -// Make sure given object is in global object map -// IF a previous binding existed, output validation error -// Otherwise, add reference from objectInfo to memoryInfo -// Add reference off of objInfo -// TODO: We may need to refactor or pass in multiple valid usage statements to handle multiple valid usage conditions. -static bool ValidateSetMemBinding(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle, VulkanObjectType type, - const char *apiName) { - bool skip = false; - // It's an error to bind an object to NULL memory - if (mem != VK_NULL_HANDLE) { - BINDABLE *mem_binding = GetObjectMemBinding(dev_data, handle, type); - assert(mem_binding); - if (mem_binding->sparse) { - UNIQUE_VALIDATION_ERROR_CODE error_code = VALIDATION_ERROR_1740082a; - const char *handle_type = "IMAGE"; - if (type == kVulkanObjectTypeBuffer) { - error_code = VALIDATION_ERROR_1700080c; - handle_type = "BUFFER"; - } else { - assert(type == kVulkanObjectTypeImage); - } - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), error_code, - "In %s, attempting to bind memory (0x%" PRIx64 ") to object (0x%" PRIx64 - ") which was created with sparse memory flags (VK_%s_CREATE_SPARSE_*_BIT).", - apiName, HandleToUint64(mem), handle, handle_type); - } - DEVICE_MEM_INFO *mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - DEVICE_MEM_INFO *prev_binding = GetMemObjInfo(dev_data, mem_binding->binding.mem); - if (prev_binding) { - UNIQUE_VALIDATION_ERROR_CODE error_code = VALIDATION_ERROR_17400828; - if (type == kVulkanObjectTypeBuffer) { - error_code = VALIDATION_ERROR_1700080a; - } else { - assert(type == kVulkanObjectTypeImage); - } - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), error_code, - "In %s, attempting to bind memory (0x%" PRIx64 ") to object (0x%" PRIx64 - ") which has already been bound to mem object 0x%" PRIx64 ".", - apiName, HandleToUint64(mem), handle, HandleToUint64(prev_binding->mem)); - } else if (mem_binding->binding.mem == MEMORY_UNBOUND) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), MEMTRACK_REBIND_OBJECT, - "In %s, attempting to bind memory (0x%" PRIx64 ") to object (0x%" PRIx64 - ") which was previous bound to memory that has since been freed. Memory bindings are immutable in " - "Vulkan so this attempt to bind to new memory is not allowed.", - apiName, HandleToUint64(mem), handle); - } - } - } - return skip; -} - -// For NULL mem case, clear any previous binding Else... -// Make sure given object is in its object map -// IF a previous binding existed, update binding -// Add reference from objectInfo to memoryInfo -// Add reference off of object's binding info -// Return VK_TRUE if addition is successful, VK_FALSE otherwise -static bool SetSparseMemBinding(layer_data *dev_data, MEM_BINDING binding, uint64_t handle, VulkanObjectType type) { - bool skip = VK_FALSE; - // Handle NULL case separately, just clear previous binding & decrement reference - if (binding.mem == VK_NULL_HANDLE) { - // TODO : This should cause the range of the resource to be unbound according to spec - } else { - BINDABLE *mem_binding = GetObjectMemBinding(dev_data, handle, type); - assert(mem_binding); - assert(mem_binding->sparse); - DEVICE_MEM_INFO *mem_info = GetMemObjInfo(dev_data, binding.mem); - if (mem_info) { - mem_info->obj_bindings.insert({handle, type}); - // Need to set mem binding for this object - mem_binding->sparse_bindings.insert(binding); - mem_binding->UpdateBoundMemorySet(); - } - } - return skip; -} - -// Check object status for selected flag state -static bool validate_status(layer_data *dev_data, GLOBAL_CB_NODE *pNode, CBStatusFlags status_mask, VkFlags msg_flags, - const char *fail_msg, UNIQUE_VALIDATION_ERROR_CODE const msg_code) { - if (!(pNode->status & status_mask)) { - return log_msg(dev_data->report_data, msg_flags, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pNode->commandBuffer), msg_code, "command buffer object 0x%" PRIx64 ": %s..", - HandleToUint64(pNode->commandBuffer), fail_msg); - } - return false; -} - -// Retrieve pipeline node ptr for given pipeline object -static PIPELINE_STATE *getPipelineState(layer_data const *dev_data, VkPipeline pipeline) { - auto it = dev_data->pipelineMap.find(pipeline); - if (it == dev_data->pipelineMap.end()) { - return nullptr; - } - return it->second.get(); -} - -RENDER_PASS_STATE *GetRenderPassState(layer_data const *dev_data, VkRenderPass renderpass) { - auto it = dev_data->renderPassMap.find(renderpass); - if (it == dev_data->renderPassMap.end()) { - return nullptr; - } - return it->second.get(); -} - -std::shared_ptr GetRenderPassStateSharedPtr(layer_data const *dev_data, VkRenderPass renderpass) { - auto it = dev_data->renderPassMap.find(renderpass); - if (it == dev_data->renderPassMap.end()) { - return nullptr; - } - return it->second; -} - -FRAMEBUFFER_STATE *GetFramebufferState(const layer_data *dev_data, VkFramebuffer framebuffer) { - auto it = dev_data->frameBufferMap.find(framebuffer); - if (it == dev_data->frameBufferMap.end()) { - return nullptr; - } - return it->second.get(); -} - -std::shared_ptr const GetDescriptorSetLayout(layer_data const *dev_data, - VkDescriptorSetLayout dsLayout) { - auto it = dev_data->descriptorSetLayoutMap.find(dsLayout); - if (it == dev_data->descriptorSetLayoutMap.end()) { - return nullptr; - } - return it->second; -} - -static PIPELINE_LAYOUT_NODE const *getPipelineLayout(layer_data const *dev_data, VkPipelineLayout pipeLayout) { - auto it = dev_data->pipelineLayoutMap.find(pipeLayout); - if (it == dev_data->pipelineLayoutMap.end()) { - return nullptr; - } - return &it->second; -} - -shader_module const *GetShaderModuleState(layer_data const *dev_data, VkShaderModule module) { - auto it = dev_data->shaderModuleMap.find(module); - if (it == dev_data->shaderModuleMap.end()) { - return nullptr; - } - return it->second.get(); -} - -// Return true if for a given PSO, the given state enum is dynamic, else return false -static bool isDynamic(const PIPELINE_STATE *pPipeline, const VkDynamicState state) { - if (pPipeline && pPipeline->graphicsPipelineCI.pDynamicState) { - for (uint32_t i = 0; i < pPipeline->graphicsPipelineCI.pDynamicState->dynamicStateCount; i++) { - if (state == pPipeline->graphicsPipelineCI.pDynamicState->pDynamicStates[i]) return true; - } - } - return false; -} - -// Validate state stored as flags at time of draw call -static bool validate_draw_state_flags(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const PIPELINE_STATE *pPipe, bool indexed, - UNIQUE_VALIDATION_ERROR_CODE const msg_code) { - bool result = false; - if (pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_LIST || - pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP) { - result |= validate_status(dev_data, pCB, CBSTATUS_LINE_WIDTH_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Dynamic line width state not set for this command buffer", msg_code); - } - if (pPipe->graphicsPipelineCI.pRasterizationState && - (pPipe->graphicsPipelineCI.pRasterizationState->depthBiasEnable == VK_TRUE)) { - result |= validate_status(dev_data, pCB, CBSTATUS_DEPTH_BIAS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Dynamic depth bias state not set for this command buffer", msg_code); - } - if (pPipe->blendConstantsEnabled) { - result |= validate_status(dev_data, pCB, CBSTATUS_BLEND_CONSTANTS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Dynamic blend constants state not set for this command buffer", msg_code); - } - if (pPipe->graphicsPipelineCI.pDepthStencilState && - (pPipe->graphicsPipelineCI.pDepthStencilState->depthBoundsTestEnable == VK_TRUE)) { - result |= validate_status(dev_data, pCB, CBSTATUS_DEPTH_BOUNDS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Dynamic depth bounds state not set for this command buffer", msg_code); - } - if (pPipe->graphicsPipelineCI.pDepthStencilState && - (pPipe->graphicsPipelineCI.pDepthStencilState->stencilTestEnable == VK_TRUE)) { - result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_READ_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Dynamic stencil read mask state not set for this command buffer", msg_code); - result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_WRITE_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Dynamic stencil write mask state not set for this command buffer", msg_code); - result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_REFERENCE_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Dynamic stencil reference state not set for this command buffer", msg_code); - } - if (indexed) { - result |= validate_status(dev_data, pCB, CBSTATUS_INDEX_BUFFER_BOUND, VK_DEBUG_REPORT_ERROR_BIT_EXT, - "Index buffer object not bound to this command buffer when Indexed Draw attempted", msg_code); - } - - return result; -} - -static bool logInvalidAttachmentMessage(layer_data const *dev_data, const char *type1_string, const RENDER_PASS_STATE *rp1_state, - const char *type2_string, const RENDER_PASS_STATE *rp2_state, uint32_t primary_attach, - uint32_t secondary_attach, const char *msg, const char *caller, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - HandleToUint64(rp1_state->renderPass), error_code, - "%s: RenderPasses incompatible between %s w/ renderPass 0x%" PRIx64 " and %s w/ renderPass 0x%" PRIx64 - " Attachment %u is not compatible with %u: %s.", - caller, type1_string, HandleToUint64(rp1_state->renderPass), type2_string, HandleToUint64(rp2_state->renderPass), - primary_attach, secondary_attach, msg); -} - -static bool validateAttachmentCompatibility(layer_data const *dev_data, const char *type1_string, - const RENDER_PASS_STATE *rp1_state, const char *type2_string, - const RENDER_PASS_STATE *rp2_state, uint32_t primary_attach, uint32_t secondary_attach, - const char *caller, UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - const auto &primaryPassCI = rp1_state->createInfo; - const auto &secondaryPassCI = rp2_state->createInfo; - if (primaryPassCI.attachmentCount <= primary_attach) { - primary_attach = VK_ATTACHMENT_UNUSED; - } - if (secondaryPassCI.attachmentCount <= secondary_attach) { - secondary_attach = VK_ATTACHMENT_UNUSED; - } - if (primary_attach == VK_ATTACHMENT_UNUSED && secondary_attach == VK_ATTACHMENT_UNUSED) { - return skip; - } - if (primary_attach == VK_ATTACHMENT_UNUSED) { - skip |= logInvalidAttachmentMessage(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_attach, - secondary_attach, "The first is unused while the second is not.", caller, error_code); - return skip; - } - if (secondary_attach == VK_ATTACHMENT_UNUSED) { - skip |= logInvalidAttachmentMessage(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_attach, - secondary_attach, "The second is unused while the first is not.", caller, error_code); - return skip; - } - if (primaryPassCI.pAttachments[primary_attach].format != secondaryPassCI.pAttachments[secondary_attach].format) { - skip |= logInvalidAttachmentMessage(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_attach, - secondary_attach, "They have different formats.", caller, error_code); - } - if (primaryPassCI.pAttachments[primary_attach].samples != secondaryPassCI.pAttachments[secondary_attach].samples) { - skip |= logInvalidAttachmentMessage(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_attach, - secondary_attach, "They have different samples.", caller, error_code); - } - if (primaryPassCI.pAttachments[primary_attach].flags != secondaryPassCI.pAttachments[secondary_attach].flags) { - skip |= logInvalidAttachmentMessage(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_attach, - secondary_attach, "They have different flags.", caller, error_code); - } - - return skip; -} - -static bool validateSubpassCompatibility(layer_data const *dev_data, const char *type1_string, const RENDER_PASS_STATE *rp1_state, - const char *type2_string, const RENDER_PASS_STATE *rp2_state, const int subpass, - const char *caller, UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - const auto &primary_desc = rp1_state->createInfo.pSubpasses[subpass]; - const auto &secondary_desc = rp2_state->createInfo.pSubpasses[subpass]; - uint32_t maxInputAttachmentCount = std::max(primary_desc.inputAttachmentCount, secondary_desc.inputAttachmentCount); - for (uint32_t i = 0; i < maxInputAttachmentCount; ++i) { - uint32_t primary_input_attach = VK_ATTACHMENT_UNUSED, secondary_input_attach = VK_ATTACHMENT_UNUSED; - if (i < primary_desc.inputAttachmentCount) { - primary_input_attach = primary_desc.pInputAttachments[i].attachment; - } - if (i < secondary_desc.inputAttachmentCount) { - secondary_input_attach = secondary_desc.pInputAttachments[i].attachment; - } - skip |= validateAttachmentCompatibility(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_input_attach, - secondary_input_attach, caller, error_code); - } - uint32_t maxColorAttachmentCount = std::max(primary_desc.colorAttachmentCount, secondary_desc.colorAttachmentCount); - for (uint32_t i = 0; i < maxColorAttachmentCount; ++i) { - uint32_t primary_color_attach = VK_ATTACHMENT_UNUSED, secondary_color_attach = VK_ATTACHMENT_UNUSED; - if (i < primary_desc.colorAttachmentCount) { - primary_color_attach = primary_desc.pColorAttachments[i].attachment; - } - if (i < secondary_desc.colorAttachmentCount) { - secondary_color_attach = secondary_desc.pColorAttachments[i].attachment; - } - skip |= validateAttachmentCompatibility(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_color_attach, - secondary_color_attach, caller, error_code); - uint32_t primary_resolve_attach = VK_ATTACHMENT_UNUSED, secondary_resolve_attach = VK_ATTACHMENT_UNUSED; - if (i < primary_desc.colorAttachmentCount && primary_desc.pResolveAttachments) { - primary_resolve_attach = primary_desc.pResolveAttachments[i].attachment; - } - if (i < secondary_desc.colorAttachmentCount && secondary_desc.pResolveAttachments) { - secondary_resolve_attach = secondary_desc.pResolveAttachments[i].attachment; - } - skip |= validateAttachmentCompatibility(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_resolve_attach, - secondary_resolve_attach, caller, error_code); - } - uint32_t primary_depthstencil_attach = VK_ATTACHMENT_UNUSED, secondary_depthstencil_attach = VK_ATTACHMENT_UNUSED; - if (primary_desc.pDepthStencilAttachment) { - primary_depthstencil_attach = primary_desc.pDepthStencilAttachment[0].attachment; - } - if (secondary_desc.pDepthStencilAttachment) { - secondary_depthstencil_attach = secondary_desc.pDepthStencilAttachment[0].attachment; - } - skip |= validateAttachmentCompatibility(dev_data, type1_string, rp1_state, type2_string, rp2_state, primary_depthstencil_attach, - secondary_depthstencil_attach, caller, error_code); - return skip; -} - -// Verify that given renderPass CreateInfo for primary and secondary command buffers are compatible. -// This function deals directly with the CreateInfo, there are overloaded versions below that can take the renderPass handle and -// will then feed into this function -static bool validateRenderPassCompatibility(layer_data const *dev_data, const char *type1_string, - const RENDER_PASS_STATE *rp1_state, const char *type2_string, - const RENDER_PASS_STATE *rp2_state, const char *caller, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - - if (rp1_state->createInfo.subpassCount != rp2_state->createInfo.subpassCount) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - HandleToUint64(rp1_state->renderPass), error_code, - "%s: RenderPasses incompatible between %s w/ renderPass 0x%" PRIx64 - " with a subpassCount of %u and %s w/ renderPass 0x%" PRIx64 " with a subpassCount of %u.", - caller, type1_string, HandleToUint64(rp1_state->renderPass), rp1_state->createInfo.subpassCount, - type2_string, HandleToUint64(rp2_state->renderPass), rp2_state->createInfo.subpassCount); - } else { - for (uint32_t i = 0; i < rp1_state->createInfo.subpassCount; ++i) { - skip |= validateSubpassCompatibility(dev_data, type1_string, rp1_state, type2_string, rp2_state, i, caller, error_code); - } - } - return skip; -} - -// Return Set node ptr for specified set or else NULL -cvdescriptorset::DescriptorSet *GetSetNode(const layer_data *dev_data, VkDescriptorSet set) { - auto set_it = dev_data->setMap.find(set); - if (set_it == dev_data->setMap.end()) { - return NULL; - } - return set_it->second; -} - -// For given pipeline, return number of MSAA samples, or one if MSAA disabled -static VkSampleCountFlagBits getNumSamples(PIPELINE_STATE const *pipe) { - if (pipe->graphicsPipelineCI.pMultisampleState != NULL && - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO == pipe->graphicsPipelineCI.pMultisampleState->sType) { - return pipe->graphicsPipelineCI.pMultisampleState->rasterizationSamples; - } - return VK_SAMPLE_COUNT_1_BIT; -} - -static void list_bits(std::ostream &s, uint32_t bits) { - for (int i = 0; i < 32 && bits; i++) { - if (bits & (1 << i)) { - s << i; - bits &= ~(1 << i); - if (bits) { - s << ","; - } - } - } -} - -// Validate draw-time state related to the PSO -static bool ValidatePipelineDrawtimeState(layer_data const *dev_data, LAST_BOUND_STATE const &state, const GLOBAL_CB_NODE *pCB, - CMD_TYPE cmd_type, PIPELINE_STATE const *pPipeline, const char *caller) { - bool skip = false; - - // Verify vertex binding - if (pPipeline->vertexBindingDescriptions.size() > 0) { - for (size_t i = 0; i < pPipeline->vertexBindingDescriptions.size(); i++) { - auto vertex_binding = pPipeline->vertexBindingDescriptions[i].binding; - if ((pCB->currentDrawData.buffers.size() < (vertex_binding + 1)) || - (pCB->currentDrawData.buffers[vertex_binding] == VK_NULL_HANDLE)) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, - "The Pipeline State Object (0x%" PRIx64 - ") expects that this Command Buffer's vertex binding Index %u should be set via " - "vkCmdBindVertexBuffers. This is because VkVertexInputBindingDescription struct at " - "index " PRINTF_SIZE_T_SPECIFIER " of pVertexBindingDescriptions has a binding value of %u.", - HandleToUint64(state.pipeline_state->pipeline), vertex_binding, i, vertex_binding); - } - } - } else { - if (!pCB->currentDrawData.buffers.empty() && !pCB->vertex_buffer_used) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(pCB->commandBuffer), - DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, - "Vertex buffers are bound to command buffer (0x%" PRIx64 - ") but no vertex buffers are attached to this Pipeline State Object (0x%" PRIx64 ").", - HandleToUint64(pCB->commandBuffer), HandleToUint64(state.pipeline_state->pipeline)); - } - } - // If Viewport or scissors are dynamic, verify that dynamic count matches PSO count. - // Skip check if rasterization is disabled or there is no viewport. - if ((!pPipeline->graphicsPipelineCI.pRasterizationState || - (pPipeline->graphicsPipelineCI.pRasterizationState->rasterizerDiscardEnable == VK_FALSE)) && - pPipeline->graphicsPipelineCI.pViewportState) { - bool dynViewport = isDynamic(pPipeline, VK_DYNAMIC_STATE_VIEWPORT); - bool dynScissor = isDynamic(pPipeline, VK_DYNAMIC_STATE_SCISSOR); - - if (dynViewport) { - auto requiredViewportsMask = (1 << pPipeline->graphicsPipelineCI.pViewportState->viewportCount) - 1; - auto missingViewportMask = ~pCB->viewportMask & requiredViewportsMask; - if (missingViewportMask) { - std::stringstream ss; - ss << "Dynamic viewport(s) "; - list_bits(ss, missingViewportMask); - ss << " are used by pipeline state object, but were not provided via calls to vkCmdSetViewport()."; - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "%s", ss.str().c_str()); - } - } - - if (dynScissor) { - auto requiredScissorMask = (1 << pPipeline->graphicsPipelineCI.pViewportState->scissorCount) - 1; - auto missingScissorMask = ~pCB->scissorMask & requiredScissorMask; - if (missingScissorMask) { - std::stringstream ss; - ss << "Dynamic scissor(s) "; - list_bits(ss, missingScissorMask); - ss << " are used by pipeline state object, but were not provided via calls to vkCmdSetScissor()."; - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "%s", ss.str().c_str()); - } - } - } - - // Verify that any MSAA request in PSO matches sample# in bound FB - // Skip the check if rasterization is disabled. - if (!pPipeline->graphicsPipelineCI.pRasterizationState || - (pPipeline->graphicsPipelineCI.pRasterizationState->rasterizerDiscardEnable == VK_FALSE)) { - VkSampleCountFlagBits pso_num_samples = getNumSamples(pPipeline); - if (pCB->activeRenderPass) { - auto const render_pass_info = pCB->activeRenderPass->createInfo.ptr(); - const VkSubpassDescription *subpass_desc = &render_pass_info->pSubpasses[pCB->activeSubpass]; - uint32_t i; - unsigned subpass_num_samples = 0; - - for (i = 0; i < subpass_desc->colorAttachmentCount; i++) { - auto attachment = subpass_desc->pColorAttachments[i].attachment; - if (attachment != VK_ATTACHMENT_UNUSED) - subpass_num_samples |= (unsigned)render_pass_info->pAttachments[attachment].samples; - } - - if (subpass_desc->pDepthStencilAttachment && - subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - auto attachment = subpass_desc->pDepthStencilAttachment->attachment; - subpass_num_samples |= (unsigned)render_pass_info->pAttachments[attachment].samples; - } - - if (!dev_data->extensions.vk_amd_mixed_attachment_samples && - ((subpass_num_samples & static_cast(pso_num_samples)) != subpass_num_samples)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), DRAWSTATE_NUM_SAMPLES_MISMATCH, - "Num samples mismatch! At draw-time in Pipeline (0x%" PRIx64 - ") with %u samples while current RenderPass (0x%" PRIx64 ") w/ %u samples!", - HandleToUint64(pPipeline->pipeline), pso_num_samples, - HandleToUint64(pCB->activeRenderPass->renderPass), subpass_num_samples); - } - } else { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), DRAWSTATE_NUM_SAMPLES_MISMATCH, - "No active render pass found at draw-time in Pipeline (0x%" PRIx64 ")!", - HandleToUint64(pPipeline->pipeline)); - } - } - // Verify that PSO creation renderPass is compatible with active renderPass - if (pCB->activeRenderPass) { - // TODO: Move all of the error codes common across different Draws into a LUT accessed by cmd_type - // TODO: AMD extension codes are included here, but actual function entrypoints are not yet intercepted - // Error codes for renderpass and subpass mismatches - auto rp_error = VALIDATION_ERROR_1a200366, sp_error = VALIDATION_ERROR_1a200368; - switch (cmd_type) { - case CMD_DRAWINDEXED: - rp_error = VALIDATION_ERROR_1a40038c; - sp_error = VALIDATION_ERROR_1a40038e; - break; - case CMD_DRAWINDIRECT: - rp_error = VALIDATION_ERROR_1aa003be; - sp_error = VALIDATION_ERROR_1aa003c0; - break; - case CMD_DRAWINDIRECTCOUNTAMD: - rp_error = VALIDATION_ERROR_1ac003f6; - sp_error = VALIDATION_ERROR_1ac003f8; - break; - case CMD_DRAWINDEXEDINDIRECT: - rp_error = VALIDATION_ERROR_1a600426; - sp_error = VALIDATION_ERROR_1a600428; - break; - case CMD_DRAWINDEXEDINDIRECTCOUNTAMD: - rp_error = VALIDATION_ERROR_1a800460; - sp_error = VALIDATION_ERROR_1a800462; - break; - default: - assert(CMD_DRAW == cmd_type); - break; - } - std::string err_string; - if (pCB->activeRenderPass->renderPass != pPipeline->rp_state->renderPass) { - // renderPass that PSO was created with must be compatible with active renderPass that PSO is being used with - skip |= validateRenderPassCompatibility(dev_data, "active render pass", pCB->activeRenderPass, "pipeline state object", - pPipeline->rp_state.get(), caller, rp_error); - } - if (pPipeline->graphicsPipelineCI.subpass != pCB->activeSubpass) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), sp_error, "Pipeline was built for subpass %u but used in subpass %u.", - pPipeline->graphicsPipelineCI.subpass, pCB->activeSubpass); - } - } - - return skip; -} - -// For given cvdescriptorset::DescriptorSet, verify that its Set is compatible w/ the setLayout corresponding to -// pipelineLayout[layoutIndex] -static bool verify_set_layout_compatibility(const cvdescriptorset::DescriptorSet *descriptor_set, - PIPELINE_LAYOUT_NODE const *pipeline_layout, const uint32_t layoutIndex, - string &errorMsg) { - auto num_sets = pipeline_layout->set_layouts.size(); - if (layoutIndex >= num_sets) { - stringstream errorStr; - errorStr << "VkPipelineLayout (" << pipeline_layout->layout << ") only contains " << num_sets - << " setLayouts corresponding to sets 0-" << num_sets - 1 << ", but you're attempting to bind set to index " - << layoutIndex; - errorMsg = errorStr.str(); - return false; - } - if (descriptor_set->IsPushDescriptor()) return true; - auto layout_node = pipeline_layout->set_layouts[layoutIndex]; - return descriptor_set->IsCompatible(layout_node.get(), &errorMsg); -} - -// Validate overall state at the time of a draw call -static bool ValidateDrawState(layer_data *dev_data, GLOBAL_CB_NODE *cb_node, CMD_TYPE cmd_type, const bool indexed, - const VkPipelineBindPoint bind_point, const char *function, - UNIQUE_VALIDATION_ERROR_CODE const msg_code) { - bool result = false; - auto const &state = cb_node->lastBound[bind_point]; - PIPELINE_STATE *pPipe = state.pipeline_state; - if (nullptr == pPipe) { - result |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_PIPELINE, - "At Draw/Dispatch time no valid VkPipeline is bound! This is illegal. Please bind one with vkCmdBindPipeline()."); - // Early return as any further checks below will be busted w/o a pipeline - if (result) return true; - } - // First check flag states - if (VK_PIPELINE_BIND_POINT_GRAPHICS == bind_point) - result = validate_draw_state_flags(dev_data, cb_node, pPipe, indexed, msg_code); - - // Now complete other state checks - string errorString; - auto const &pipeline_layout = pPipe->pipeline_layout; - - for (const auto &set_binding_pair : pPipe->active_slots) { - uint32_t setIndex = set_binding_pair.first; - // If valid set is not bound throw an error - if ((state.boundDescriptorSets.size() <= setIndex) || (!state.boundDescriptorSets[setIndex])) { - result |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_DESCRIPTOR_SET_NOT_BOUND, - "VkPipeline 0x%" PRIx64 " uses set #%u but that set is not bound.", HandleToUint64(pPipe->pipeline), - setIndex); - } else if (!verify_set_layout_compatibility(state.boundDescriptorSets[setIndex], &pipeline_layout, setIndex, errorString)) { - // Set is bound but not compatible w/ overlapping pipeline_layout from PSO - VkDescriptorSet setHandle = state.boundDescriptorSets[setIndex]->GetSet(); - result |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(setHandle), DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, - "VkDescriptorSet (0x%" PRIx64 - ") bound as set #%u is not compatible with overlapping VkPipelineLayout 0x%" PRIx64 " due to: %s", - HandleToUint64(setHandle), setIndex, HandleToUint64(pipeline_layout.layout), errorString.c_str()); - } else { // Valid set is bound and layout compatible, validate that it's updated - // Pull the set node - cvdescriptorset::DescriptorSet *descriptor_set = state.boundDescriptorSets[setIndex]; - // Validate the draw-time state for this descriptor set - std::string err_str; - if (!descriptor_set->IsPushDescriptor()) { - // For the "bindless" style resource usage with many descriptors, need to optimize command <-> descriptor - // binding validation. Take the requested binding set and prefilter it to eliminate redundant validation checks. - // Here, the currently bound pipeline determines whether an image validation check is redundant... - // for images are the "req" portion of the binding_req is indirectly (but tightly) coupled to the pipeline. - const cvdescriptorset::PrefilterBindRequestMap reduced_map(*descriptor_set, set_binding_pair.second, cb_node, - pPipe); - const auto &binding_req_map = reduced_map.Map(); - - if (!descriptor_set->ValidateDrawState(binding_req_map, state.dynamicOffsets[setIndex], cb_node, function, - &err_str)) { - auto set = descriptor_set->GetSet(); - result |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(set), DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, - "Descriptor set 0x%" PRIx64 " bound as set #%u encountered the following validation error at %s time: %s", - HandleToUint64(set), setIndex, function, err_str.c_str()); - } - } - } - } - - // Check general pipeline state that needs to be validated at drawtime - if (VK_PIPELINE_BIND_POINT_GRAPHICS == bind_point) - result |= ValidatePipelineDrawtimeState(dev_data, state, cb_node, cmd_type, pPipe, function); - - return result; -} - -static void UpdateDrawState(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, const VkPipelineBindPoint bind_point) { - auto const &state = cb_state->lastBound[bind_point]; - PIPELINE_STATE *pPipe = state.pipeline_state; - if (VK_NULL_HANDLE != state.pipeline_layout) { - for (const auto &set_binding_pair : pPipe->active_slots) { - uint32_t setIndex = set_binding_pair.first; - // Pull the set node - cvdescriptorset::DescriptorSet *descriptor_set = state.boundDescriptorSets[setIndex]; - if (!descriptor_set->IsPushDescriptor()) { - // For the "bindless" style resource usage with many descriptors, need to optimize command <-> descriptor binding - const cvdescriptorset::PrefilterBindRequestMap reduced_map(*descriptor_set, set_binding_pair.second, cb_state); - const auto &binding_req_map = reduced_map.Map(); - - // Bind this set and its active descriptor resources to the command buffer - descriptor_set->BindCommandBuffer(cb_state, binding_req_map); - // For given active slots record updated images & buffers - descriptor_set->GetStorageUpdates(binding_req_map, &cb_state->updateBuffers, &cb_state->updateImages); - } - } - } - if (pPipe->vertexBindingDescriptions.size() > 0) { - cb_state->vertex_buffer_used = true; - } -} - -static bool ValidatePipelineLocked(layer_data *dev_data, std::vector> const &pPipelines, - int pipelineIndex) { - bool skip = false; - - PIPELINE_STATE *pPipeline = pPipelines[pipelineIndex].get(); - - // If create derivative bit is set, check that we've specified a base - // pipeline correctly, and that the base pipeline was created to allow - // derivatives. - if (pPipeline->graphicsPipelineCI.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) { - PIPELINE_STATE *pBasePipeline = nullptr; - if (!((pPipeline->graphicsPipelineCI.basePipelineHandle != VK_NULL_HANDLE) ^ - (pPipeline->graphicsPipelineCI.basePipelineIndex != -1))) { - // This check is a superset of VALIDATION_ERROR_096005a8 and VALIDATION_ERROR_096005aa - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, - "Invalid Pipeline CreateInfo: exactly one of base pipeline index and handle must be specified"); - } else if (pPipeline->graphicsPipelineCI.basePipelineIndex != -1) { - if (pPipeline->graphicsPipelineCI.basePipelineIndex >= pipelineIndex) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_208005a0, - "Invalid Pipeline CreateInfo: base pipeline must occur earlier in array than derivative pipeline."); - } else { - pBasePipeline = pPipelines[pPipeline->graphicsPipelineCI.basePipelineIndex].get(); - } - } else if (pPipeline->graphicsPipelineCI.basePipelineHandle != VK_NULL_HANDLE) { - pBasePipeline = getPipelineState(dev_data, pPipeline->graphicsPipelineCI.basePipelineHandle); - } - - if (pBasePipeline && !(pBasePipeline->graphicsPipelineCI.flags & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, - "Invalid Pipeline CreateInfo: base pipeline does not allow derivatives."); - } - } - - return skip; -} - -// UNLOCKED pipeline validation. DO NOT lookup objects in the layer_data->* maps in this function. -static bool ValidatePipelineUnlocked(layer_data *dev_data, std::vector> const &pPipelines, - int pipelineIndex) { - bool skip = false; - - PIPELINE_STATE *pPipeline = pPipelines[pipelineIndex].get(); - - // Ensure the subpass index is valid. If not, then validate_and_capture_pipeline_shader_state - // produces nonsense errors that confuse users. Other layers should already - // emit errors for renderpass being invalid. - auto subpass_desc = &pPipeline->rp_state->createInfo.pSubpasses[pPipeline->graphicsPipelineCI.subpass]; - if (pPipeline->graphicsPipelineCI.subpass >= pPipeline->rp_state->createInfo.subpassCount) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005ee, - "Invalid Pipeline CreateInfo State: Subpass index %u is out of range for this renderpass (0..%u).", - pPipeline->graphicsPipelineCI.subpass, pPipeline->rp_state->createInfo.subpassCount - 1); - subpass_desc = nullptr; - } - - if (pPipeline->graphicsPipelineCI.pColorBlendState != NULL) { - const safe_VkPipelineColorBlendStateCreateInfo *color_blend_state = pPipeline->graphicsPipelineCI.pColorBlendState; - if (color_blend_state->attachmentCount != subpass_desc->colorAttachmentCount) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005d4, - "vkCreateGraphicsPipelines(): Render pass (0x%" PRIx64 - ") subpass %u has colorAttachmentCount of %u which doesn't match the pColorBlendState->attachmentCount of %u.", - HandleToUint64(pPipeline->rp_state->renderPass), pPipeline->graphicsPipelineCI.subpass, - subpass_desc->colorAttachmentCount, color_blend_state->attachmentCount); - } - if (!dev_data->enabled_features2.features.independentBlend) { - if (pPipeline->attachments.size() > 1) { - VkPipelineColorBlendAttachmentState *pAttachments = &pPipeline->attachments[0]; - for (size_t i = 1; i < pPipeline->attachments.size(); i++) { - // Quoting the spec: "If [the independent blend] feature is not enabled, the VkPipelineColorBlendAttachmentState - // settings for all color attachments must be identical." VkPipelineColorBlendAttachmentState contains - // only attachment state, so memcmp is best suited for the comparison - if (memcmp(static_cast(pAttachments), static_cast(&pAttachments[i]), - sizeof(pAttachments[0]))) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_0f4004ba, - "Invalid Pipeline CreateInfo: If independent blend feature not enabled, all elements of " - "pAttachments must be identical."); - break; - } - } - } - } - if (!dev_data->enabled_features2.features.logicOp && - (pPipeline->graphicsPipelineCI.pColorBlendState->logicOpEnable != VK_FALSE)) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_0f4004bc, - "Invalid Pipeline CreateInfo: If logic operations feature not enabled, logicOpEnable must be VK_FALSE."); - } - for (size_t i = 0; i < pPipeline->attachments.size(); i++) { - if ((pPipeline->attachments[i].srcColorBlendFactor == VK_BLEND_FACTOR_SRC1_COLOR) || - (pPipeline->attachments[i].srcColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR) || - (pPipeline->attachments[i].srcColorBlendFactor == VK_BLEND_FACTOR_SRC1_ALPHA) || - (pPipeline->attachments[i].srcColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA)) { - if (!dev_data->enabled_features2.features.dualSrcBlend) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_0f2004c0, - "vkCreateGraphicsPipelines(): pPipelines[%d].pColorBlendState.pAttachments[" PRINTF_SIZE_T_SPECIFIER - "].srcColorBlendFactor uses a dual-source blend factor (%d), but this device feature is not " - "enabled.", - pipelineIndex, i, pPipeline->attachments[i].srcColorBlendFactor); - } - } - if ((pPipeline->attachments[i].dstColorBlendFactor == VK_BLEND_FACTOR_SRC1_COLOR) || - (pPipeline->attachments[i].dstColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR) || - (pPipeline->attachments[i].dstColorBlendFactor == VK_BLEND_FACTOR_SRC1_ALPHA) || - (pPipeline->attachments[i].dstColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA)) { - if (!dev_data->enabled_features2.features.dualSrcBlend) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_0f2004c2, - "vkCreateGraphicsPipelines(): pPipelines[%d].pColorBlendState.pAttachments[" PRINTF_SIZE_T_SPECIFIER - "].dstColorBlendFactor uses a dual-source blend factor (%d), but this device feature is not " - "enabled.", - pipelineIndex, i, pPipeline->attachments[i].dstColorBlendFactor); - } - } - if ((pPipeline->attachments[i].srcAlphaBlendFactor == VK_BLEND_FACTOR_SRC1_COLOR) || - (pPipeline->attachments[i].srcAlphaBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR) || - (pPipeline->attachments[i].srcAlphaBlendFactor == VK_BLEND_FACTOR_SRC1_ALPHA) || - (pPipeline->attachments[i].srcAlphaBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA)) { - if (!dev_data->enabled_features2.features.dualSrcBlend) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_0f2004c4, - "vkCreateGraphicsPipelines(): pPipelines[%d].pColorBlendState.pAttachments[" PRINTF_SIZE_T_SPECIFIER - "].srcAlphaBlendFactor uses a dual-source blend factor (%d), but this device feature is not " - "enabled.", - pipelineIndex, i, pPipeline->attachments[i].srcAlphaBlendFactor); - } - } - if ((pPipeline->attachments[i].dstAlphaBlendFactor == VK_BLEND_FACTOR_SRC1_COLOR) || - (pPipeline->attachments[i].dstAlphaBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR) || - (pPipeline->attachments[i].dstAlphaBlendFactor == VK_BLEND_FACTOR_SRC1_ALPHA) || - (pPipeline->attachments[i].dstAlphaBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA)) { - if (!dev_data->enabled_features2.features.dualSrcBlend) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_0f2004c6, - "vkCreateGraphicsPipelines(): pPipelines[%d].pColorBlendState.pAttachments[" PRINTF_SIZE_T_SPECIFIER - "].dstAlphaBlendFactor uses a dual-source blend factor (%d), but this device feature is not " - "enabled.", - pipelineIndex, i, pPipeline->attachments[i].dstAlphaBlendFactor); - } - } - } - } - - if (validate_and_capture_pipeline_shader_state(dev_data, pPipeline)) { - skip = true; - } - // Each shader's stage must be unique - if (pPipeline->duplicate_shaders) { - for (uint32_t stage = VK_SHADER_STAGE_VERTEX_BIT; stage & VK_SHADER_STAGE_ALL_GRAPHICS; stage <<= 1) { - if (pPipeline->duplicate_shaders & stage) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, - "Invalid Pipeline CreateInfo State: Multiple shaders provided for stage %s", - string_VkShaderStageFlagBits(VkShaderStageFlagBits(stage))); - } - } - } - // VS is required - if (!(pPipeline->active_shaders & VK_SHADER_STAGE_VERTEX_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005ae, - "Invalid Pipeline CreateInfo State: Vertex Shader required."); - } - // Either both or neither TC/TE shaders should be defined - bool has_control = (pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0; - bool has_eval = (pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0; - if (has_control && !has_eval) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005b2, - "Invalid Pipeline CreateInfo State: TE and TC shaders must be included or excluded as a pair."); - } - if (!has_control && has_eval) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005b4, - "Invalid Pipeline CreateInfo State: TE and TC shaders must be included or excluded as a pair."); - } - // Compute shaders should be specified independent of Gfx shaders - if (pPipeline->active_shaders & VK_SHADER_STAGE_COMPUTE_BIT) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005b0, - "Invalid Pipeline CreateInfo State: Do not specify Compute Shader for Gfx Pipeline."); - } - // VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive topology is only valid for tessellation pipelines. - // Mismatching primitive topology and tessellation fails graphics pipeline creation. - if (has_control && has_eval && - (!pPipeline->graphicsPipelineCI.pInputAssemblyState || - pPipeline->graphicsPipelineCI.pInputAssemblyState->topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005c0, - "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH_LIST must be set as IA topology for " - "tessellation pipelines."); - } - if (pPipeline->graphicsPipelineCI.pInputAssemblyState && - pPipeline->graphicsPipelineCI.pInputAssemblyState->topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) { - if (!has_control || !has_eval) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005c2, - "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive topology is only valid " - "for tessellation pipelines."); - } - } - - // If a rasterization state is provided... - if (pPipeline->graphicsPipelineCI.pRasterizationState) { - if ((pPipeline->graphicsPipelineCI.pRasterizationState->depthClampEnable == VK_TRUE) && - (!dev_data->enabled_features2.features.depthClamp)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_1020061c, - "vkCreateGraphicsPipelines(): the depthClamp device feature is disabled: the depthClampEnable member " - "of the VkPipelineRasterizationStateCreateInfo structure must be set to VK_FALSE."); - } - - if (!isDynamic(pPipeline, VK_DYNAMIC_STATE_DEPTH_BIAS) && - (pPipeline->graphicsPipelineCI.pRasterizationState->depthBiasClamp != 0.0) && - (!dev_data->enabled_features2.features.depthBiasClamp)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), DRAWSTATE_INVALID_FEATURE, - "vkCreateGraphicsPipelines(): the depthBiasClamp device feature is disabled: the depthBiasClamp member " - "of the VkPipelineRasterizationStateCreateInfo structure must be set to 0.0 unless the " - "VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state is enabled"); - } - - // If rasterization is enabled... - if (pPipeline->graphicsPipelineCI.pRasterizationState->rasterizerDiscardEnable == VK_FALSE) { - if ((pPipeline->graphicsPipelineCI.pMultisampleState->alphaToOneEnable == VK_TRUE) && - (!dev_data->enabled_features2.features.alphaToOne)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_10000622, - "vkCreateGraphicsPipelines(): the alphaToOne device feature is disabled: the alphaToOneEnable " - "member of the VkPipelineMultisampleStateCreateInfo structure must be set to VK_FALSE."); - } - - // If subpass uses a depth/stencil attachment, pDepthStencilState must be a pointer to a valid structure - if (subpass_desc && subpass_desc->pDepthStencilAttachment && - subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - if (!pPipeline->graphicsPipelineCI.pDepthStencilState) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005e0, - "Invalid Pipeline CreateInfo State: pDepthStencilState is NULL when rasterization is enabled " - "and subpass uses a depth/stencil attachment."); - - } else if ((pPipeline->graphicsPipelineCI.pDepthStencilState->depthBoundsTestEnable == VK_TRUE) && - (!dev_data->enabled_features2.features.depthBounds)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_0f6004ac, - "vkCreateGraphicsPipelines(): the depthBounds device feature is disabled: the " - "depthBoundsTestEnable member of the VkPipelineDepthStencilStateCreateInfo structure must be " - "set to VK_FALSE."); - } - } - - // If subpass uses color attachments, pColorBlendState must be valid pointer - if (subpass_desc) { - uint32_t color_attachment_count = 0; - for (uint32_t i = 0; i < subpass_desc->colorAttachmentCount; ++i) { - if (subpass_desc->pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED) { - ++color_attachment_count; - } - } - if (color_attachment_count > 0 && pPipeline->graphicsPipelineCI.pColorBlendState == nullptr) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_096005e2, - "Invalid Pipeline CreateInfo State: pColorBlendState is NULL when rasterization is enabled and " - "subpass uses color attachments."); - } - } - } - } - - auto vi = pPipeline->graphicsPipelineCI.pVertexInputState; - if (vi != NULL) { - for (uint32_t j = 0; j < vi->vertexAttributeDescriptionCount; j++) { - VkFormat format = vi->pVertexAttributeDescriptions[j].format; - // Internal call to get format info. Still goes through layers, could potentially go directly to ICD. - VkFormatProperties properties; - dev_data->instance_data->dispatch_table.GetPhysicalDeviceFormatProperties(dev_data->physical_device, format, - &properties); - if ((properties.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) == 0) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_14a004de, - "vkCreateGraphicsPipelines: pCreateInfo[%d].pVertexInputState->vertexAttributeDescriptions[%d].format " - "(%s) is not a supported vertex buffer format.", - pipelineIndex, j, string_VkFormat(format)); - } - } - } - - if (dev_data->extensions.vk_amd_mixed_attachment_samples) { - VkSampleCountFlagBits max_sample_count = static_cast(0); - for (uint32_t i = 0; i < subpass_desc->colorAttachmentCount; ++i) { - if (subpass_desc->pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED) { - max_sample_count = - std::max(max_sample_count, - pPipeline->rp_state->createInfo.pAttachments[subpass_desc->pColorAttachments[i].attachment].samples); - } - } - if (subpass_desc->pDepthStencilAttachment && subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - max_sample_count = - std::max(max_sample_count, - pPipeline->rp_state->createInfo.pAttachments[subpass_desc->pDepthStencilAttachment->attachment].samples); - } - if (pPipeline->graphicsPipelineCI.pMultisampleState->rasterizationSamples != max_sample_count) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - HandleToUint64(pPipeline->pipeline), VALIDATION_ERROR_09600bc2, - "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%s) != max " - "attachment samples (%s) used in subpass %u.", - pipelineIndex, - string_VkSampleCountFlagBits(pPipeline->graphicsPipelineCI.pMultisampleState->rasterizationSamples), - string_VkSampleCountFlagBits(max_sample_count), pPipeline->graphicsPipelineCI.subpass); - } - } - - return skip; -} - -// Block of code at start here specifically for managing/tracking DSs - -// Return Pool node ptr for specified pool or else NULL -DESCRIPTOR_POOL_STATE *GetDescriptorPoolState(const layer_data *dev_data, const VkDescriptorPool pool) { - auto pool_it = dev_data->descriptorPoolMap.find(pool); - if (pool_it == dev_data->descriptorPoolMap.end()) { - return NULL; - } - return pool_it->second; -} - -// Validate that given set is valid and that it's not being used by an in-flight CmdBuffer -// func_str is the name of the calling function -// Return false if no errors occur -// Return true if validation error occurs and callback returns true (to skip upcoming API call down the chain) -static bool validateIdleDescriptorSet(const layer_data *dev_data, VkDescriptorSet set, std::string func_str) { - if (dev_data->instance_data->disabled.idle_descriptor_set) return false; - bool skip = false; - auto set_node = dev_data->setMap.find(set); - if (set_node == dev_data->setMap.end()) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(set), DRAWSTATE_DOUBLE_DESTROY, - "Cannot call %s() on descriptor set 0x%" PRIx64 " that has not been allocated.", func_str.c_str(), - HandleToUint64(set)); - } else { - // TODO : This covers various error cases so should pass error enum into this function and use passed in enum here - if (set_node->second->in_use.load()) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(set), VALIDATION_ERROR_2860026a, - "Cannot call %s() on descriptor set 0x%" PRIx64 " that is in use by a command buffer.", - func_str.c_str(), HandleToUint64(set)); - } - } - return skip; -} - -// Validate that given pool does not store any descriptor sets used by an in-flight CmdBuffer -// pool stores the descriptor sets to be validated -// Return false if no errors occur -// Return true if validation error occurs and callback returns true (to skip upcoming API call down the chain) -static bool validateIdleDescriptorSetForPoolReset(const layer_data *dev_data, const VkDescriptorPool pool) { - if (dev_data->instance_data->disabled.idle_descriptor_set) return false; - bool skip = false; - DESCRIPTOR_POOL_STATE *pPool = GetDescriptorPoolState(dev_data, pool); - if (pPool != nullptr) { - for (auto ds : pPool->sets) { - if (ds && ds->in_use.load()) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, HandleToUint64(pool), VALIDATION_ERROR_32a00272, - "It is invalid to call vkResetDescriptorPool() with descriptor sets in use by a command buffer. %s", - validation_error_map[VALIDATION_ERROR_32a00272]); - if (skip) break; - } - } - } - return skip; -} - -// Remove set from setMap and delete the set -static void freeDescriptorSet(layer_data *dev_data, cvdescriptorset::DescriptorSet *descriptor_set) { - dev_data->setMap.erase(descriptor_set->GetSet()); - delete descriptor_set; -} -// Free all DS Pools including their Sets & related sub-structs -// NOTE : Calls to this function should be wrapped in mutex -static void deletePools(layer_data *dev_data) { - for (auto ii = dev_data->descriptorPoolMap.begin(); ii != dev_data->descriptorPoolMap.end();) { - // Remove this pools' sets from setMap and delete them - for (auto ds : ii->second->sets) { - freeDescriptorSet(dev_data, ds); - } - ii->second->sets.clear(); - delete ii->second; - ii = dev_data->descriptorPoolMap.erase(ii); - } -} - -static void clearDescriptorPool(layer_data *dev_data, const VkDevice device, const VkDescriptorPool pool, - VkDescriptorPoolResetFlags flags) { - DESCRIPTOR_POOL_STATE *pPool = GetDescriptorPoolState(dev_data, pool); - // TODO: validate flags - // For every set off of this pool, clear it, remove from setMap, and free cvdescriptorset::DescriptorSet - for (auto ds : pPool->sets) { - freeDescriptorSet(dev_data, ds); - } - pPool->sets.clear(); - // Reset available count for each type and available sets for this pool - for (uint32_t i = 0; i < pPool->availableDescriptorTypeCount.size(); ++i) { - pPool->availableDescriptorTypeCount[i] = pPool->maxDescriptorTypeCount[i]; - } - pPool->availableSets = pPool->maxSets; -} - -// For given CB object, fetch associated CB Node from map -GLOBAL_CB_NODE *GetCBNode(layer_data const *dev_data, const VkCommandBuffer cb) { - auto it = dev_data->commandBufferMap.find(cb); - if (it == dev_data->commandBufferMap.end()) { - return NULL; - } - return it->second; -} - -// If a renderpass is active, verify that the given command type is appropriate for current subpass state -bool ValidateCmdSubpassState(const layer_data *dev_data, const GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd_type) { - if (!pCB->activeRenderPass) return false; - bool skip = false; - if (pCB->activeSubpassContents == VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS && - (cmd_type != CMD_EXECUTECOMMANDS && cmd_type != CMD_NEXTSUBPASS && cmd_type != CMD_ENDRENDERPASS)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_COMMAND_BUFFER, - "Commands cannot be called in a subpass using secondary command buffers."); - } else if (pCB->activeSubpassContents == VK_SUBPASS_CONTENTS_INLINE && cmd_type == CMD_EXECUTECOMMANDS) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_COMMAND_BUFFER, - "vkCmdExecuteCommands() cannot be called in a subpass using inline commands."); - } - return skip; -} - -bool ValidateCmdQueueFlags(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const char *caller_name, - VkQueueFlags required_flags, UNIQUE_VALIDATION_ERROR_CODE error_code) { - auto pool = GetCommandPoolNode(dev_data, cb_node->createInfo.commandPool); - if (pool) { - VkQueueFlags queue_flags = dev_data->phys_dev_properties.queue_family_properties[pool->queueFamilyIndex].queueFlags; - if (!(required_flags & queue_flags)) { - string required_flags_string; - for (auto flag : {VK_QUEUE_TRANSFER_BIT, VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT}) { - if (flag & required_flags) { - if (required_flags_string.size()) { - required_flags_string += " or "; - } - required_flags_string += string_VkQueueFlagBits(flag); - } - } - return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), error_code, - "Cannot call %s on a command buffer allocated from a pool without %s capabilities..", caller_name, - required_flags_string.c_str()); - } - } - return false; -} - -static char const *GetCauseStr(VK_OBJECT obj) { - if (obj.type == kVulkanObjectTypeDescriptorSet) return "destroyed or updated"; - if (obj.type == kVulkanObjectTypeCommandBuffer) return "destroyed or rerecorded"; - return "destroyed"; -} - -static bool ReportInvalidCommandBuffer(layer_data *dev_data, const GLOBAL_CB_NODE *cb_state, const char *call_source) { - bool skip = false; - for (auto obj : cb_state->broken_bindings) { - const char *type_str = object_string[obj.type]; - const char *cause_str = GetCauseStr(obj); - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), DRAWSTATE_INVALID_COMMAND_BUFFER, - "You are adding %s to command buffer 0x%" PRIx64 " that is invalid because bound %s 0x%" PRIx64 " was %s.", - call_source, HandleToUint64(cb_state->commandBuffer), type_str, obj.handle, cause_str); - } - return skip; -} - -// 'commandBuffer must be in the recording state' valid usage error code for each command -// Note: grepping for ^^^^^^^^^ in vk_validation_database is easily massaged into the following list -// Note: C++11 doesn't automatically devolve enum types to the underlying type for hash traits purposes (fixed in C++14) -using CmdTypeHashType = std::underlying_type::type; -static const std::unordered_map must_be_recording_map = { - {CMD_NONE, VALIDATION_ERROR_UNDEFINED}, // UNMATCHED - {CMD_BEGINQUERY, VALIDATION_ERROR_17802413}, - {CMD_BEGINRENDERPASS, VALIDATION_ERROR_17a02413}, - {CMD_BINDDESCRIPTORSETS, VALIDATION_ERROR_17c02413}, - {CMD_BINDINDEXBUFFER, VALIDATION_ERROR_17e02413}, - {CMD_BINDPIPELINE, VALIDATION_ERROR_18002413}, - {CMD_BINDVERTEXBUFFERS, VALIDATION_ERROR_18202413}, - {CMD_BLITIMAGE, VALIDATION_ERROR_18402413}, - {CMD_CLEARATTACHMENTS, VALIDATION_ERROR_18602413}, - {CMD_CLEARCOLORIMAGE, VALIDATION_ERROR_18802413}, - {CMD_CLEARDEPTHSTENCILIMAGE, VALIDATION_ERROR_18a02413}, - {CMD_COPYBUFFER, VALIDATION_ERROR_18c02413}, - {CMD_COPYBUFFERTOIMAGE, VALIDATION_ERROR_18e02413}, - {CMD_COPYIMAGE, VALIDATION_ERROR_19002413}, - {CMD_COPYIMAGETOBUFFER, VALIDATION_ERROR_19202413}, - {CMD_COPYQUERYPOOLRESULTS, VALIDATION_ERROR_19402413}, - {CMD_DEBUGMARKERBEGINEXT, VALIDATION_ERROR_19602413}, - {CMD_DEBUGMARKERENDEXT, VALIDATION_ERROR_19802413}, - {CMD_DEBUGMARKERINSERTEXT, VALIDATION_ERROR_19a02413}, - {CMD_DISPATCH, VALIDATION_ERROR_19c02413}, - // Exclude KHX (if not already present) { CMD_DISPATCHBASEKHX, VALIDATION_ERROR_19e02413 }, - {CMD_DISPATCHINDIRECT, VALIDATION_ERROR_1a002413}, - {CMD_DRAW, VALIDATION_ERROR_1a202413}, - {CMD_DRAWINDEXED, VALIDATION_ERROR_1a402413}, - {CMD_DRAWINDEXEDINDIRECT, VALIDATION_ERROR_1a602413}, - // Exclude vendor ext (if not already present) { CMD_DRAWINDEXEDINDIRECTCOUNTAMD, VALIDATION_ERROR_1a802413 }, - {CMD_DRAWINDIRECT, VALIDATION_ERROR_1aa02413}, - // Exclude vendor ext (if not already present) { CMD_DRAWINDIRECTCOUNTAMD, VALIDATION_ERROR_1ac02413 }, - {CMD_ENDCOMMANDBUFFER, VALIDATION_ERROR_27400076}, - {CMD_ENDQUERY, VALIDATION_ERROR_1ae02413}, - {CMD_ENDRENDERPASS, VALIDATION_ERROR_1b002413}, - {CMD_EXECUTECOMMANDS, VALIDATION_ERROR_1b202413}, - {CMD_FILLBUFFER, VALIDATION_ERROR_1b402413}, - {CMD_NEXTSUBPASS, VALIDATION_ERROR_1b602413}, - {CMD_PIPELINEBARRIER, VALIDATION_ERROR_1b802413}, - // Exclude vendor ext (if not already present) { CMD_PROCESSCOMMANDSNVX, VALIDATION_ERROR_1ba02413 }, - {CMD_PUSHCONSTANTS, VALIDATION_ERROR_1bc02413}, - {CMD_PUSHDESCRIPTORSETKHR, VALIDATION_ERROR_1be02413}, - {CMD_PUSHDESCRIPTORSETWITHTEMPLATEKHR, VALIDATION_ERROR_1c002413}, - // Exclude vendor ext (if not already present) { CMD_RESERVESPACEFORCOMMANDSNVX, VALIDATION_ERROR_1c202413 }, - {CMD_RESETEVENT, VALIDATION_ERROR_1c402413}, - {CMD_RESETQUERYPOOL, VALIDATION_ERROR_1c602413}, - {CMD_RESOLVEIMAGE, VALIDATION_ERROR_1c802413}, - {CMD_SETBLENDCONSTANTS, VALIDATION_ERROR_1ca02413}, - {CMD_SETDEPTHBIAS, VALIDATION_ERROR_1cc02413}, - {CMD_SETDEPTHBOUNDS, VALIDATION_ERROR_1ce02413}, - // Exclude KHX (if not already present) { CMD_SETDEVICEMASKKHX, VALIDATION_ERROR_1d002413 }, - {CMD_SETDISCARDRECTANGLEEXT, VALIDATION_ERROR_1d202413}, - {CMD_SETEVENT, VALIDATION_ERROR_1d402413}, - {CMD_SETLINEWIDTH, VALIDATION_ERROR_1d602413}, - {CMD_SETSAMPLELOCATIONSEXT, VALIDATION_ERROR_3e202413}, - {CMD_SETSCISSOR, VALIDATION_ERROR_1d802413}, - {CMD_SETSTENCILCOMPAREMASK, VALIDATION_ERROR_1da02413}, - {CMD_SETSTENCILREFERENCE, VALIDATION_ERROR_1dc02413}, - {CMD_SETSTENCILWRITEMASK, VALIDATION_ERROR_1de02413}, - {CMD_SETVIEWPORT, VALIDATION_ERROR_1e002413}, - // Exclude vendor ext (if not already present) { CMD_SETVIEWPORTWSCALINGNV, VALIDATION_ERROR_1e202413 }, - {CMD_UPDATEBUFFER, VALIDATION_ERROR_1e402413}, - {CMD_WAITEVENTS, VALIDATION_ERROR_1e602413}, - {CMD_WRITETIMESTAMP, VALIDATION_ERROR_1e802413}, -}; - -// Validate the given command being added to the specified cmd buffer, flagging errors if CB is not in the recording state or if -// there's an issue with the Cmd ordering -bool ValidateCmd(layer_data *dev_data, const GLOBAL_CB_NODE *cb_state, const CMD_TYPE cmd, const char *caller_name) { - switch (cb_state->state) { - case CB_RECORDING: - return ValidateCmdSubpassState(dev_data, cb_state, cmd); - - case CB_INVALID_COMPLETE: - case CB_INVALID_INCOMPLETE: - return ReportInvalidCommandBuffer(dev_data, cb_state, caller_name); - - default: - auto error_it = must_be_recording_map.find(cmd); - // This assert lets us know that a vkCmd.* entrypoint has been added without enabling it in the map - assert(error_it != must_be_recording_map.cend()); - if (error_it == must_be_recording_map.cend()) { - error_it = must_be_recording_map.find(CMD_NONE); // But we'll handle the asserting case, in case of a test gap - } - const auto error = error_it->second; - return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), error, - "You must call vkBeginCommandBuffer() before this call to %s.", caller_name); - } -} - -// For given object struct return a ptr of BASE_NODE type for its wrapping struct -BASE_NODE *GetStateStructPtrFromObject(layer_data *dev_data, VK_OBJECT object_struct) { - BASE_NODE *base_ptr = nullptr; - switch (object_struct.type) { - case kVulkanObjectTypeDescriptorSet: { - base_ptr = GetSetNode(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeSampler: { - base_ptr = GetSamplerState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeQueryPool: { - base_ptr = GetQueryPoolNode(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypePipeline: { - base_ptr = getPipelineState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeBuffer: { - base_ptr = GetBufferState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeBufferView: { - base_ptr = GetBufferViewState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeImage: { - base_ptr = GetImageState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeImageView: { - base_ptr = GetImageViewState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeEvent: { - base_ptr = GetEventNode(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeDescriptorPool: { - base_ptr = GetDescriptorPoolState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeCommandPool: { - base_ptr = GetCommandPoolNode(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeFramebuffer: { - base_ptr = GetFramebufferState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeRenderPass: { - base_ptr = GetRenderPassState(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - case kVulkanObjectTypeDeviceMemory: { - base_ptr = GetMemObjInfo(dev_data, reinterpret_cast(object_struct.handle)); - break; - } - default: - // TODO : Any other objects to be handled here? - assert(0); - break; - } - return base_ptr; -} - -// Tie the VK_OBJECT to the cmd buffer which includes: -// Add object_binding to cmd buffer -// Add cb_binding to object -static void addCommandBufferBinding(std::unordered_set *cb_bindings, VK_OBJECT obj, GLOBAL_CB_NODE *cb_node) { - cb_bindings->insert(cb_node); - cb_node->object_bindings.insert(obj); -} -// For a given object, if cb_node is in that objects cb_bindings, remove cb_node -static void removeCommandBufferBinding(layer_data *dev_data, VK_OBJECT const *object, GLOBAL_CB_NODE *cb_node) { - BASE_NODE *base_obj = GetStateStructPtrFromObject(dev_data, *object); - if (base_obj) base_obj->cb_bindings.erase(cb_node); -} -// Reset the command buffer state -// Maintain the createInfo and set state to CB_NEW, but clear all other state -static void ResetCommandBufferState(layer_data *dev_data, const VkCommandBuffer cb) { - GLOBAL_CB_NODE *pCB = dev_data->commandBufferMap[cb]; - if (pCB) { - pCB->in_use.store(0); - // Reset CB state (note that createInfo is not cleared) - pCB->commandBuffer = cb; - memset(&pCB->beginInfo, 0, sizeof(VkCommandBufferBeginInfo)); - memset(&pCB->inheritanceInfo, 0, sizeof(VkCommandBufferInheritanceInfo)); - pCB->hasDrawCmd = false; - pCB->state = CB_NEW; - pCB->submitCount = 0; - pCB->image_layout_change_count = 1; // Start at 1. 0 is insert value for validation cache versions, s.t. new == dirty - pCB->status = 0; - pCB->static_status = 0; - pCB->viewportMask = 0; - pCB->scissorMask = 0; - - for (uint32_t i = 0; i < VK_PIPELINE_BIND_POINT_RANGE_SIZE; ++i) { - pCB->lastBound[i].reset(); - } - - memset(&pCB->activeRenderPassBeginInfo, 0, sizeof(pCB->activeRenderPassBeginInfo)); - pCB->activeRenderPass = nullptr; - pCB->activeSubpassContents = VK_SUBPASS_CONTENTS_INLINE; - pCB->activeSubpass = 0; - pCB->broken_bindings.clear(); - pCB->waitedEvents.clear(); - pCB->events.clear(); - pCB->writeEventsBeforeWait.clear(); - pCB->waitedEventsBeforeQueryReset.clear(); - pCB->queryToStateMap.clear(); - pCB->activeQueries.clear(); - pCB->startedQueries.clear(); - pCB->imageLayoutMap.clear(); - pCB->eventToStageMap.clear(); - pCB->drawData.clear(); - pCB->currentDrawData.buffers.clear(); - pCB->vertex_buffer_used = false; - pCB->primaryCommandBuffer = VK_NULL_HANDLE; - // If secondary, invalidate any primary command buffer that may call us. - if (pCB->createInfo.level == VK_COMMAND_BUFFER_LEVEL_SECONDARY) { - invalidateCommandBuffers(dev_data, pCB->linkedCommandBuffers, {HandleToUint64(cb), kVulkanObjectTypeCommandBuffer}); - } - - // Remove reverse command buffer links. - for (auto pSubCB : pCB->linkedCommandBuffers) { - pSubCB->linkedCommandBuffers.erase(pCB); - } - pCB->linkedCommandBuffers.clear(); - pCB->updateImages.clear(); - pCB->updateBuffers.clear(); - clear_cmd_buf_and_mem_references(dev_data, pCB); - pCB->queue_submit_functions.clear(); - pCB->cmd_execute_commands_functions.clear(); - pCB->eventUpdates.clear(); - pCB->queryUpdates.clear(); - - // Remove object bindings - for (auto obj : pCB->object_bindings) { - removeCommandBufferBinding(dev_data, &obj, pCB); - } - pCB->object_bindings.clear(); - // Remove this cmdBuffer's reference from each FrameBuffer's CB ref list - for (auto framebuffer : pCB->framebuffers) { - auto fb_state = GetFramebufferState(dev_data, framebuffer); - if (fb_state) fb_state->cb_bindings.erase(pCB); - } - pCB->framebuffers.clear(); - pCB->activeFramebuffer = VK_NULL_HANDLE; - memset(&pCB->index_buffer_binding, 0, sizeof(pCB->index_buffer_binding)); - } -} - -CBStatusFlags MakeStaticStateMask(VkPipelineDynamicStateCreateInfo const *ds) { - // initially assume everything is static state - CBStatusFlags flags = CBSTATUS_ALL_STATE_SET; - - if (ds) { - for (uint32_t i = 0; i < ds->dynamicStateCount; i++) { - switch (ds->pDynamicStates[i]) { - case VK_DYNAMIC_STATE_LINE_WIDTH: - flags &= ~CBSTATUS_LINE_WIDTH_SET; - break; - case VK_DYNAMIC_STATE_DEPTH_BIAS: - flags &= ~CBSTATUS_DEPTH_BIAS_SET; - break; - case VK_DYNAMIC_STATE_BLEND_CONSTANTS: - flags &= ~CBSTATUS_BLEND_CONSTANTS_SET; - break; - case VK_DYNAMIC_STATE_DEPTH_BOUNDS: - flags &= ~CBSTATUS_DEPTH_BOUNDS_SET; - break; - case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: - flags &= ~CBSTATUS_STENCIL_READ_MASK_SET; - break; - case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: - flags &= ~CBSTATUS_STENCIL_WRITE_MASK_SET; - break; - case VK_DYNAMIC_STATE_STENCIL_REFERENCE: - flags &= ~CBSTATUS_STENCIL_REFERENCE_SET; - break; - case VK_DYNAMIC_STATE_SCISSOR: - flags &= ~CBSTATUS_SCISSOR_SET; - break; - case VK_DYNAMIC_STATE_VIEWPORT: - flags &= ~CBSTATUS_VIEWPORT_SET; - break; - default: - break; - } - } - } - - return flags; -} - -// Flags validation error if the associated call is made inside a render pass. The apiName routine should ONLY be called outside a -// render pass. -bool insideRenderPass(const layer_data *dev_data, const GLOBAL_CB_NODE *pCB, const char *apiName, - UNIQUE_VALIDATION_ERROR_CODE msgCode) { - bool inside = false; - if (pCB->activeRenderPass) { - inside = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), msgCode, - "%s: It is invalid to issue this call inside an active render pass (0x%" PRIx64 ").", apiName, - HandleToUint64(pCB->activeRenderPass->renderPass)); - } - return inside; -} - -// Flags validation error if the associated call is made outside a render pass. The apiName -// routine should ONLY be called inside a render pass. -bool outsideRenderPass(const layer_data *dev_data, GLOBAL_CB_NODE *pCB, const char *apiName, UNIQUE_VALIDATION_ERROR_CODE msgCode) { - bool outside = false; - if (((pCB->createInfo.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) && (!pCB->activeRenderPass)) || - ((pCB->createInfo.level == VK_COMMAND_BUFFER_LEVEL_SECONDARY) && (!pCB->activeRenderPass) && - !(pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT))) { - outside = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), msgCode, "%s: This call must be issued inside an active render pass.", - apiName); - } - return outside; -} - -static void init_core_validation(instance_layer_data *instance_data, const VkAllocationCallbacks *pAllocator) { - layer_debug_report_actions(instance_data->report_data, instance_data->logging_callback, pAllocator, "lunarg_core_validation"); - layer_debug_messenger_actions(instance_data->report_data, instance_data->logging_messenger, pAllocator, - "lunarg_core_validation"); -} - -// For the given ValidationCheck enum, set all relevant instance disabled flags to true -void SetDisabledFlags(instance_layer_data *instance_data, const VkValidationFlagsEXT *val_flags_struct) { - for (uint32_t i = 0; i < val_flags_struct->disabledValidationCheckCount; ++i) { - switch (val_flags_struct->pDisabledValidationChecks[i]) { - case VK_VALIDATION_CHECK_SHADERS_EXT: - instance_data->disabled.shader_validation = true; - break; - case VK_VALIDATION_CHECK_ALL_EXT: - // Set all disabled flags to true - instance_data->disabled.SetAll(true); - break; - default: - break; - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) { - VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); - if (fpCreateInstance == NULL) return VK_ERROR_INITIALIZATION_FAILED; - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); - if (result != VK_SUCCESS) return result; - - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), instance_layer_data_map); - instance_data->instance = *pInstance; - layer_init_instance_dispatch_table(*pInstance, &instance_data->dispatch_table, fpGetInstanceProcAddr); - instance_data->report_data = debug_utils_create_instance( - &instance_data->dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames); - - instance_data->api_version = instance_data->extensions.InitFromInstanceCreateInfo( - (pCreateInfo->pApplicationInfo ? pCreateInfo->pApplicationInfo->apiVersion : VK_API_VERSION_1_0), pCreateInfo); - init_core_validation(instance_data, pAllocator); - - ValidateLayerOrdering(*pCreateInfo); - // Parse any pNext chains - const auto *validation_flags_ext = lvl_find_in_chain(pCreateInfo->pNext); - if (validation_flags_ext) { - SetDisabledFlags(instance_data, validation_flags_ext); - } - - return result; -} - -// Hook DestroyInstance to remove tableInstanceMap entry -VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - // TODOSC : Shouldn't need any customization here - dispatch_key key = get_dispatch_key(instance); - // TBD: Need any locking this early, in case this function is called at the - // same time by more than one thread? - instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map); - instance_data->dispatch_table.DestroyInstance(instance, pAllocator); - - lock_guard_t lock(global_lock); - // Clean up logging callback, if any - while (instance_data->logging_messenger.size() > 0) { - VkDebugUtilsMessengerEXT messenger = instance_data->logging_messenger.back(); - layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator); - instance_data->logging_messenger.pop_back(); - } - while (instance_data->logging_callback.size() > 0) { - VkDebugReportCallbackEXT callback = instance_data->logging_callback.back(); - layer_destroy_report_callback(instance_data->report_data, callback, pAllocator); - instance_data->logging_callback.pop_back(); - } - - layer_debug_utils_destroy_instance(instance_data->report_data); - FreeLayerDataPtr(key, instance_layer_data_map); -} - -static bool ValidatePhysicalDeviceQueueFamily(instance_layer_data *instance_data, const PHYSICAL_DEVICE_STATE *pd_state, - uint32_t requested_queue_family, int32_t err_code, const char *cmd_name, - const char *queue_family_var_name) { - bool skip = false; - - const char *conditional_ext_cmd = instance_data->extensions.vk_khr_get_physical_device_properties_2 - ? "or vkGetPhysicalDeviceQueueFamilyProperties2[KHR]" - : ""; - - std::string count_note = (UNCALLED == pd_state->vkGetPhysicalDeviceQueueFamilyPropertiesState) - ? "the pQueueFamilyPropertyCount was never obtained" - : "i.e. is not less than " + std::to_string(pd_state->queue_family_count); - - if (requested_queue_family >= pd_state->queue_family_count) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - HandleToUint64(pd_state->phys_device), err_code, - "%s: %s (= %" PRIu32 - ") is not less than any previously obtained pQueueFamilyPropertyCount from " - "vkGetPhysicalDeviceQueueFamilyProperties%s (%s).", - cmd_name, queue_family_var_name, requested_queue_family, conditional_ext_cmd, count_note.c_str()); - } - return skip; -} - -// Verify VkDeviceQueueCreateInfos -static bool ValidateDeviceQueueCreateInfos(instance_layer_data *instance_data, const PHYSICAL_DEVICE_STATE *pd_state, - uint32_t info_count, const VkDeviceQueueCreateInfo *infos) { - bool skip = false; - - for (uint32_t i = 0; i < info_count; ++i) { - const auto requested_queue_family = infos[i].queueFamilyIndex; - - // Verify that requested queue family is known to be valid at this point in time - std::string queue_family_var_name = "pCreateInfo->pQueueCreateInfos[" + std::to_string(i) + "].queueFamilyIndex"; - skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, requested_queue_family, VALIDATION_ERROR_06c002fa, - "vkCreateDevice", queue_family_var_name.c_str()); - - // Verify that requested queue count of queue family is known to be valid at this point in time - if (requested_queue_family < pd_state->queue_family_count) { - const auto requested_queue_count = infos[i].queueCount; - const auto queue_family_props_count = pd_state->queue_family_properties.size(); - const bool queue_family_has_props = requested_queue_family < queue_family_props_count; - const char *conditional_ext_cmd = instance_data->extensions.vk_khr_get_physical_device_properties_2 - ? "or vkGetPhysicalDeviceQueueFamilyProperties2[KHR]" - : ""; - std::string count_note = - !queue_family_has_props - ? "the pQueueFamilyProperties[" + std::to_string(requested_queue_family) + "] was never obtained" - : "i.e. is not less than or equal to " + - std::to_string(pd_state->queue_family_properties[requested_queue_family].queueCount); - - if (!queue_family_has_props || - requested_queue_count > pd_state->queue_family_properties[requested_queue_family].queueCount) { - skip |= log_msg( - instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - HandleToUint64(pd_state->phys_device), VALIDATION_ERROR_06c002fc, - "vkCreateDevice: pCreateInfo->pQueueCreateInfos[%" PRIu32 "].queueCount (=%" PRIu32 - ") is not less than or equal to available queue count for this pCreateInfo->pQueueCreateInfos[%" PRIu32 - "].queueFamilyIndex} (=%" PRIu32 ") obtained previously from vkGetPhysicalDeviceQueueFamilyProperties%s (%s).", - i, requested_queue_count, i, requested_queue_family, conditional_ext_cmd, count_note.c_str()); - } - } - } - - return skip; -} - -// Verify that features have been queried and that they are available -static bool ValidateRequestedFeatures(instance_layer_data *instance_data, const PHYSICAL_DEVICE_STATE *pd_state, - const VkPhysicalDeviceFeatures *requested_features) { - bool skip = false; - - const VkBool32 *actual = reinterpret_cast(&pd_state->features2.features.robustBufferAccess); - const VkBool32 *requested = reinterpret_cast(requested_features); - // TODO : This is a nice, compact way to loop through struct, but a bad way to report issues - // Need to provide the struct member name with the issue. To do that seems like we'll - // have to loop through each struct member which should be done w/ codegen to keep in synch. - uint32_t errors = 0; - uint32_t total_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); - for (uint32_t i = 0; i < total_bools; i++) { - if (requested[i] > actual[i]) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, DEVLIMITS_INVALID_FEATURE_REQUESTED, - "While calling vkCreateDevice(), requesting feature '%s' in VkPhysicalDeviceFeatures struct, which is " - "not available on this device.", - GetPhysDevFeatureString(i)); - errors++; - } - } - if (errors && (UNCALLED == pd_state->vkGetPhysicalDeviceFeaturesState)) { - // If user didn't request features, notify them that they should - // TODO: Verify this against the spec. I believe this is an invalid use of the API and should return an error - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - 0, DEVLIMITS_INVALID_FEATURE_REQUESTED, - "You requested features that are unavailable on this device. You should first query feature availability " - "by calling vkGetPhysicalDeviceFeatures()."); - } - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(gpu), instance_layer_data_map); - - unique_lock_t lock(global_lock); - auto pd_state = GetPhysicalDeviceState(instance_data, gpu); - - // TODO: object_tracker should perhaps do this instead - // and it does not seem to currently work anyway -- the loader just crashes before this point - if (!GetPhysicalDeviceState(instance_data, gpu)) { - skip |= - log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, - DEVLIMITS_MUST_QUERY_COUNT, "Invalid call to vkCreateDevice() w/o first calling vkEnumeratePhysicalDevices()."); - } - - // Check that any requested features are available - // The enabled features can come from either pEnabledFeatures, or from the pNext chain - // TODO: Validate VALIDATION_ERROR_056002ea here, can't have non-null pEnabledFeatures & GPDF2 in pNext chain - const VkPhysicalDeviceFeatures *enabled_features_found = pCreateInfo->pEnabledFeatures; - if (nullptr == enabled_features_found) { - const auto *features2 = lvl_find_in_chain(pCreateInfo->pNext); - if (features2) { - enabled_features_found = &(features2->features); - } - } - - if (enabled_features_found) { - skip |= ValidateRequestedFeatures(instance_data, pd_state, enabled_features_found); - } - - skip |= - ValidateDeviceQueueCreateInfos(instance_data, pd_state, pCreateInfo->queueCreateInfoCount, pCreateInfo->pQueueCreateInfos); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance_data->instance, "vkCreateDevice"); - if (fpCreateDevice == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - lock.unlock(); - - VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); - if (result != VK_SUCCESS) { - return result; - } - - lock.lock(); - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); - - device_data->instance_data = instance_data; - // Setup device dispatch table - layer_init_device_dispatch_table(*pDevice, &device_data->dispatch_table, fpGetDeviceProcAddr); - device_data->device = *pDevice; - // Save PhysicalDevice handle - device_data->physical_device = gpu; - - device_data->report_data = layer_debug_utils_create_device(instance_data->report_data, *pDevice); - - // Get physical device limits for this device - instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &(device_data->phys_dev_properties.properties)); - - device_data->api_version = device_data->extensions.InitFromDeviceCreateInfo( - &instance_data->extensions, device_data->phys_dev_properties.properties.apiVersion, pCreateInfo); - - uint32_t count; - instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(gpu, &count, nullptr); - device_data->phys_dev_properties.queue_family_properties.resize(count); - instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties( - gpu, &count, &device_data->phys_dev_properties.queue_family_properties[0]); - // TODO: device limits should make sure these are compatible - if (enabled_features_found) { - device_data->enabled_features2.features = *enabled_features_found; - } else { - memset(&device_data->enabled_features2.features, 0, sizeof(VkPhysicalDeviceFeatures)); - } - // Store physical device properties and physical device mem limits into device layer_data structs - instance_data->dispatch_table.GetPhysicalDeviceMemoryProperties(gpu, &device_data->phys_dev_mem_props); - instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &device_data->phys_dev_props); - - if (device_data->extensions.vk_khr_push_descriptor) { - // Get the needed push_descriptor limits - auto push_descriptor_prop = lvl_init_struct(); - auto prop2 = lvl_init_struct(&push_descriptor_prop); - instance_data->dispatch_table.GetPhysicalDeviceProperties2KHR(gpu, &prop2); - device_data->phys_dev_ext_props.max_push_descriptors = push_descriptor_prop.maxPushDescriptors; - } - if (device_data->extensions.vk_ext_descriptor_indexing) { - // Get the needed descriptor_indexing limits - auto descriptor_indexing_props = lvl_init_struct(); - auto prop2 = lvl_init_struct(&descriptor_indexing_props); - instance_data->dispatch_table.GetPhysicalDeviceProperties2KHR(gpu, &prop2); - device_data->phys_dev_ext_props.descriptor_indexing_props = descriptor_indexing_props; - } - - const auto *descriptor_indexing_features = lvl_find_in_chain(pCreateInfo->pNext); - if (descriptor_indexing_features) { - device_data->phys_dev_ext_props.descriptor_indexing_features = *descriptor_indexing_features; - } - - lock.unlock(); - - ValidateLayerOrdering(*pCreateInfo); - - return result; -} - -// prototype -VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { - // TODOSC : Shouldn't need any customization here - dispatch_key key = get_dispatch_key(device); - layer_data *dev_data = GetLayerDataPtr(key, layer_data_map); - // Free all the memory - unique_lock_t lock(global_lock); - dev_data->pipelineMap.clear(); - dev_data->renderPassMap.clear(); - for (auto ii = dev_data->commandBufferMap.begin(); ii != dev_data->commandBufferMap.end(); ++ii) { - delete (*ii).second; - } - dev_data->commandBufferMap.clear(); - // This will also delete all sets in the pool & remove them from setMap - deletePools(dev_data); - // All sets should be removed - assert(dev_data->setMap.empty()); - dev_data->descriptorSetLayoutMap.clear(); - dev_data->imageViewMap.clear(); - dev_data->imageMap.clear(); - dev_data->imageSubresourceMap.clear(); - dev_data->imageLayoutMap.clear(); - dev_data->bufferViewMap.clear(); - dev_data->bufferMap.clear(); - // Queues persist until device is destroyed - dev_data->queueMap.clear(); - // Report any memory leaks - layer_debug_utils_destroy_device(device); - lock.unlock(); - -#if DISPATCH_MAP_DEBUG - fprintf(stderr, "Device: 0x%p, key: 0x%p\n", device, key); -#endif - - dev_data->dispatch_table.DestroyDevice(device, pAllocator); - FreeLayerDataPtr(key, layer_data_map); -} - -static const VkExtensionProperties instance_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}}; - -// For given stage mask, if Geometry shader stage is on w/o GS being enabled, report geo_error_id -// and if Tessellation Control or Evaluation shader stages are on w/o TS being enabled, report tess_error_id -static bool ValidateStageMaskGsTsEnables(layer_data *dev_data, VkPipelineStageFlags stageMask, const char *caller, - UNIQUE_VALIDATION_ERROR_CODE geo_error_id, UNIQUE_VALIDATION_ERROR_CODE tess_error_id) { - bool skip = false; - if (!dev_data->enabled_features2.features.geometryShader && (stageMask & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT)) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, geo_error_id, - "%s call includes a stageMask with VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT bit set when device does not have " - "geometryShader feature enabled.", - caller); - } - if (!dev_data->enabled_features2.features.tessellationShader && - (stageMask & (VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT))) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, tess_error_id, - "%s call includes a stageMask with VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT and/or " - "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT bit(s) set when device does not have " - "tessellationShader feature enabled.", - caller); - } - return skip; -} - -// Loop through bound objects and increment their in_use counts. -static void IncrementBoundObjects(layer_data *dev_data, GLOBAL_CB_NODE const *cb_node) { - for (auto obj : cb_node->object_bindings) { - auto base_obj = GetStateStructPtrFromObject(dev_data, obj); - if (base_obj) { - base_obj->in_use.fetch_add(1); - } - } -} -// Track which resources are in-flight by atomically incrementing their "in_use" count -static void incrementResources(layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - cb_node->submitCount++; - cb_node->in_use.fetch_add(1); - - // First Increment for all "generic" objects bound to cmd buffer, followed by special-case objects below - IncrementBoundObjects(dev_data, cb_node); - // TODO : We should be able to remove the NULL look-up checks from the code below as long as - // all the corresponding cases are verified to cause CB_INVALID state and the CB_INVALID state - // should then be flagged prior to calling this function - for (auto drawDataElement : cb_node->drawData) { - for (auto buffer : drawDataElement.buffers) { - auto buffer_state = GetBufferState(dev_data, buffer); - if (buffer_state) { - buffer_state->in_use.fetch_add(1); - } - } - } - for (auto event : cb_node->writeEventsBeforeWait) { - auto event_state = GetEventNode(dev_data, event); - if (event_state) event_state->write_in_use++; - } -} - -// Note: This function assumes that the global lock is held by the calling thread. -// For the given queue, verify the queue state up to the given seq number. -// Currently the only check is to make sure that if there are events to be waited on prior to -// a QueryReset, make sure that all such events have been signalled. -static bool VerifyQueueStateToSeq(layer_data *dev_data, QUEUE_STATE *initial_queue, uint64_t initial_seq) { - bool skip = false; - - // sequence number we want to validate up to, per queue - std::unordered_map target_seqs{{initial_queue, initial_seq}}; - // sequence number we've completed validation for, per queue - std::unordered_map done_seqs; - std::vector worklist{initial_queue}; - - while (worklist.size()) { - auto queue = worklist.back(); - worklist.pop_back(); - - auto target_seq = target_seqs[queue]; - auto seq = std::max(done_seqs[queue], queue->seq); - auto sub_it = queue->submissions.begin() + int(seq - queue->seq); // seq >= queue->seq - - for (; seq < target_seq; ++sub_it, ++seq) { - for (auto &wait : sub_it->waitSemaphores) { - auto other_queue = GetQueueState(dev_data, wait.queue); - - if (other_queue == queue) continue; // semaphores /always/ point backwards, so no point here. - - auto other_target_seq = std::max(target_seqs[other_queue], wait.seq); - auto other_done_seq = std::max(done_seqs[other_queue], other_queue->seq); - - // if this wait is for another queue, and covers new sequence - // numbers beyond what we've already validated, mark the new - // target seq and (possibly-re)add the queue to the worklist. - if (other_done_seq < other_target_seq) { - target_seqs[other_queue] = other_target_seq; - worklist.push_back(other_queue); - } - } - - for (auto cb : sub_it->cbs) { - auto cb_node = GetCBNode(dev_data, cb); - if (cb_node) { - for (auto queryEventsPair : cb_node->waitedEventsBeforeQueryReset) { - for (auto event : queryEventsPair.second) { - if (dev_data->eventMap[event].needsSignaled) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, DRAWSTATE_INVALID_QUERY, - "Cannot get query results on queryPool 0x%" PRIx64 - " with index %d which was guarded by unsignaled event 0x%" PRIx64 ".", - HandleToUint64(queryEventsPair.first.pool), queryEventsPair.first.index, - HandleToUint64(event)); - } - } - } - } - } - } - - // finally mark the point we've now validated this queue to. - done_seqs[queue] = seq; - } - - return skip; -} - -// When the given fence is retired, verify outstanding queue operations through the point of the fence -static bool VerifyQueueStateToFence(layer_data *dev_data, VkFence fence) { - auto fence_state = GetFenceNode(dev_data, fence); - if (fence_state->scope == kSyncScopeInternal && VK_NULL_HANDLE != fence_state->signaler.first) { - return VerifyQueueStateToSeq(dev_data, GetQueueState(dev_data, fence_state->signaler.first), fence_state->signaler.second); - } - return false; -} - -// Decrement in-use count for objects bound to command buffer -static void DecrementBoundResources(layer_data *dev_data, GLOBAL_CB_NODE const *cb_node) { - BASE_NODE *base_obj = nullptr; - for (auto obj : cb_node->object_bindings) { - base_obj = GetStateStructPtrFromObject(dev_data, obj); - if (base_obj) { - base_obj->in_use.fetch_sub(1); - } - } -} - -static void RetireWorkOnQueue(layer_data *dev_data, QUEUE_STATE *pQueue, uint64_t seq) { - std::unordered_map otherQueueSeqs; - - // Roll this queue forward, one submission at a time. - while (pQueue->seq < seq) { - auto &submission = pQueue->submissions.front(); - - for (auto &wait : submission.waitSemaphores) { - auto pSemaphore = GetSemaphoreNode(dev_data, wait.semaphore); - if (pSemaphore) { - pSemaphore->in_use.fetch_sub(1); - } - auto &lastSeq = otherQueueSeqs[wait.queue]; - lastSeq = std::max(lastSeq, wait.seq); - } - - for (auto &semaphore : submission.signalSemaphores) { - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore) { - pSemaphore->in_use.fetch_sub(1); - } - } - - for (auto &semaphore : submission.externalSemaphores) { - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore) { - pSemaphore->in_use.fetch_sub(1); - } - } - - for (auto cb : submission.cbs) { - auto cb_node = GetCBNode(dev_data, cb); - if (!cb_node) { - continue; - } - // First perform decrement on general case bound objects - DecrementBoundResources(dev_data, cb_node); - for (auto drawDataElement : cb_node->drawData) { - for (auto buffer : drawDataElement.buffers) { - auto buffer_state = GetBufferState(dev_data, buffer); - if (buffer_state) { - buffer_state->in_use.fetch_sub(1); - } - } - } - for (auto event : cb_node->writeEventsBeforeWait) { - auto eventNode = dev_data->eventMap.find(event); - if (eventNode != dev_data->eventMap.end()) { - eventNode->second.write_in_use--; - } - } - for (auto queryStatePair : cb_node->queryToStateMap) { - dev_data->queryToStateMap[queryStatePair.first] = queryStatePair.second; - } - for (auto eventStagePair : cb_node->eventToStageMap) { - dev_data->eventMap[eventStagePair.first].stageMask = eventStagePair.second; - } - - cb_node->in_use.fetch_sub(1); - } - - auto pFence = GetFenceNode(dev_data, submission.fence); - if (pFence && pFence->scope == kSyncScopeInternal) { - pFence->state = FENCE_RETIRED; - } - - pQueue->submissions.pop_front(); - pQueue->seq++; - } - - // Roll other queues forward to the highest seq we saw a wait for - for (auto qs : otherQueueSeqs) { - RetireWorkOnQueue(dev_data, GetQueueState(dev_data, qs.first), qs.second); - } -} - -// Submit a fence to a queue, delimiting previous fences and previous untracked -// work by it. -static void SubmitFence(QUEUE_STATE *pQueue, FENCE_NODE *pFence, uint64_t submitCount) { - pFence->state = FENCE_INFLIGHT; - pFence->signaler.first = pQueue->queue; - pFence->signaler.second = pQueue->seq + pQueue->submissions.size() + submitCount; -} - -static bool validateCommandBufferSimultaneousUse(layer_data *dev_data, GLOBAL_CB_NODE *pCB, int current_submit_count) { - bool skip = false; - if ((pCB->in_use.load() || current_submit_count > 1) && - !(pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - VALIDATION_ERROR_31a0008e, - "Command Buffer 0x%" PRIx64 " is already in use and is not marked for simultaneous use.", - HandleToUint64(pCB->commandBuffer)); - } - return skip; -} - -static bool validateCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, const char *call_source, - int current_submit_count, UNIQUE_VALIDATION_ERROR_CODE vu_id) { - bool skip = false; - if (dev_data->instance_data->disabled.command_buffer_state) return skip; - // Validate ONE_TIME_SUBMIT_BIT CB is not being submitted more than once - if ((cb_state->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) && - (cb_state->submitCount + current_submit_count > 1)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, - "Commandbuffer 0x%" PRIx64 - " was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted 0x%" PRIxLEAST64 - " times.", - HandleToUint64(cb_state->commandBuffer), cb_state->submitCount + current_submit_count); - } - - // Validate that cmd buffers have been updated - switch (cb_state->state) { - case CB_INVALID_INCOMPLETE: - case CB_INVALID_COMPLETE: - skip |= ReportInvalidCommandBuffer(dev_data, cb_state, call_source); - break; - - case CB_NEW: - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)(cb_state->commandBuffer), vu_id, - "Command buffer 0x%" PRIx64 " used in the call to %s is unrecorded and contains no commands.", - HandleToUint64(cb_state->commandBuffer), call_source); - break; - - case CB_RECORDING: - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), DRAWSTATE_NO_END_COMMAND_BUFFER, - "You must call vkEndCommandBuffer() on command buffer 0x%" PRIx64 " before this call to %s!", - HandleToUint64(cb_state->commandBuffer), call_source); - break; - - default: /* recorded */ - break; - } - return skip; -} - -static bool validateResources(layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - bool skip = false; - - // TODO : We should be able to remove the NULL look-up checks from the code below as long as - // all the corresponding cases are verified to cause CB_INVALID state and the CB_INVALID state - // should then be flagged prior to calling this function - for (auto drawDataElement : cb_node->drawData) { - for (auto buffer : drawDataElement.buffers) { - auto buffer_state = GetBufferState(dev_data, buffer); - if (buffer != VK_NULL_HANDLE && !buffer_state) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - HandleToUint64(buffer), DRAWSTATE_INVALID_BUFFER, - "Cannot submit cmd buffer using deleted buffer 0x%" PRIx64 ".", HandleToUint64(buffer)); - } - } - } - return skip; -} - -// Check that the queue family index of 'queue' matches one of the entries in pQueueFamilyIndices -bool ValidImageBufferQueue(layer_data *dev_data, GLOBAL_CB_NODE *cb_node, const VK_OBJECT *object, VkQueue queue, uint32_t count, - const uint32_t *indices) { - bool found = false; - bool skip = false; - auto queue_state = GetQueueState(dev_data, queue); - if (queue_state) { - for (uint32_t i = 0; i < count; i++) { - if (indices[i] == queue_state->queueFamilyIndex) { - found = true; - break; - } - } - - if (!found) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[object->type], - object->handle, DRAWSTATE_INVALID_QUEUE_FAMILY, - "vkQueueSubmit: Command buffer 0x%" PRIx64 " contains %s 0x%" PRIx64 - " which was not created allowing concurrent access to this queue family %d.", - HandleToUint64(cb_node->commandBuffer), object_string[object->type], object->handle, - queue_state->queueFamilyIndex); - } - } - return skip; -} - -// Validate that queueFamilyIndices of primary command buffers match this queue -// Secondary command buffers were previously validated in vkCmdExecuteCommands(). -static bool validateQueueFamilyIndices(layer_data *dev_data, GLOBAL_CB_NODE *pCB, VkQueue queue) { - bool skip = false; - auto pPool = GetCommandPoolNode(dev_data, pCB->createInfo.commandPool); - auto queue_state = GetQueueState(dev_data, queue); - - if (pPool && queue_state) { - if (pPool->queueFamilyIndex != queue_state->queueFamilyIndex) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), VALIDATION_ERROR_31a00094, - "vkQueueSubmit: Primary command buffer 0x%" PRIx64 - " created in queue family %d is being submitted on queue 0x%" PRIx64 " from queue family %d.", - HandleToUint64(pCB->commandBuffer), pPool->queueFamilyIndex, HandleToUint64(queue), - queue_state->queueFamilyIndex); - } - - // Ensure that any bound images or buffers created with SHARING_MODE_CONCURRENT have access to the current queue family - for (auto object : pCB->object_bindings) { - if (object.type == kVulkanObjectTypeImage) { - auto image_state = GetImageState(dev_data, reinterpret_cast(object.handle)); - if (image_state && image_state->createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) { - skip |= ValidImageBufferQueue(dev_data, pCB, &object, queue, image_state->createInfo.queueFamilyIndexCount, - image_state->createInfo.pQueueFamilyIndices); - } - } else if (object.type == kVulkanObjectTypeBuffer) { - auto buffer_state = GetBufferState(dev_data, reinterpret_cast(object.handle)); - if (buffer_state && buffer_state->createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) { - skip |= ValidImageBufferQueue(dev_data, pCB, &object, queue, buffer_state->createInfo.queueFamilyIndexCount, - buffer_state->createInfo.pQueueFamilyIndices); - } - } - } - } - - return skip; -} - -static bool validatePrimaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB, int current_submit_count) { - // Track in-use for resources off of primary and any secondary CBs - bool skip = false; - - // If USAGE_SIMULTANEOUS_USE_BIT not set then CB cannot already be executing - // on device - skip |= validateCommandBufferSimultaneousUse(dev_data, pCB, current_submit_count); - - skip |= validateResources(dev_data, pCB); - - for (auto pSubCB : pCB->linkedCommandBuffers) { - skip |= validateResources(dev_data, pSubCB); - // TODO: replace with invalidateCommandBuffers() at recording. - if ((pSubCB->primaryCommandBuffer != pCB->commandBuffer) && - !(pSubCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)) { - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - VALIDATION_ERROR_31a00092, - "Commandbuffer 0x%" PRIx64 " was submitted with secondary buffer 0x%" PRIx64 - " but that buffer has subsequently been bound to primary cmd buffer 0x%" PRIx64 - " and it does not have VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set.", - HandleToUint64(pCB->commandBuffer), HandleToUint64(pSubCB->commandBuffer), - HandleToUint64(pSubCB->primaryCommandBuffer)); - } - } - - skip |= validateCommandBufferState(dev_data, pCB, "vkQueueSubmit()", current_submit_count, VALIDATION_ERROR_31a00090); - - return skip; -} - -static bool ValidateFenceForSubmit(layer_data *dev_data, FENCE_NODE *pFence) { - bool skip = false; - - if (pFence && pFence->scope == kSyncScopeInternal) { - if (pFence->state == FENCE_INFLIGHT) { - // TODO: opportunities for VALIDATION_ERROR_31a00080, VALIDATION_ERROR_316008b4, VALIDATION_ERROR_16400a0e - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(pFence->fence), DRAWSTATE_INVALID_FENCE, - "Fence 0x%" PRIx64 " is already in use by another submission.", HandleToUint64(pFence->fence)); - } - - else if (pFence->state == FENCE_RETIRED) { - // TODO: opportunities for VALIDATION_ERROR_31a0007e, VALIDATION_ERROR_316008b2, VALIDATION_ERROR_16400a0e - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(pFence->fence), MEMTRACK_INVALID_FENCE_STATE, - "Fence 0x%" PRIx64 " submitted in SIGNALED state. Fences must be reset before being submitted", - HandleToUint64(pFence->fence)); - } - } - - return skip; -} - -static void PostCallRecordQueueSubmit(layer_data *dev_data, VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, - VkFence fence) { - uint64_t early_retire_seq = 0; - auto pQueue = GetQueueState(dev_data, queue); - auto pFence = GetFenceNode(dev_data, fence); - - if (pFence) { - if (pFence->scope == kSyncScopeInternal) { - // Mark fence in use - SubmitFence(pQueue, pFence, std::max(1u, submitCount)); - if (!submitCount) { - // If no submissions, but just dropping a fence on the end of the queue, - // record an empty submission with just the fence, so we can determine - // its completion. - pQueue->submissions.emplace_back(std::vector(), std::vector(), - std::vector(), std::vector(), fence); - } - } else { - // Retire work up until this fence early, we will not see the wait that corresponds to this signal - early_retire_seq = pQueue->seq + pQueue->submissions.size(); - if (!dev_data->external_sync_warning) { - dev_data->external_sync_warning = true; - log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(fence), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "vkQueueSubmit(): Signaling external fence 0x%" PRIx64 " on queue 0x%" PRIx64 - " will disable validation of preceding command buffer lifecycle states and the in-use status of associated " - "objects.", - HandleToUint64(fence), HandleToUint64(queue)); - } - } - } - - // Now process each individual submit - for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) { - std::vector cbs; - const VkSubmitInfo *submit = &pSubmits[submit_idx]; - vector semaphore_waits; - vector semaphore_signals; - vector semaphore_externals; - for (uint32_t i = 0; i < submit->waitSemaphoreCount; ++i) { - VkSemaphore semaphore = submit->pWaitSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore) { - if (pSemaphore->scope == kSyncScopeInternal) { - if (pSemaphore->signaler.first != VK_NULL_HANDLE) { - semaphore_waits.push_back({semaphore, pSemaphore->signaler.first, pSemaphore->signaler.second}); - pSemaphore->in_use.fetch_add(1); - } - pSemaphore->signaler.first = VK_NULL_HANDLE; - pSemaphore->signaled = false; - } else { - semaphore_externals.push_back(semaphore); - pSemaphore->in_use.fetch_add(1); - if (pSemaphore->scope == kSyncScopeExternalTemporary) { - pSemaphore->scope = kSyncScopeInternal; - } - } - } - } - for (uint32_t i = 0; i < submit->signalSemaphoreCount; ++i) { - VkSemaphore semaphore = submit->pSignalSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore) { - if (pSemaphore->scope == kSyncScopeInternal) { - pSemaphore->signaler.first = queue; - pSemaphore->signaler.second = pQueue->seq + pQueue->submissions.size() + 1; - pSemaphore->signaled = true; - pSemaphore->in_use.fetch_add(1); - semaphore_signals.push_back(semaphore); - } else { - // Retire work up until this submit early, we will not see the wait that corresponds to this signal - early_retire_seq = std::max(early_retire_seq, pQueue->seq + pQueue->submissions.size() + 1); - if (!dev_data->external_sync_warning) { - dev_data->external_sync_warning = true; - log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - HandleToUint64(semaphore), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "vkQueueSubmit(): Signaling external semaphore 0x%" PRIx64 " on queue 0x%" PRIx64 - " will disable validation of preceding command buffer lifecycle states and the in-use status of " - "associated objects.", - HandleToUint64(semaphore), HandleToUint64(queue)); - } - } - } - } - for (uint32_t i = 0; i < submit->commandBufferCount; i++) { - auto cb_node = GetCBNode(dev_data, submit->pCommandBuffers[i]); - if (cb_node) { - cbs.push_back(submit->pCommandBuffers[i]); - for (auto secondaryCmdBuffer : cb_node->linkedCommandBuffers) { - cbs.push_back(secondaryCmdBuffer->commandBuffer); - UpdateCmdBufImageLayouts(dev_data, secondaryCmdBuffer); - incrementResources(dev_data, secondaryCmdBuffer); - } - UpdateCmdBufImageLayouts(dev_data, cb_node); - incrementResources(dev_data, cb_node); - } - } - pQueue->submissions.emplace_back(cbs, semaphore_waits, semaphore_signals, semaphore_externals, - submit_idx == submitCount - 1 ? fence : VK_NULL_HANDLE); - } - - if (early_retire_seq) { - RetireWorkOnQueue(dev_data, pQueue, early_retire_seq); - } -} - -static bool PreCallValidateQueueSubmit(layer_data *dev_data, VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, - VkFence fence) { - auto pFence = GetFenceNode(dev_data, fence); - bool skip = ValidateFenceForSubmit(dev_data, pFence); - if (skip) { - return true; - } - - unordered_set signaled_semaphores; - unordered_set unsignaled_semaphores; - unordered_set internal_semaphores; - vector current_cmds; - unordered_map localImageLayoutMap; - // Now verify each individual submit - for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) { - const VkSubmitInfo *submit = &pSubmits[submit_idx]; - for (uint32_t i = 0; i < submit->waitSemaphoreCount; ++i) { - skip |= ValidateStageMaskGsTsEnables(dev_data, submit->pWaitDstStageMask[i], "vkQueueSubmit()", - VALIDATION_ERROR_13c00098, VALIDATION_ERROR_13c0009a); - VkSemaphore semaphore = submit->pWaitSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore && (pSemaphore->scope == kSyncScopeInternal || internal_semaphores.count(semaphore))) { - if (unsignaled_semaphores.count(semaphore) || - (!(signaled_semaphores.count(semaphore)) && !(pSemaphore->signaled))) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - HandleToUint64(semaphore), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "Queue 0x%" PRIx64 " is waiting on semaphore 0x%" PRIx64 " that has no way to be signaled.", - HandleToUint64(queue), HandleToUint64(semaphore)); - } else { - signaled_semaphores.erase(semaphore); - unsignaled_semaphores.insert(semaphore); - } - } - if (pSemaphore && pSemaphore->scope == kSyncScopeExternalTemporary) { - internal_semaphores.insert(semaphore); - } - } - for (uint32_t i = 0; i < submit->signalSemaphoreCount; ++i) { - VkSemaphore semaphore = submit->pSignalSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore && (pSemaphore->scope == kSyncScopeInternal || internal_semaphores.count(semaphore))) { - if (signaled_semaphores.count(semaphore) || (!(unsignaled_semaphores.count(semaphore)) && pSemaphore->signaled)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - HandleToUint64(semaphore), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "Queue 0x%" PRIx64 " is signaling semaphore 0x%" PRIx64 - " that has already been signaled but not waited on by queue 0x%" PRIx64 ".", - HandleToUint64(queue), HandleToUint64(semaphore), HandleToUint64(pSemaphore->signaler.first)); - } else { - unsignaled_semaphores.erase(semaphore); - signaled_semaphores.insert(semaphore); - } - } - } - for (uint32_t i = 0; i < submit->commandBufferCount; i++) { - auto cb_node = GetCBNode(dev_data, submit->pCommandBuffers[i]); - if (cb_node) { - skip |= ValidateCmdBufImageLayouts(dev_data, cb_node, dev_data->imageLayoutMap, localImageLayoutMap); - current_cmds.push_back(submit->pCommandBuffers[i]); - skip |= validatePrimaryCommandBufferState( - dev_data, cb_node, (int)std::count(current_cmds.begin(), current_cmds.end(), submit->pCommandBuffers[i])); - skip |= validateQueueFamilyIndices(dev_data, cb_node, queue); - - // Potential early exit here as bad object state may crash in delayed function calls - if (skip) { - return true; - } - - // Call submit-time functions to validate/update state - for (auto &function : cb_node->queue_submit_functions) { - skip |= function(); - } - for (auto &function : cb_node->eventUpdates) { - skip |= function(queue); - } - for (auto &function : cb_node->queryUpdates) { - skip |= function(queue); - } - } - } - } - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - unique_lock_t lock(global_lock); - - bool skip = PreCallValidateQueueSubmit(dev_data, queue, submitCount, pSubmits, fence); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.QueueSubmit(queue, submitCount, pSubmits, fence); - - lock.lock(); - PostCallRecordQueueSubmit(dev_data, queue, submitCount, pSubmits, fence); - lock.unlock(); - return result; -} - -static bool PreCallValidateAllocateMemory(layer_data *dev_data) { - bool skip = false; - if (dev_data->memObjMap.size() >= dev_data->phys_dev_properties.properties.limits.maxMemoryAllocationCount) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_UNDEFINED, - "Number of currently valid memory objects is not less than the maximum allowed (%u).", - dev_data->phys_dev_properties.properties.limits.maxMemoryAllocationCount); - } - return skip; -} - -static void PostCallRecordAllocateMemory(layer_data *dev_data, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory) { - add_mem_obj_info(dev_data, dev_data->device, *pMemory, pAllocateInfo); - return; -} - -VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, - const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateAllocateMemory(dev_data); - if (!skip) { - lock.unlock(); - result = dev_data->dispatch_table.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); - lock.lock(); - if (VK_SUCCESS == result) { - PostCallRecordAllocateMemory(dev_data, pAllocateInfo, pMemory); - } - } - return result; -} - -// For given obj node, if it is use, flag a validation error and return callback result, else return false -bool ValidateObjectNotInUse(const layer_data *dev_data, BASE_NODE *obj_node, VK_OBJECT obj_struct, const char *caller_name, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - if (dev_data->instance_data->disabled.object_in_use) return false; - bool skip = false; - if (obj_node->in_use.load()) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[obj_struct.type], obj_struct.handle, - error_code, "Cannot call %s on %s 0x%" PRIx64 " that is currently in use by a command buffer.", caller_name, - object_string[obj_struct.type], obj_struct.handle); - } - return skip; -} - -static bool PreCallValidateFreeMemory(layer_data *dev_data, VkDeviceMemory mem, DEVICE_MEM_INFO **mem_info, VK_OBJECT *obj_struct) { - *mem_info = GetMemObjInfo(dev_data, mem); - *obj_struct = {HandleToUint64(mem), kVulkanObjectTypeDeviceMemory}; - if (dev_data->instance_data->disabled.free_memory) return false; - bool skip = false; - if (*mem_info) { - skip |= ValidateObjectNotInUse(dev_data, *mem_info, *obj_struct, "vkFreeMemory", VALIDATION_ERROR_2880054a); - } - return skip; -} - -static void PreCallRecordFreeMemory(layer_data *dev_data, VkDeviceMemory mem, DEVICE_MEM_INFO *mem_info, VK_OBJECT obj_struct) { - // Clear mem binding for any bound objects - for (auto obj : mem_info->obj_bindings) { - log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, get_debug_report_enum[obj.type], obj.handle, - MEMTRACK_FREED_MEM_REF, "VK Object 0x%" PRIx64 " still has a reference to mem obj 0x%" PRIx64, - HandleToUint64(obj.handle), HandleToUint64(mem_info->mem)); - BINDABLE *bindable_state = nullptr; - switch (obj.type) { - case kVulkanObjectTypeImage: - bindable_state = GetImageState(dev_data, reinterpret_cast(obj.handle)); - break; - case kVulkanObjectTypeBuffer: - bindable_state = GetBufferState(dev_data, reinterpret_cast(obj.handle)); - break; - default: - // Should only have buffer or image objects bound to memory - assert(0); - } - - assert(bindable_state); - bindable_state->binding.mem = MEMORY_UNBOUND; - bindable_state->UpdateBoundMemorySet(); - } - // Any bound cmd buffers are now invalid - invalidateCommandBuffers(dev_data, mem_info->cb_bindings, obj_struct); - dev_data->memObjMap.erase(mem); -} - -VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - DEVICE_MEM_INFO *mem_info = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateFreeMemory(dev_data, mem, &mem_info, &obj_struct); - if (!skip) { - if (mem != VK_NULL_HANDLE) { - // Avoid free/alloc race by recording state change before dispatching - PreCallRecordFreeMemory(dev_data, mem, mem_info, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.FreeMemory(device, mem, pAllocator); - } -} - -// Validate that given Map memory range is valid. This means that the memory should not already be mapped, -// and that the size of the map range should be: -// 1. Not zero -// 2. Within the size of the memory allocation -static bool ValidateMapMemRange(layer_data *dev_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) { - bool skip = false; - - if (size == 0) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), MEMTRACK_INVALID_MAP, "VkMapMemory: Attempting to map memory range of size zero"); - } - - auto mem_element = dev_data->memObjMap.find(mem); - if (mem_element != dev_data->memObjMap.end()) { - auto mem_info = mem_element->second.get(); - // It is an application error to call VkMapMemory on an object that is already mapped - if (mem_info->mem_range.size != 0) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), MEMTRACK_INVALID_MAP, - "VkMapMemory: Attempting to map memory on an already-mapped object 0x%" PRIx64, HandleToUint64(mem)); - } - - // Validate that offset + size is within object's allocationSize - if (size == VK_WHOLE_SIZE) { - if (offset >= mem_info->alloc_info.allocationSize) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), MEMTRACK_INVALID_MAP, - "Mapping Memory from 0x%" PRIx64 " to 0x%" PRIx64 - " with size of VK_WHOLE_SIZE oversteps total array size 0x%" PRIx64, - offset, mem_info->alloc_info.allocationSize, mem_info->alloc_info.allocationSize); - } - } else { - if ((offset + size) > mem_info->alloc_info.allocationSize) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), VALIDATION_ERROR_31200552, - "Mapping Memory from 0x%" PRIx64 " to 0x%" PRIx64 " oversteps total array size 0x%" PRIx64 ".", - offset, size + offset, mem_info->alloc_info.allocationSize); - } - } - } - return skip; -} - -static void storeMemRanges(layer_data *dev_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) { - auto mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - mem_info->mem_range.offset = offset; - mem_info->mem_range.size = size; - } -} - -static bool deleteMemRanges(layer_data *dev_data, VkDeviceMemory mem) { - bool skip = false; - auto mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - if (!mem_info->mem_range.size) { - // Valid Usage: memory must currently be mapped - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), VALIDATION_ERROR_33600562, - "Unmapping Memory without memory being mapped: mem obj 0x%" PRIx64 ".", HandleToUint64(mem)); - } - mem_info->mem_range.size = 0; - if (mem_info->shadow_copy) { - free(mem_info->shadow_copy_base); - mem_info->shadow_copy_base = 0; - mem_info->shadow_copy = 0; - } - } - return skip; -} - -// Guard value for pad data -static char NoncoherentMemoryFillValue = 0xb; - -static void initializeAndTrackMemory(layer_data *dev_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, - void **ppData) { - auto mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - mem_info->p_driver_data = *ppData; - uint32_t index = mem_info->alloc_info.memoryTypeIndex; - if (dev_data->phys_dev_mem_props.memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) { - mem_info->shadow_copy = 0; - } else { - if (size == VK_WHOLE_SIZE) { - size = mem_info->alloc_info.allocationSize - offset; - } - mem_info->shadow_pad_size = dev_data->phys_dev_properties.properties.limits.minMemoryMapAlignment; - assert(SafeModulo(mem_info->shadow_pad_size, dev_data->phys_dev_properties.properties.limits.minMemoryMapAlignment) == - 0); - // Ensure start of mapped region reflects hardware alignment constraints - uint64_t map_alignment = dev_data->phys_dev_properties.properties.limits.minMemoryMapAlignment; - - // From spec: (ppData - offset) must be aligned to at least limits::minMemoryMapAlignment. - uint64_t start_offset = offset % map_alignment; - // Data passed to driver will be wrapped by a guardband of data to detect over- or under-writes. - mem_info->shadow_copy_base = - malloc(static_cast(2 * mem_info->shadow_pad_size + size + map_alignment + start_offset)); - - mem_info->shadow_copy = - reinterpret_cast((reinterpret_cast(mem_info->shadow_copy_base) + map_alignment) & - ~(map_alignment - 1)) + - start_offset; - assert(SafeModulo(reinterpret_cast(mem_info->shadow_copy) + mem_info->shadow_pad_size - start_offset, - map_alignment) == 0); - - memset(mem_info->shadow_copy, NoncoherentMemoryFillValue, static_cast(2 * mem_info->shadow_pad_size + size)); - *ppData = static_cast(mem_info->shadow_copy) + mem_info->shadow_pad_size; - } - } -} - -// Verify that state for fence being waited on is appropriate. That is, -// a fence being waited on should not already be signaled and -// it should have been submitted on a queue or during acquire next image -static inline bool verifyWaitFenceState(layer_data *dev_data, VkFence fence, const char *apiCall) { - bool skip = false; - - auto pFence = GetFenceNode(dev_data, fence); - if (pFence && pFence->scope == kSyncScopeInternal) { - if (pFence->state == FENCE_UNSIGNALED) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(fence), MEMTRACK_INVALID_FENCE_STATE, - "%s called for fence 0x%" PRIx64 " which has not been submitted on a Queue or during acquire next image.", - apiCall, HandleToUint64(fence)); - } - } - return skip; -} - -static void RetireFence(layer_data *dev_data, VkFence fence) { - auto pFence = GetFenceNode(dev_data, fence); - if (pFence->scope == kSyncScopeInternal) { - if (pFence->signaler.first != VK_NULL_HANDLE) { - // Fence signaller is a queue -- use this as proof that prior operations on that queue have completed. - RetireWorkOnQueue(dev_data, GetQueueState(dev_data, pFence->signaler.first), pFence->signaler.second); - } else { - // Fence signaller is the WSI. We're not tracking what the WSI op actually /was/ in CV yet, but we need to mark - // the fence as retired. - pFence->state = FENCE_RETIRED; - } - } -} - -static bool PreCallValidateWaitForFences(layer_data *dev_data, uint32_t fence_count, const VkFence *fences) { - if (dev_data->instance_data->disabled.wait_for_fences) return false; - bool skip = false; - for (uint32_t i = 0; i < fence_count; i++) { - skip |= verifyWaitFenceState(dev_data, fences[i], "vkWaitForFences"); - skip |= VerifyQueueStateToFence(dev_data, fences[i]); - } - return skip; -} - -static void PostCallRecordWaitForFences(layer_data *dev_data, uint32_t fence_count, const VkFence *fences, VkBool32 wait_all) { - // When we know that all fences are complete we can clean/remove their CBs - if ((VK_TRUE == wait_all) || (1 == fence_count)) { - for (uint32_t i = 0; i < fence_count; i++) { - RetireFence(dev_data, fences[i]); - } - } - // NOTE : Alternate case not handled here is when some fences have completed. In - // this case for app to guarantee which fences completed it will have to call - // vkGetFenceStatus() at which point we'll clean/remove their CBs if complete. -} - -VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, - uint64_t timeout) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - // Verify fence status of submitted fences - unique_lock_t lock(global_lock); - bool skip = PreCallValidateWaitForFences(dev_data, fenceCount, pFences); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.WaitForFences(device, fenceCount, pFences, waitAll, timeout); - - if (result == VK_SUCCESS) { - lock.lock(); - PostCallRecordWaitForFences(dev_data, fenceCount, pFences, waitAll); - lock.unlock(); - } - return result; -} - -static bool PreCallValidateGetFenceStatus(layer_data *dev_data, VkFence fence) { - if (dev_data->instance_data->disabled.get_fence_state) return false; - return verifyWaitFenceState(dev_data, fence, "vkGetFenceStatus"); -} - -static void PostCallRecordGetFenceStatus(layer_data *dev_data, VkFence fence) { RetireFence(dev_data, fence); } - -VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateGetFenceStatus(dev_data, fence); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.GetFenceStatus(device, fence); - if (result == VK_SUCCESS) { - lock.lock(); - PostCallRecordGetFenceStatus(dev_data, fence); - lock.unlock(); - } - return result; -} - -static void PostCallRecordGetDeviceQueue(layer_data *dev_data, uint32_t q_family_index, VkQueue queue) { - // Add queue to tracking set only if it is new - auto result = dev_data->queues.emplace(queue); - if (result.second == true) { - QUEUE_STATE *queue_state = &dev_data->queueMap[queue]; - queue_state->queue = queue; - queue_state->queueFamilyIndex = q_family_index; - queue_state->seq = 0; - } -} - -VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); - lock_guard_t lock(global_lock); - - PostCallRecordGetDeviceQueue(dev_data, queueFamilyIndex, *pQueue); -} - -VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetDeviceQueue2(device, pQueueInfo, pQueue); - lock_guard_t lock(global_lock); - - if (*pQueue != VK_NULL_HANDLE) { - PostCallRecordGetDeviceQueue(dev_data, pQueueInfo->queueFamilyIndex, *pQueue); - } -} - -static bool PreCallValidateQueueWaitIdle(layer_data *dev_data, VkQueue queue, QUEUE_STATE **queue_state) { - *queue_state = GetQueueState(dev_data, queue); - if (dev_data->instance_data->disabled.queue_wait_idle) return false; - return VerifyQueueStateToSeq(dev_data, *queue_state, (*queue_state)->seq + (*queue_state)->submissions.size()); -} - -static void PostCallRecordQueueWaitIdle(layer_data *dev_data, QUEUE_STATE *queue_state) { - RetireWorkOnQueue(dev_data, queue_state, queue_state->seq + queue_state->submissions.size()); -} - -VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - QUEUE_STATE *queue_state = nullptr; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateQueueWaitIdle(dev_data, queue, &queue_state); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = dev_data->dispatch_table.QueueWaitIdle(queue); - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordQueueWaitIdle(dev_data, queue_state); - lock.unlock(); - } - return result; -} - -static bool PreCallValidateDeviceWaitIdle(layer_data *dev_data) { - if (dev_data->instance_data->disabled.device_wait_idle) return false; - bool skip = false; - for (auto &queue : dev_data->queueMap) { - skip |= VerifyQueueStateToSeq(dev_data, &queue.second, queue.second.seq + queue.second.submissions.size()); - } - return skip; -} - -static void PostCallRecordDeviceWaitIdle(layer_data *dev_data) { - for (auto &queue : dev_data->queueMap) { - RetireWorkOnQueue(dev_data, &queue.second, queue.second.seq + queue.second.submissions.size()); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDeviceWaitIdle(dev_data); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = dev_data->dispatch_table.DeviceWaitIdle(device); - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordDeviceWaitIdle(dev_data); - lock.unlock(); - } - return result; -} - -static bool PreCallValidateDestroyFence(layer_data *dev_data, VkFence fence, FENCE_NODE **fence_node, VK_OBJECT *obj_struct) { - *fence_node = GetFenceNode(dev_data, fence); - *obj_struct = {HandleToUint64(fence), kVulkanObjectTypeFence}; - if (dev_data->instance_data->disabled.destroy_fence) return false; - bool skip = false; - if (*fence_node) { - if ((*fence_node)->scope == kSyncScopeInternal && (*fence_node)->state == FENCE_INFLIGHT) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(fence), VALIDATION_ERROR_24e008c0, "Fence 0x%" PRIx64 " is in use.", HandleToUint64(fence)); - } - } - return skip; -} - -static void PreCallRecordDestroyFence(layer_data *dev_data, VkFence fence) { dev_data->fenceMap.erase(fence); } - -VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - // Common data objects used pre & post call - FENCE_NODE *fence_node = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyFence(dev_data, fence, &fence_node, &obj_struct); - - if (!skip) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyFence(dev_data, fence); - lock.unlock(); - dev_data->dispatch_table.DestroyFence(device, fence, pAllocator); - } -} - -static bool PreCallValidateDestroySemaphore(layer_data *dev_data, VkSemaphore semaphore, SEMAPHORE_NODE **sema_node, - VK_OBJECT *obj_struct) { - *sema_node = GetSemaphoreNode(dev_data, semaphore); - *obj_struct = {HandleToUint64(semaphore), kVulkanObjectTypeSemaphore}; - if (dev_data->instance_data->disabled.destroy_semaphore) return false; - bool skip = false; - if (*sema_node) { - skip |= ValidateObjectNotInUse(dev_data, *sema_node, *obj_struct, "vkDestroySemaphore", VALIDATION_ERROR_268008e2); - } - return skip; -} - -static void PreCallRecordDestroySemaphore(layer_data *dev_data, VkSemaphore sema) { dev_data->semaphoreMap.erase(sema); } - -VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - SEMAPHORE_NODE *sema_node; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroySemaphore(dev_data, semaphore, &sema_node, &obj_struct); - if (!skip) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroySemaphore(dev_data, semaphore); - lock.unlock(); - dev_data->dispatch_table.DestroySemaphore(device, semaphore, pAllocator); - } -} - -static bool PreCallValidateDestroyEvent(layer_data *dev_data, VkEvent event, EVENT_STATE **event_state, VK_OBJECT *obj_struct) { - *event_state = GetEventNode(dev_data, event); - *obj_struct = {HandleToUint64(event), kVulkanObjectTypeEvent}; - if (dev_data->instance_data->disabled.destroy_event) return false; - bool skip = false; - if (*event_state) { - skip |= ValidateObjectNotInUse(dev_data, *event_state, *obj_struct, "vkDestroyEvent", VALIDATION_ERROR_24c008f2); - } - return skip; -} - -static void PreCallRecordDestroyEvent(layer_data *dev_data, VkEvent event, EVENT_STATE *event_state, VK_OBJECT obj_struct) { - invalidateCommandBuffers(dev_data, event_state->cb_bindings, obj_struct); - dev_data->eventMap.erase(event); -} - -VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - EVENT_STATE *event_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyEvent(dev_data, event, &event_state, &obj_struct); - if (!skip) { - if (event != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyEvent(dev_data, event, event_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyEvent(device, event, pAllocator); - } -} - -static bool PreCallValidateDestroyQueryPool(layer_data *dev_data, VkQueryPool query_pool, QUERY_POOL_NODE **qp_state, - VK_OBJECT *obj_struct) { - *qp_state = GetQueryPoolNode(dev_data, query_pool); - *obj_struct = {HandleToUint64(query_pool), kVulkanObjectTypeQueryPool}; - if (dev_data->instance_data->disabled.destroy_query_pool) return false; - bool skip = false; - if (*qp_state) { - skip |= ValidateObjectNotInUse(dev_data, *qp_state, *obj_struct, "vkDestroyQueryPool", VALIDATION_ERROR_26200632); - } - return skip; -} - -static void PreCallRecordDestroyQueryPool(layer_data *dev_data, VkQueryPool query_pool, QUERY_POOL_NODE *qp_state, - VK_OBJECT obj_struct) { - invalidateCommandBuffers(dev_data, qp_state->cb_bindings, obj_struct); - dev_data->queryPoolMap.erase(query_pool); -} - -VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - QUERY_POOL_NODE *qp_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyQueryPool(dev_data, queryPool, &qp_state, &obj_struct); - if (!skip) { - if (queryPool != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyQueryPool(dev_data, queryPool, qp_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyQueryPool(device, queryPool, pAllocator); - } -} -static bool PreCallValidateGetQueryPoolResults(layer_data *dev_data, VkQueryPool query_pool, uint32_t first_query, - uint32_t query_count, VkQueryResultFlags flags, - unordered_map> *queries_in_flight) { - bool skip = false; - auto query_pool_state = dev_data->queryPoolMap.find(query_pool); - if (query_pool_state != dev_data->queryPoolMap.end()) { - if ((query_pool_state->second.createInfo.queryType == VK_QUERY_TYPE_TIMESTAMP) && (flags & VK_QUERY_RESULT_PARTIAL_BIT)) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, - VALIDATION_ERROR_2fa00664, - "QueryPool 0x%" PRIx64 - " was created with a queryType of VK_QUERY_TYPE_TIMESTAMP but flags contains VK_QUERY_RESULT_PARTIAL_BIT.", - HandleToUint64(query_pool)); - } - } - - // TODO: clean this up, it's insanely wasteful. - for (auto cmd_buffer : dev_data->commandBufferMap) { - if (cmd_buffer.second->in_use.load()) { - for (auto query_state_pair : cmd_buffer.second->queryToStateMap) { - (*queries_in_flight)[query_state_pair.first].push_back(cmd_buffer.first); - } - } - } - - if (dev_data->instance_data->disabled.get_query_pool_results) return false; - for (uint32_t i = 0; i < query_count; ++i) { - QueryObject query = {query_pool, first_query + i}; - auto qif_pair = queries_in_flight->find(query); - auto query_state_pair = dev_data->queryToStateMap.find(query); - if (query_state_pair != dev_data->queryToStateMap.end()) { - // Available and in flight - if (qif_pair != queries_in_flight->end()) { - if (query_state_pair->second) { - for (auto cmd_buffer : qif_pair->second) { - auto cb = GetCBNode(dev_data, cmd_buffer); - auto query_event_pair = cb->waitedEventsBeforeQueryReset.find(query); - if (query_event_pair == cb->waitedEventsBeforeQueryReset.end()) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, DRAWSTATE_INVALID_QUERY, - "Cannot get query results on queryPool 0x%" PRIx64 " with index %d which is in flight.", - HandleToUint64(query_pool), first_query + i); - } - } - } - } else if (!query_state_pair->second) { // Unavailable and Not in flight - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, - DRAWSTATE_INVALID_QUERY, - "Cannot get query results on queryPool 0x%" PRIx64 " with index %d which is unavailable.", - HandleToUint64(query_pool), first_query + i); - } - } else { // Uninitialized - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, - DRAWSTATE_INVALID_QUERY, - "Cannot get query results on queryPool 0x%" PRIx64 - " with index %d as data has not been collected for this index.", - HandleToUint64(query_pool), first_query + i); - } - } - return skip; -} - -static void PostCallRecordGetQueryPoolResults(layer_data *dev_data, VkQueryPool query_pool, uint32_t first_query, - uint32_t query_count, - unordered_map> *queries_in_flight) { - for (uint32_t i = 0; i < query_count; ++i) { - QueryObject query = {query_pool, first_query + i}; - auto qif_pair = queries_in_flight->find(query); - auto query_state_pair = dev_data->queryToStateMap.find(query); - if (query_state_pair != dev_data->queryToStateMap.end()) { - // Available and in flight - if (qif_pair != queries_in_flight->end() && query_state_pair != dev_data->queryToStateMap.end() && - query_state_pair->second) { - for (auto cmd_buffer : qif_pair->second) { - auto cb = GetCBNode(dev_data, cmd_buffer); - auto query_event_pair = cb->waitedEventsBeforeQueryReset.find(query); - if (query_event_pair != cb->waitedEventsBeforeQueryReset.end()) { - for (auto event : query_event_pair->second) { - dev_data->eventMap[event].needsSignaled = true; - } - } - } - } - } - } -} - -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) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unordered_map> queries_in_flight; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateGetQueryPoolResults(dev_data, queryPool, firstQuery, queryCount, flags, &queries_in_flight); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = - dev_data->dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); - lock.lock(); - PostCallRecordGetQueryPoolResults(dev_data, queryPool, firstQuery, queryCount, &queries_in_flight); - lock.unlock(); - return result; -} - -// Return true if given ranges intersect, else false -// Prereq : For both ranges, range->end - range->start > 0. This case should have already resulted -// in an error so not checking that here -// pad_ranges bool indicates a linear and non-linear comparison which requires padding -// In the case where padding is required, if an alias is encountered then a validation error is reported and skip -// may be set by the callback function so caller should merge in skip value if padding case is possible. -// This check can be skipped by passing skip_checks=true, for call sites outside the validation path. -static bool rangesIntersect(layer_data const *dev_data, MEMORY_RANGE const *range1, MEMORY_RANGE const *range2, bool *skip, - bool skip_checks) { - *skip = false; - auto r1_start = range1->start; - auto r1_end = range1->end; - auto r2_start = range2->start; - auto r2_end = range2->end; - VkDeviceSize pad_align = 1; - if (range1->linear != range2->linear) { - pad_align = dev_data->phys_dev_properties.properties.limits.bufferImageGranularity; - } - if ((r1_end & ~(pad_align - 1)) < (r2_start & ~(pad_align - 1))) return false; - if ((r1_start & ~(pad_align - 1)) > (r2_end & ~(pad_align - 1))) return false; - - if (!skip_checks && (range1->linear != range2->linear)) { - // In linear vs. non-linear case, warn of aliasing - const char *r1_linear_str = range1->linear ? "Linear" : "Non-linear"; - const char *r1_type_str = range1->image ? "image" : "buffer"; - const char *r2_linear_str = range2->linear ? "linear" : "non-linear"; - const char *r2_type_str = range2->image ? "image" : "buffer"; - auto obj_type = range1->image ? VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT : VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT; - *skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, obj_type, range1->handle, MEMTRACK_INVALID_ALIASING, - "%s %s 0x%" PRIx64 " is aliased with %s %s 0x%" PRIx64 - " which may indicate a bug. For further info refer to the Buffer-Image Granularity section of the Vulkan " - "specification. " - "(https://www.khronos.org/registry/vulkan/specs/1.0-extensions/xhtml/vkspec.html#resources-bufferimagegranularity)", - r1_linear_str, r1_type_str, range1->handle, r2_linear_str, r2_type_str, range2->handle); - } - // Ranges intersect - return true; -} -// Simplified rangesIntersect that calls above function to check range1 for intersection with offset & end addresses -bool rangesIntersect(layer_data const *dev_data, MEMORY_RANGE const *range1, VkDeviceSize offset, VkDeviceSize end) { - // Create a local MEMORY_RANGE struct to wrap offset/size - MEMORY_RANGE range_wrap; - // Synch linear with range1 to avoid padding and potential validation error case - range_wrap.linear = range1->linear; - range_wrap.start = offset; - range_wrap.end = end; - bool tmp_bool; - return rangesIntersect(dev_data, range1, &range_wrap, &tmp_bool, true); -} - -static bool ValidateInsertMemoryRange(layer_data const *dev_data, uint64_t handle, DEVICE_MEM_INFO *mem_info, - VkDeviceSize memoryOffset, VkMemoryRequirements memRequirements, bool is_image, - bool is_linear, const char *api_name) { - bool skip = false; - - MEMORY_RANGE range; - range.image = is_image; - range.handle = handle; - range.linear = is_linear; - range.memory = mem_info->mem; - range.start = memoryOffset; - range.size = memRequirements.size; - range.end = memoryOffset + memRequirements.size - 1; - range.aliases.clear(); - - // Check for aliasing problems. - for (auto &obj_range_pair : mem_info->bound_ranges) { - auto check_range = &obj_range_pair.second; - bool intersection_error = false; - if (rangesIntersect(dev_data, &range, check_range, &intersection_error, false)) { - skip |= intersection_error; - range.aliases.insert(check_range); - } - } - - if (memoryOffset >= mem_info->alloc_info.allocationSize) { - UNIQUE_VALIDATION_ERROR_CODE error_code = is_image ? VALIDATION_ERROR_1740082c : VALIDATION_ERROR_1700080e; - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem_info->mem), error_code, - "In %s, attempting to bind memory (0x%" PRIx64 ") to object (0x%" PRIx64 "), memoryOffset=0x%" PRIxLEAST64 - " must be less than the memory allocation size 0x%" PRIxLEAST64 ".", - api_name, HandleToUint64(mem_info->mem), HandleToUint64(handle), memoryOffset, - mem_info->alloc_info.allocationSize); - } - - return skip; -} - -// Object with given handle is being bound to memory w/ given mem_info struct. -// Track the newly bound memory range with given memoryOffset -// Also scan any previous ranges, track aliased ranges with new range, and flag an error if a linear -// and non-linear range incorrectly overlap. -// Return true if an error is flagged and the user callback returns "true", otherwise false -// is_image indicates an image object, otherwise handle is for a buffer -// is_linear indicates a buffer or linear image -static void InsertMemoryRange(layer_data const *dev_data, uint64_t handle, DEVICE_MEM_INFO *mem_info, VkDeviceSize memoryOffset, - VkMemoryRequirements memRequirements, bool is_image, bool is_linear) { - MEMORY_RANGE range; - - range.image = is_image; - range.handle = handle; - range.linear = is_linear; - range.memory = mem_info->mem; - range.start = memoryOffset; - range.size = memRequirements.size; - range.end = memoryOffset + memRequirements.size - 1; - range.aliases.clear(); - // Update Memory aliasing - // Save aliased ranges so we can copy into final map entry below. Can't do it in loop b/c we don't yet have final ptr. If we - // inserted into map before loop to get the final ptr, then we may enter loop when not needed & we check range against itself - std::unordered_set tmp_alias_ranges; - for (auto &obj_range_pair : mem_info->bound_ranges) { - auto check_range = &obj_range_pair.second; - bool intersection_error = false; - if (rangesIntersect(dev_data, &range, check_range, &intersection_error, true)) { - range.aliases.insert(check_range); - tmp_alias_ranges.insert(check_range); - } - } - mem_info->bound_ranges[handle] = std::move(range); - for (auto tmp_range : tmp_alias_ranges) { - tmp_range->aliases.insert(&mem_info->bound_ranges[handle]); - } - if (is_image) - mem_info->bound_images.insert(handle); - else - mem_info->bound_buffers.insert(handle); -} - -static bool ValidateInsertImageMemoryRange(layer_data const *dev_data, VkImage image, DEVICE_MEM_INFO *mem_info, - VkDeviceSize mem_offset, VkMemoryRequirements mem_reqs, bool is_linear, - const char *api_name) { - return ValidateInsertMemoryRange(dev_data, HandleToUint64(image), mem_info, mem_offset, mem_reqs, true, is_linear, api_name); -} -static void InsertImageMemoryRange(layer_data const *dev_data, VkImage image, DEVICE_MEM_INFO *mem_info, VkDeviceSize mem_offset, - VkMemoryRequirements mem_reqs, bool is_linear) { - InsertMemoryRange(dev_data, HandleToUint64(image), mem_info, mem_offset, mem_reqs, true, is_linear); -} - -static bool ValidateInsertBufferMemoryRange(layer_data const *dev_data, VkBuffer buffer, DEVICE_MEM_INFO *mem_info, - VkDeviceSize mem_offset, VkMemoryRequirements mem_reqs, const char *api_name) { - return ValidateInsertMemoryRange(dev_data, HandleToUint64(buffer), mem_info, mem_offset, mem_reqs, false, true, api_name); -} -static void InsertBufferMemoryRange(layer_data const *dev_data, VkBuffer buffer, DEVICE_MEM_INFO *mem_info, VkDeviceSize mem_offset, - VkMemoryRequirements mem_reqs) { - InsertMemoryRange(dev_data, HandleToUint64(buffer), mem_info, mem_offset, mem_reqs, false, true); -} - -// Remove MEMORY_RANGE struct for give handle from bound_ranges of mem_info -// is_image indicates if handle is for image or buffer -// This function will also remove the handle-to-index mapping from the appropriate -// map and clean up any aliases for range being removed. -static void RemoveMemoryRange(uint64_t handle, DEVICE_MEM_INFO *mem_info, bool is_image) { - auto erase_range = &mem_info->bound_ranges[handle]; - for (auto alias_range : erase_range->aliases) { - alias_range->aliases.erase(erase_range); - } - erase_range->aliases.clear(); - mem_info->bound_ranges.erase(handle); - if (is_image) { - mem_info->bound_images.erase(handle); - } else { - mem_info->bound_buffers.erase(handle); - } -} - -void RemoveBufferMemoryRange(uint64_t handle, DEVICE_MEM_INFO *mem_info) { RemoveMemoryRange(handle, mem_info, false); } - -void RemoveImageMemoryRange(uint64_t handle, DEVICE_MEM_INFO *mem_info) { RemoveMemoryRange(handle, mem_info, true); } - -VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - BUFFER_STATE *buffer_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyBuffer(dev_data, buffer, &buffer_state, &obj_struct); - if (!skip) { - if (buffer != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyBuffer(dev_data, buffer, buffer_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyBuffer(device, buffer, pAllocator); - } -} - -VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - // Common data objects used pre & post call - BUFFER_VIEW_STATE *buffer_view_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - // Validate state before calling down chain, update common data if we'll be calling down chain - bool skip = PreCallValidateDestroyBufferView(dev_data, bufferView, &buffer_view_state, &obj_struct); - if (!skip) { - if (bufferView != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyBufferView(dev_data, bufferView, buffer_view_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyBufferView(device, bufferView, pAllocator); - } -} - -VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - IMAGE_STATE *image_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyImage(dev_data, image, &image_state, &obj_struct); - if (!skip) { - if (image != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyImage(dev_data, image, image_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyImage(device, image, pAllocator); - } -} - -static bool ValidateMemoryTypes(const layer_data *dev_data, const DEVICE_MEM_INFO *mem_info, const uint32_t memory_type_bits, - const char *funcName, UNIQUE_VALIDATION_ERROR_CODE msgCode) { - bool skip = false; - if (((1 << mem_info->alloc_info.memoryTypeIndex) & memory_type_bits) == 0) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem_info->mem), msgCode, - "%s(): MemoryRequirements->memoryTypeBits (0x%X) for this object type are not compatible with the memory " - "type (0x%X) of this memory object 0x%" PRIx64 ".", - funcName, memory_type_bits, mem_info->alloc_info.memoryTypeIndex, HandleToUint64(mem_info->mem)); - } - return skip; -} - -static bool PreCallValidateBindBufferMemory(layer_data *dev_data, VkBuffer buffer, BUFFER_STATE *buffer_state, VkDeviceMemory mem, - VkDeviceSize memoryOffset, const char *api_name) { - bool skip = false; - if (buffer_state) { - unique_lock_t lock(global_lock); - // Track objects tied to memory - uint64_t buffer_handle = HandleToUint64(buffer); - skip = ValidateSetMemBinding(dev_data, mem, buffer_handle, kVulkanObjectTypeBuffer, api_name); - if (!buffer_state->memory_requirements_checked) { - // There's not an explicit requirement in the spec to call vkGetBufferMemoryRequirements() prior to calling - // BindBufferMemory, but it's implied in that memory being bound must conform with VkMemoryRequirements from - // vkGetBufferMemoryRequirements() - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - buffer_handle, DRAWSTATE_INVALID_BUFFER, - "%s: Binding memory to buffer 0x%" PRIx64 - " but vkGetBufferMemoryRequirements() has not been called on that buffer.", - api_name, HandleToUint64(buffer_handle)); - // Make the call for them so we can verify the state - lock.unlock(); - dev_data->dispatch_table.GetBufferMemoryRequirements(dev_data->device, buffer, &buffer_state->requirements); - lock.lock(); - } - - // Validate bound memory range information - const auto mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - skip |= ValidateInsertBufferMemoryRange(dev_data, buffer, mem_info, memoryOffset, buffer_state->requirements, api_name); - skip |= ValidateMemoryTypes(dev_data, mem_info, buffer_state->requirements.memoryTypeBits, api_name, - VALIDATION_ERROR_17000816); - } - - // Validate memory requirements alignment - if (SafeModulo(memoryOffset, buffer_state->requirements.alignment) != 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - buffer_handle, VALIDATION_ERROR_17000818, - "%s: memoryOffset is 0x%" PRIxLEAST64 - " but must be an integer multiple of the VkMemoryRequirements::alignment value 0x%" PRIxLEAST64 - ", returned from a call to vkGetBufferMemoryRequirements with buffer.", - api_name, memoryOffset, buffer_state->requirements.alignment); - } - - if (mem_info) { - // Validate memory requirements size - if (buffer_state->requirements.size > (mem_info->alloc_info.allocationSize - memoryOffset)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - buffer_handle, VALIDATION_ERROR_1700081a, - "%s: memory size minus memoryOffset is 0x%" PRIxLEAST64 - " but must be at least as large as VkMemoryRequirements::size value 0x%" PRIxLEAST64 - ", returned from a call to vkGetBufferMemoryRequirements with buffer.", - api_name, mem_info->alloc_info.allocationSize - memoryOffset, buffer_state->requirements.size); - } - - // Validate dedicated allocation - if (mem_info->is_dedicated && ((mem_info->dedicated_buffer != buffer) || (memoryOffset != 0))) { - // TODO: Add vkBindBufferMemory2KHR error message when added to spec. - auto validation_error = VALIDATION_ERROR_UNDEFINED; - if (strcmp(api_name, "vkBindBufferMemory()") == 0) { - validation_error = VALIDATION_ERROR_17000bc8; - } - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - buffer_handle, validation_error, - "%s: for dedicated memory allocation 0x%" PRIxLEAST64 - ", VkMemoryDedicatedAllocateInfoKHR::buffer 0x%" PRIXLEAST64 " must be equal to buffer 0x%" PRIxLEAST64 - " and memoryOffset 0x%" PRIxLEAST64 " must be zero.", - api_name, HandleToUint64(mem), HandleToUint64(mem_info->dedicated_buffer), buffer_handle, memoryOffset); - } - } - - // Validate device limits alignments - static const VkBufferUsageFlagBits usage_list[3] = { - static_cast(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT), - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT}; - static const char *memory_type[3] = {"texel", "uniform", "storage"}; - static const char *offset_name[3] = {"minTexelBufferOffsetAlignment", "minUniformBufferOffsetAlignment", - "minStorageBufferOffsetAlignment"}; - - // TODO: vk_validation_stats.py cannot abide braces immediately preceding or following a validation error enum - // clang-format off - static const UNIQUE_VALIDATION_ERROR_CODE msgCode[3] = { VALIDATION_ERROR_17000810, VALIDATION_ERROR_17000812, - VALIDATION_ERROR_17000814 }; - // clang-format on - - // Keep this one fresh! - const VkDeviceSize offset_requirement[3] = { - dev_data->phys_dev_properties.properties.limits.minTexelBufferOffsetAlignment, - dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment, - dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment}; - VkBufferUsageFlags usage = dev_data->bufferMap[buffer].get()->createInfo.usage; - - for (int i = 0; i < 3; i++) { - if (usage & usage_list[i]) { - if (SafeModulo(memoryOffset, offset_requirement[i]) != 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - buffer_handle, msgCode[i], - "%s: %s memoryOffset is 0x%" PRIxLEAST64 - " but must be a multiple of device limit %s 0x%" PRIxLEAST64 ".", - api_name, memory_type[i], memoryOffset, offset_name[i], offset_requirement[i]); - } - } - } - } - return skip; -} - -static void PostCallRecordBindBufferMemory(layer_data *dev_data, VkBuffer buffer, BUFFER_STATE *buffer_state, VkDeviceMemory mem, - VkDeviceSize memoryOffset, const char *api_name) { - if (buffer_state) { - unique_lock_t lock(global_lock); - // Track bound memory range information - auto mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - InsertBufferMemoryRange(dev_data, buffer, mem_info, memoryOffset, buffer_state->requirements); - } - - // Track objects tied to memory - uint64_t buffer_handle = HandleToUint64(buffer); - SetMemBinding(dev_data, mem, buffer_state, memoryOffset, buffer_handle, kVulkanObjectTypeBuffer, api_name); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - BUFFER_STATE *buffer_state; - { - unique_lock_t lock(global_lock); - buffer_state = GetBufferState(dev_data, buffer); - } - bool skip = PreCallValidateBindBufferMemory(dev_data, buffer, buffer_state, mem, memoryOffset, "vkBindBufferMemory()"); - if (!skip) { - result = dev_data->dispatch_table.BindBufferMemory(device, buffer, mem, memoryOffset); - if (result == VK_SUCCESS) { - PostCallRecordBindBufferMemory(dev_data, buffer, buffer_state, mem, memoryOffset, "vkBindBufferMemory()"); - } - } - return result; -} - -static bool PreCallValidateBindBufferMemory2(layer_data *dev_data, std::vector *buffer_state, - uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR *pBindInfos) { - { - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < bindInfoCount; i++) { - (*buffer_state)[i] = GetBufferState(dev_data, pBindInfos[i].buffer); - } - } - bool skip = false; - char api_name[64]; - for (uint32_t i = 0; i < bindInfoCount; i++) { - sprintf(api_name, "vkBindBufferMemory2() pBindInfos[%u]", i); - skip |= PreCallValidateBindBufferMemory(dev_data, pBindInfos[i].buffer, (*buffer_state)[i], pBindInfos[i].memory, - pBindInfos[i].memoryOffset, api_name); - } - return skip; -} - -static void PostCallRecordBindBufferMemory2(layer_data *dev_data, const std::vector &buffer_state, - uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR *pBindInfos) { - for (uint32_t i = 0; i < bindInfoCount; i++) { - PostCallRecordBindBufferMemory(dev_data, pBindInfos[i].buffer, buffer_state[i], pBindInfos[i].memory, - pBindInfos[i].memoryOffset, "vkBindBufferMemory2()"); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, - const VkBindBufferMemoryInfoKHR *pBindInfos) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::vector buffer_state(bindInfoCount); - if (!PreCallValidateBindBufferMemory2(dev_data, &buffer_state, bindInfoCount, pBindInfos)) { - result = dev_data->dispatch_table.BindBufferMemory2(device, bindInfoCount, pBindInfos); - if (result == VK_SUCCESS) { - PostCallRecordBindBufferMemory2(dev_data, buffer_state, bindInfoCount, pBindInfos); - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, - const VkBindBufferMemoryInfoKHR *pBindInfos) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::vector buffer_state(bindInfoCount); - if (!PreCallValidateBindBufferMemory2(dev_data, &buffer_state, bindInfoCount, pBindInfos)) { - result = dev_data->dispatch_table.BindBufferMemory2KHR(device, bindInfoCount, pBindInfos); - if (result == VK_SUCCESS) { - PostCallRecordBindBufferMemory2(dev_data, buffer_state, bindInfoCount, pBindInfos); - } - } - return result; -} - -static void PostCallRecordGetBufferMemoryRequirements(layer_data *dev_data, VkBuffer buffer, - VkMemoryRequirements *pMemoryRequirements) { - BUFFER_STATE *buffer_state; - { - unique_lock_t lock(global_lock); - buffer_state = GetBufferState(dev_data, buffer); - } - if (buffer_state) { - buffer_state->requirements = *pMemoryRequirements; - buffer_state->memory_requirements_checked = true; - } -} - -VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, - VkMemoryRequirements *pMemoryRequirements) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); - PostCallRecordGetBufferMemoryRequirements(dev_data, buffer, pMemoryRequirements); -} - -VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR *pInfo, - VkMemoryRequirements2KHR *pMemoryRequirements) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); - PostCallRecordGetBufferMemoryRequirements(dev_data, pInfo->buffer, &pMemoryRequirements->memoryRequirements); -} - -VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR *pInfo, - VkMemoryRequirements2KHR *pMemoryRequirements) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); - PostCallRecordGetBufferMemoryRequirements(dev_data, pInfo->buffer, &pMemoryRequirements->memoryRequirements); -} - -static void PostCallRecordGetImageMemoryRequirements(layer_data *dev_data, VkImage image, - VkMemoryRequirements *pMemoryRequirements) { - IMAGE_STATE *image_state; - { - unique_lock_t lock(global_lock); - image_state = GetImageState(dev_data, image); - } - if (image_state) { - image_state->requirements = *pMemoryRequirements; - image_state->memory_requirements_checked = true; - } -} - -VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements); - PostCallRecordGetImageMemoryRequirements(dev_data, image, pMemoryRequirements); -} - -VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2KHR *pInfo, - VkMemoryRequirements2KHR *pMemoryRequirements) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); - PostCallRecordGetImageMemoryRequirements(dev_data, pInfo->image, &pMemoryRequirements->memoryRequirements); -} - -VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2KHR *pInfo, - VkMemoryRequirements2KHR *pMemoryRequirements) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); - PostCallRecordGetImageMemoryRequirements(dev_data, pInfo->image, &pMemoryRequirements->memoryRequirements); -} - -static void PostCallRecordGetImageSparseMemoryRequirements(IMAGE_STATE *image_state, uint32_t req_count, - VkSparseImageMemoryRequirements *reqs) { - image_state->get_sparse_reqs_called = true; - image_state->sparse_requirements.resize(req_count); - if (reqs) { - std::copy(reqs, reqs + req_count, image_state->sparse_requirements.begin()); - } - for (const auto &req : image_state->sparse_requirements) { - if (req.formatProperties.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT) { - image_state->sparse_metadata_required = true; - } - } -} - -VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements *pSparseMemoryRequirements) { - // TODO : Implement tracking here, just passthrough initially - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, - pSparseMemoryRequirements); - unique_lock_t lock(global_lock); - auto image_state = GetImageState(dev_data, image); - PostCallRecordGetImageSparseMemoryRequirements(image_state, *pSparseMemoryRequirementCount, pSparseMemoryRequirements); -} - -static void PostCallRecordGetImageSparseMemoryRequirements2(IMAGE_STATE *image_state, uint32_t req_count, - VkSparseImageMemoryRequirements2KHR *reqs) { - // reqs is empty, so there is nothing to loop over and read. - if (reqs == nullptr) { - return; - } - std::vector sparse_reqs(req_count); - // Migrate to old struct type for common handling with GetImageSparseMemoryRequirements() - for (uint32_t i = 0; i < req_count; ++i) { - assert(!reqs[i].pNext); // TODO: If an extension is ever added here we need to handle it - sparse_reqs[i] = reqs[i].memoryRequirements; - } - PostCallRecordGetImageSparseMemoryRequirements(image_state, req_count, sparse_reqs.data()); -} - -VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, - uint32_t *pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) { - // TODO : Implement tracking here, just passthrough initially - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, - pSparseMemoryRequirements); - unique_lock_t lock(global_lock); - auto image_state = GetImageState(dev_data, pInfo->image); - PostCallRecordGetImageSparseMemoryRequirements2(image_state, *pSparseMemoryRequirementCount, pSparseMemoryRequirements); -} - -VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device, - const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, - uint32_t *pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) { - // TODO : Implement tracking here, just passthrough initially - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, - pSparseMemoryRequirements); - unique_lock_t lock(global_lock); - auto image_state = GetImageState(dev_data, pInfo->image); - PostCallRecordGetImageSparseMemoryRequirements2(image_state, *pSparseMemoryRequirementCount, pSparseMemoryRequirements); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, - VkImageType type, VkSampleCountFlagBits samples, - VkImageUsageFlags usage, VkImageTiling tiling, - uint32_t *pPropertyCount, - VkSparseImageFormatProperties *pProperties) { - // TODO : Implement this intercept, track sparse image format properties and make sure they are obeyed. - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - instance_data->dispatch_table.GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, - pPropertyCount, pProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, - VkSparseImageFormatProperties2KHR *pProperties) { - // TODO : Implement this intercept, track sparse image format properties and make sure they are obeyed. - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - instance_data->dispatch_table.GetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, - pProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, - VkSparseImageFormatProperties2KHR *pProperties) { - // TODO : Implement this intercept, track sparse image format properties and make sure they are obeyed. - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - instance_data->dispatch_table.GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, - pProperties); -} - -VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - // Common data objects used pre & post call - IMAGE_VIEW_STATE *image_view_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyImageView(dev_data, imageView, &image_view_state, &obj_struct); - if (!skip) { - if (imageView != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyImageView(dev_data, imageView, image_view_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyImageView(device, imageView, pAllocator); - } -} - -VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, - const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - unique_lock_t lock(global_lock); - // Pre-record to avoid Destroy/Create race - dev_data->shaderModuleMap.erase(shaderModule); - lock.unlock(); - - dev_data->dispatch_table.DestroyShaderModule(device, shaderModule, pAllocator); -} - -static bool PreCallValidateDestroyPipeline(layer_data *dev_data, VkPipeline pipeline, PIPELINE_STATE **pipeline_state, - VK_OBJECT *obj_struct) { - *pipeline_state = getPipelineState(dev_data, pipeline); - *obj_struct = {HandleToUint64(pipeline), kVulkanObjectTypePipeline}; - if (dev_data->instance_data->disabled.destroy_pipeline) return false; - bool skip = false; - if (*pipeline_state) { - skip |= ValidateObjectNotInUse(dev_data, *pipeline_state, *obj_struct, "vkDestroyPipeline", VALIDATION_ERROR_25c005fa); - } - return skip; -} - -static void PreCallRecordDestroyPipeline(layer_data *dev_data, VkPipeline pipeline, PIPELINE_STATE *pipeline_state, - VK_OBJECT obj_struct) { - // Any bound cmd buffers are now invalid - invalidateCommandBuffers(dev_data, pipeline_state->cb_bindings, obj_struct); - dev_data->pipelineMap.erase(pipeline); -} - -VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - PIPELINE_STATE *pipeline_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyPipeline(dev_data, pipeline, &pipeline_state, &obj_struct); - if (!skip) { - if (pipeline != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyPipeline(dev_data, pipeline, pipeline_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyPipeline(device, pipeline, pAllocator); - } -} - -VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - // Pre-record to avoid Destroy/Create race - dev_data->pipelineLayoutMap.erase(pipelineLayout); - lock.unlock(); - - dev_data->dispatch_table.DestroyPipelineLayout(device, pipelineLayout, pAllocator); -} - -static bool PreCallValidateDestroySampler(layer_data *dev_data, VkSampler sampler, SAMPLER_STATE **sampler_state, - VK_OBJECT *obj_struct) { - *sampler_state = GetSamplerState(dev_data, sampler); - *obj_struct = {HandleToUint64(sampler), kVulkanObjectTypeSampler}; - if (dev_data->instance_data->disabled.destroy_sampler) return false; - bool skip = false; - if (*sampler_state) { - skip |= ValidateObjectNotInUse(dev_data, *sampler_state, *obj_struct, "vkDestroySampler", VALIDATION_ERROR_26600874); - } - return skip; -} - -static void PreCallRecordDestroySampler(layer_data *dev_data, VkSampler sampler, SAMPLER_STATE *sampler_state, - VK_OBJECT obj_struct) { - // Any bound cmd buffers are now invalid - if (sampler_state) invalidateCommandBuffers(dev_data, sampler_state->cb_bindings, obj_struct); - dev_data->samplerMap.erase(sampler); -} - -VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - SAMPLER_STATE *sampler_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroySampler(dev_data, sampler, &sampler_state, &obj_struct); - if (!skip) { - if (sampler != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroySampler(dev_data, sampler, sampler_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroySampler(device, sampler, pAllocator); - } -} - -static void PreCallRecordDestroyDescriptorSetLayout(layer_data *dev_data, VkDescriptorSetLayout ds_layout) { - auto layout_it = dev_data->descriptorSetLayoutMap.find(ds_layout); - if (layout_it != dev_data->descriptorSetLayoutMap.end()) { - layout_it->second.get()->MarkDestroyed(); - dev_data->descriptorSetLayoutMap.erase(layout_it); - } -} - -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - { - lock_guard_t lock(global_lock); - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyDescriptorSetLayout(dev_data, descriptorSetLayout); - } - dev_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); -} - -static bool PreCallValidateDestroyDescriptorPool(layer_data *dev_data, VkDescriptorPool pool, - DESCRIPTOR_POOL_STATE **desc_pool_state, VK_OBJECT *obj_struct) { - *desc_pool_state = GetDescriptorPoolState(dev_data, pool); - *obj_struct = {HandleToUint64(pool), kVulkanObjectTypeDescriptorPool}; - if (dev_data->instance_data->disabled.destroy_descriptor_pool) return false; - bool skip = false; - if (*desc_pool_state) { - skip |= - ValidateObjectNotInUse(dev_data, *desc_pool_state, *obj_struct, "vkDestroyDescriptorPool", VALIDATION_ERROR_2440025e); - } - return skip; -} - -static void PreCallRecordDestroyDescriptorPool(layer_data *dev_data, VkDescriptorPool descriptorPool, - DESCRIPTOR_POOL_STATE *desc_pool_state, VK_OBJECT obj_struct) { - if (desc_pool_state) { - // Any bound cmd buffers are now invalid - invalidateCommandBuffers(dev_data, desc_pool_state->cb_bindings, obj_struct); - // Free sets that were in this pool - for (auto ds : desc_pool_state->sets) { - freeDescriptorSet(dev_data, ds); - } - dev_data->descriptorPoolMap.erase(descriptorPool); - delete desc_pool_state; - } -} - -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, - const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - DESCRIPTOR_POOL_STATE *desc_pool_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyDescriptorPool(dev_data, descriptorPool, &desc_pool_state, &obj_struct); - if (!skip) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyDescriptorPool(dev_data, descriptorPool, desc_pool_state, obj_struct); - lock.unlock(); - dev_data->dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator); - } -} - -// Verify cmdBuffer in given cb_node is not in global in-flight set, and return skip result -// If this is a secondary command buffer, then make sure its primary is also in-flight -// If primary is not in-flight, then remove secondary from global in-flight set -// This function is only valid at a point when cmdBuffer is being reset or freed -static bool checkCommandBufferInFlight(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const char *action, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - if (cb_node->in_use.load()) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), error_code, - "Attempt to %s command buffer (0x%" PRIx64 ") which is in use.", action, - HandleToUint64(cb_node->commandBuffer)); - } - return skip; -} - -// Iterate over all cmdBuffers in given commandPool and verify that each is not in use -static bool checkCommandBuffersInFlight(layer_data *dev_data, COMMAND_POOL_NODE *pPool, const char *action, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - for (auto cmd_buffer : pPool->commandBuffers) { - skip |= checkCommandBufferInFlight(dev_data, GetCBNode(dev_data, cmd_buffer), action, error_code); - } - return skip; -} - -// Free all command buffers in given list, removing all references/links to them using ResetCommandBufferState -static void FreeCommandBufferStates(layer_data *dev_data, COMMAND_POOL_NODE *pool_state, const uint32_t command_buffer_count, - const VkCommandBuffer *command_buffers) { - for (uint32_t i = 0; i < command_buffer_count; i++) { - auto cb_state = GetCBNode(dev_data, command_buffers[i]); - // Remove references to command buffer's state and delete - if (cb_state) { - // reset prior to delete, removing various references to it. - // TODO: fix this, it's insane. - ResetCommandBufferState(dev_data, cb_state->commandBuffer); - // Remove the cb_state's references from layer_data and COMMAND_POOL_NODE - dev_data->commandBufferMap.erase(cb_state->commandBuffer); - pool_state->commandBuffers.erase(command_buffers[i]); - delete cb_state; - } - } -} - -VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, - const VkCommandBuffer *pCommandBuffers) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - unique_lock_t lock(global_lock); - - for (uint32_t i = 0; i < commandBufferCount; i++) { - auto cb_node = GetCBNode(dev_data, pCommandBuffers[i]); - // Delete CB information structure, and remove from commandBufferMap - if (cb_node) { - skip |= checkCommandBufferInFlight(dev_data, cb_node, "free", VALIDATION_ERROR_2840005e); - } - } - - if (skip) return; - - auto pPool = GetCommandPoolNode(dev_data, commandPool); - FreeCommandBufferStates(dev_data, pPool, commandBufferCount, pCommandBuffers); - lock.unlock(); - - dev_data->dispatch_table.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - VkResult result = dev_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); - - if (VK_SUCCESS == result) { - lock_guard_t lock(global_lock); - dev_data->commandPoolMap[*pCommandPool].createFlags = pCreateInfo->flags; - dev_data->commandPoolMap[*pCommandPool].queueFamilyIndex = pCreateInfo->queueFamilyIndex; - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - if (pCreateInfo && pCreateInfo->queryType == VK_QUERY_TYPE_PIPELINE_STATISTICS) { - if (!dev_data->enabled_features2.features.pipelineStatisticsQuery) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, - VALIDATION_ERROR_11c0062e, - "Query pool with type VK_QUERY_TYPE_PIPELINE_STATISTICS created on a device with " - "VkDeviceCreateInfo.pEnabledFeatures.pipelineStatisticsQuery == VK_FALSE."); - } - } - - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - if (!skip) { - result = dev_data->dispatch_table.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); - } - if (result == VK_SUCCESS) { - lock_guard_t lock(global_lock); - QUERY_POOL_NODE *qp_node = &dev_data->queryPoolMap[*pQueryPool]; - qp_node->createInfo = *pCreateInfo; - } - return result; -} - -static bool PreCallValidateDestroyCommandPool(layer_data *dev_data, VkCommandPool pool) { - COMMAND_POOL_NODE *cp_state = GetCommandPoolNode(dev_data, pool); - if (dev_data->instance_data->disabled.destroy_command_pool) return false; - bool skip = false; - if (cp_state) { - // Verify that command buffers in pool are complete (not in-flight) - skip |= checkCommandBuffersInFlight(dev_data, cp_state, "destroy command pool with", VALIDATION_ERROR_24000052); - } - return skip; -} - -static void PreCallRecordDestroyCommandPool(layer_data *dev_data, VkCommandPool pool) { - COMMAND_POOL_NODE *cp_state = GetCommandPoolNode(dev_data, pool); - // Remove cmdpool from cmdpoolmap, after freeing layer data for the command buffers - // "When a pool is destroyed, all command buffers allocated from the pool are freed." - if (cp_state) { - // Create a vector, as FreeCommandBufferStates deletes from cp_state->commandBuffers during iteration. - std::vector cb_vec{cp_state->commandBuffers.begin(), cp_state->commandBuffers.end()}; - FreeCommandBufferStates(dev_data, cp_state, static_cast(cb_vec.size()), cb_vec.data()); - dev_data->commandPoolMap.erase(pool); - } -} - -// Destroy commandPool along with all of the commandBuffers allocated from that pool -VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyCommandPool(dev_data, commandPool); - if (!skip) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyCommandPool(dev_data, commandPool); - lock.unlock(); - dev_data->dispatch_table.DestroyCommandPool(device, commandPool, pAllocator); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - - unique_lock_t lock(global_lock); - auto pPool = GetCommandPoolNode(dev_data, commandPool); - skip |= checkCommandBuffersInFlight(dev_data, pPool, "reset command pool with", VALIDATION_ERROR_32800050); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.ResetCommandPool(device, commandPool, flags); - - // Reset all of the CBs allocated from this pool - if (VK_SUCCESS == result) { - lock.lock(); - for (auto cmdBuffer : pPool->commandBuffers) { - ResetCommandBufferState(dev_data, cmdBuffer); - } - lock.unlock(); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < fenceCount; ++i) { - auto pFence = GetFenceNode(dev_data, pFences[i]); - if (pFence && pFence->scope == kSyncScopeInternal && pFence->state == FENCE_INFLIGHT) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(pFences[i]), VALIDATION_ERROR_32e008c6, "Fence 0x%" PRIx64 " is in use.", - HandleToUint64(pFences[i])); - } - } - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.ResetFences(device, fenceCount, pFences); - - if (result == VK_SUCCESS) { - lock.lock(); - for (uint32_t i = 0; i < fenceCount; ++i) { - auto pFence = GetFenceNode(dev_data, pFences[i]); - if (pFence) { - if (pFence->scope == kSyncScopeInternal) { - pFence->state = FENCE_UNSIGNALED; - } else if (pFence->scope == kSyncScopeExternalTemporary) { - pFence->scope = kSyncScopeInternal; - } - } - } - lock.unlock(); - } - - return result; -} - -// For given cb_nodes, invalidate them and track object causing invalidation -void invalidateCommandBuffers(const layer_data *dev_data, std::unordered_set const &cb_nodes, VK_OBJECT obj) { - for (auto cb_node : cb_nodes) { - if (cb_node->state == CB_RECORDING) { - log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_COMMAND_BUFFER, - "Invalidating a command buffer that's currently being recorded: 0x%" PRIx64 ".", - HandleToUint64(cb_node->commandBuffer)); - cb_node->state = CB_INVALID_INCOMPLETE; - } else if (cb_node->state == CB_RECORDED) { - cb_node->state = CB_INVALID_COMPLETE; - } - cb_node->broken_bindings.push_back(obj); - - // if secondary, then propagate the invalidation to the primaries that will call us. - if (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_SECONDARY) { - invalidateCommandBuffers(dev_data, cb_node->linkedCommandBuffers, obj); - } - } -} - -static bool PreCallValidateDestroyFramebuffer(layer_data *dev_data, VkFramebuffer framebuffer, - FRAMEBUFFER_STATE **framebuffer_state, VK_OBJECT *obj_struct) { - *framebuffer_state = GetFramebufferState(dev_data, framebuffer); - *obj_struct = {HandleToUint64(framebuffer), kVulkanObjectTypeFramebuffer}; - if (dev_data->instance_data->disabled.destroy_framebuffer) return false; - bool skip = false; - if (*framebuffer_state) { - skip |= - ValidateObjectNotInUse(dev_data, *framebuffer_state, *obj_struct, "vkDestroyFramebuffer", VALIDATION_ERROR_250006f8); - } - return skip; -} - -static void PreCallRecordDestroyFramebuffer(layer_data *dev_data, VkFramebuffer framebuffer, FRAMEBUFFER_STATE *framebuffer_state, - VK_OBJECT obj_struct) { - invalidateCommandBuffers(dev_data, framebuffer_state->cb_bindings, obj_struct); - dev_data->frameBufferMap.erase(framebuffer); -} - -VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - FRAMEBUFFER_STATE *framebuffer_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyFramebuffer(dev_data, framebuffer, &framebuffer_state, &obj_struct); - if (!skip) { - if (framebuffer != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyFramebuffer(dev_data, framebuffer, framebuffer_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyFramebuffer(device, framebuffer, pAllocator); - } -} - -static bool PreCallValidateDestroyRenderPass(layer_data *dev_data, VkRenderPass render_pass, RENDER_PASS_STATE **rp_state, - VK_OBJECT *obj_struct) { - *rp_state = GetRenderPassState(dev_data, render_pass); - *obj_struct = {HandleToUint64(render_pass), kVulkanObjectTypeRenderPass}; - if (dev_data->instance_data->disabled.destroy_renderpass) return false; - bool skip = false; - if (*rp_state) { - skip |= ValidateObjectNotInUse(dev_data, *rp_state, *obj_struct, "vkDestroyRenderPass", VALIDATION_ERROR_264006d2); - } - return skip; -} - -static void PreCallRecordDestroyRenderPass(layer_data *dev_data, VkRenderPass render_pass, RENDER_PASS_STATE *rp_state, - VK_OBJECT obj_struct) { - invalidateCommandBuffers(dev_data, rp_state->cb_bindings, obj_struct); - dev_data->renderPassMap.erase(render_pass); -} - -VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - RENDER_PASS_STATE *rp_state = nullptr; - VK_OBJECT obj_struct; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateDestroyRenderPass(dev_data, renderPass, &rp_state, &obj_struct); - if (!skip) { - if (renderPass != VK_NULL_HANDLE) { - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyRenderPass(dev_data, renderPass, rp_state, obj_struct); - } - lock.unlock(); - dev_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCreateBuffer(dev_data, pCreateInfo); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = dev_data->dispatch_table.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); - - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordCreateBuffer(dev_data, pCreateInfo, pBuffer); - lock.unlock(); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkBufferView *pView) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCreateBufferView(dev_data, pCreateInfo); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = dev_data->dispatch_table.CreateBufferView(device, pCreateInfo, pAllocator, pView); - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordCreateBufferView(dev_data, pCreateInfo, pView); - lock.unlock(); - } - return result; -} - -// Access helper functions for external modules -VkFormatProperties GetFormatProperties(core_validation::layer_data *device_data, VkFormat format) { - VkFormatProperties format_properties; - instance_layer_data *instance_data = - GetLayerDataPtr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map); - instance_data->dispatch_table.GetPhysicalDeviceFormatProperties(device_data->physical_device, format, &format_properties); - return format_properties; -} - -VkResult GetImageFormatProperties(core_validation::layer_data *device_data, const VkImageCreateInfo *image_ci, - VkImageFormatProperties *pImageFormatProperties) { - instance_layer_data *instance_data = - GetLayerDataPtr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map); - return instance_data->dispatch_table.GetPhysicalDeviceImageFormatProperties( - device_data->physical_device, image_ci->format, image_ci->imageType, image_ci->tiling, image_ci->usage, image_ci->flags, - pImageFormatProperties); -} - -const debug_report_data *GetReportData(const core_validation::layer_data *device_data) { return device_data->report_data; } - -const VkPhysicalDeviceProperties *GetPhysicalDeviceProperties(core_validation::layer_data *device_data) { - return &device_data->phys_dev_props; -} - -const CHECK_DISABLED *GetDisables(core_validation::layer_data *device_data) { return &device_data->instance_data->disabled; } - -std::unordered_map> *GetImageMap(core_validation::layer_data *device_data) { - return &device_data->imageMap; -} - -std::unordered_map> *GetImageSubresourceMap(core_validation::layer_data *device_data) { - return &device_data->imageSubresourceMap; -} - -std::unordered_map *GetImageLayoutMap(layer_data *device_data) { - return &device_data->imageLayoutMap; -} - -std::unordered_map const *GetImageLayoutMap(layer_data const *device_data) { - return &device_data->imageLayoutMap; -} - -std::unordered_map> *GetBufferMap(layer_data *device_data) { - return &device_data->bufferMap; -} - -std::unordered_map> *GetBufferViewMap(layer_data *device_data) { - return &device_data->bufferViewMap; -} - -std::unordered_map> *GetImageViewMap(layer_data *device_data) { - return &device_data->imageViewMap; -} - -const PHYS_DEV_PROPERTIES_NODE *GetPhysDevProperties(const layer_data *device_data) { return &device_data->phys_dev_properties; } - -const VkPhysicalDeviceFeatures *GetEnabledFeatures(const layer_data *device_data) { - return &device_data->enabled_features2.features; -} - -const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *GetEnabledDescriptorIndexingFeatures(const layer_data *device_data) { - return &device_data->phys_dev_ext_props.descriptor_indexing_features; -} - -const DeviceExtensions *GetDeviceExtensions(const layer_data *device_data) { return &device_data->extensions; } - -uint32_t GetApiVersion(const layer_data *device_data) { return device_data->api_version; } - -VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkImage *pImage) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = PreCallValidateCreateImage(dev_data, pCreateInfo, pAllocator, pImage); - if (!skip) { - result = dev_data->dispatch_table.CreateImage(device, pCreateInfo, pAllocator, pImage); - } - if (VK_SUCCESS == result) { - lock_guard_t lock(global_lock); - PostCallRecordCreateImage(dev_data, pCreateInfo, pImage); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkImageView *pView) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCreateImageView(dev_data, pCreateInfo); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = dev_data->dispatch_table.CreateImageView(device, pCreateInfo, pAllocator, pView); - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordCreateImageView(dev_data, pCreateInfo, *pView); - lock.unlock(); - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkFence *pFence) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence); - if (VK_SUCCESS == result) { - lock_guard_t lock(global_lock); - auto &fence_node = dev_data->fenceMap[*pFence]; - fence_node.fence = *pFence; - fence_node.createInfo = *pCreateInfo; - fence_node.state = (pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT) ? FENCE_RETIRED : FENCE_UNSIGNALED; - } - return result; -} - -// TODO handle pipeline caches -VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, - const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - // Pre-record to avoid Destroy/Create race (if/when implemented) - dev_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, - void *pData) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, - const VkPipelineCache *pSrcCaches) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); - return result; -} - -// Validation cache: -// CV is the bottommost implementor of this extension. Don't pass calls down. -VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkValidationCacheEXT *pValidationCache) { - *pValidationCache = ValidationCache::Create(pCreateInfo); - return *pValidationCache ? VK_SUCCESS : VK_ERROR_INITIALIZATION_FAILED; -} - -VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, - const VkAllocationCallbacks *pAllocator) { - delete (ValidationCache *)validationCache; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, - void *pData) { - size_t inSize = *pDataSize; - ((ValidationCache *)validationCache)->Write(pDataSize, pData); - return (pData && *pDataSize != inSize) ? VK_INCOMPLETE : VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, - const VkValidationCacheEXT *pSrcCaches) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - auto dst = (ValidationCache *)dstCache; - auto src = (ValidationCache const *const *)pSrcCaches; - VkResult result = VK_SUCCESS; - for (uint32_t i = 0; i < srcCacheCount; i++) { - if (src[i] == dst) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, - 0, VALIDATION_ERROR_3e600c00, - "vkMergeValidationCachesEXT: dstCache (0x%" PRIx64 ") must not appear in pSrcCaches array.", - HandleToUint64(dstCache)); - result = VK_ERROR_VALIDATION_FAILED_EXT; - } - if (!skip) { - dst->Merge(src[i]); - } - } - - return result; -} - -// utility function to set collective state for pipeline -void set_pipeline_state(PIPELINE_STATE *pPipe) { - // If any attachment used by this pipeline has blendEnable, set top-level blendEnable - if (pPipe->graphicsPipelineCI.pColorBlendState) { - for (size_t i = 0; i < pPipe->attachments.size(); ++i) { - if (VK_TRUE == pPipe->attachments[i].blendEnable) { - if (((pPipe->attachments[i].dstAlphaBlendFactor >= VK_BLEND_FACTOR_CONSTANT_COLOR) && - (pPipe->attachments[i].dstAlphaBlendFactor <= VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA)) || - ((pPipe->attachments[i].dstColorBlendFactor >= VK_BLEND_FACTOR_CONSTANT_COLOR) && - (pPipe->attachments[i].dstColorBlendFactor <= VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA)) || - ((pPipe->attachments[i].srcAlphaBlendFactor >= VK_BLEND_FACTOR_CONSTANT_COLOR) && - (pPipe->attachments[i].srcAlphaBlendFactor <= VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA)) || - ((pPipe->attachments[i].srcColorBlendFactor >= VK_BLEND_FACTOR_CONSTANT_COLOR) && - (pPipe->attachments[i].srcColorBlendFactor <= VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA))) { - pPipe->blendConstantsEnabled = true; - } - } - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, - const VkGraphicsPipelineCreateInfo *pCreateInfos, - const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { - // The order of operations here is a little convoluted but gets the job done - // 1. Pipeline create state is first shadowed into PIPELINE_STATE struct - // 2. Create state is then validated (which uses flags setup during shadowing) - // 3. If everything looks good, we'll then create the pipeline and add NODE to pipelineMap - bool skip = false; - vector> pipe_state; - pipe_state.reserve(count); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - uint32_t i = 0; - unique_lock_t lock(global_lock); - - for (i = 0; i < count; i++) { - pipe_state.push_back(std::unique_ptr(new PIPELINE_STATE)); - pipe_state[i]->initGraphicsPipeline(&pCreateInfos[i], GetRenderPassStateSharedPtr(dev_data, pCreateInfos[i].renderPass)); - pipe_state[i]->pipeline_layout = *getPipelineLayout(dev_data, pCreateInfos[i].layout); - } - - for (i = 0; i < count; i++) { - skip |= ValidatePipelineLocked(dev_data, pipe_state, i); - } - - lock.unlock(); - - for (i = 0; i < count; i++) { - skip |= ValidatePipelineUnlocked(dev_data, pipe_state, i); - } - - if (skip) { - for (i = 0; i < count; i++) { - pPipelines[i] = VK_NULL_HANDLE; - } - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - auto result = - dev_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines); - lock.lock(); - for (i = 0; i < count; i++) { - if (pPipelines[i] != VK_NULL_HANDLE) { - pipe_state[i]->pipeline = pPipelines[i]; - dev_data->pipelineMap[pPipelines[i]] = std::move(pipe_state[i]); - } - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, - const VkComputePipelineCreateInfo *pCreateInfos, - const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { - bool skip = false; - - vector> pPipeState; - pPipeState.reserve(count); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - uint32_t i = 0; - unique_lock_t lock(global_lock); - for (i = 0; i < count; i++) { - // Create and initialize internal tracking data structure - pPipeState.push_back(unique_ptr(new PIPELINE_STATE)); - pPipeState[i]->initComputePipeline(&pCreateInfos[i]); - pPipeState[i]->pipeline_layout = *getPipelineLayout(dev_data, pCreateInfos[i].layout); - - // TODO: Add Compute Pipeline Verification - skip |= validate_compute_pipeline(dev_data, pPipeState[i].get()); - } - - if (skip) { - for (i = 0; i < count; i++) { - pPipelines[i] = VK_NULL_HANDLE; - } - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - lock.unlock(); - auto result = - dev_data->dispatch_table.CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines); - lock.lock(); - for (i = 0; i < count; i++) { - if (pPipelines[i] != VK_NULL_HANDLE) { - pPipeState[i]->pipeline = pPipelines[i]; - dev_data->pipelineMap[pPipelines[i]] = std::move(pPipeState[i]); - } - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.CreateSampler(device, pCreateInfo, pAllocator, pSampler); - if (VK_SUCCESS == result) { - lock_guard_t lock(global_lock); - dev_data->samplerMap[*pSampler] = unique_ptr(new SAMPLER_STATE(pSampler, pCreateInfo)); - } - return result; -} - -static bool PreCallValidateCreateDescriptorSetLayout(layer_data *dev_data, const VkDescriptorSetLayoutCreateInfo *create_info) { - if (dev_data->instance_data->disabled.create_descriptor_set_layout) return false; - return cvdescriptorset::DescriptorSetLayout::ValidateCreateInfo( - dev_data->report_data, create_info, dev_data->extensions.vk_khr_push_descriptor, - dev_data->phys_dev_ext_props.max_push_descriptors, dev_data->extensions.vk_ext_descriptor_indexing, - &dev_data->phys_dev_ext_props.descriptor_indexing_features); -} - -static void PostCallRecordCreateDescriptorSetLayout(layer_data *dev_data, const VkDescriptorSetLayoutCreateInfo *create_info, - VkDescriptorSetLayout set_layout) { - dev_data->descriptorSetLayoutMap[set_layout] = std::make_shared(create_info, set_layout); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorSetLayout *pSetLayout) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCreateDescriptorSetLayout(dev_data, pCreateInfo); - if (!skip) { - lock.unlock(); - result = dev_data->dispatch_table.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordCreateDescriptorSetLayout(dev_data, pCreateInfo, *pSetLayout); - } - } - return result; -} - -// Used by CreatePipelineLayout and CmdPushConstants. -// Note that the index argument is optional and only used by CreatePipelineLayout. -static bool validatePushConstantRange(const layer_data *dev_data, const uint32_t offset, const uint32_t size, - const char *caller_name, uint32_t index = 0) { - if (dev_data->instance_data->disabled.push_constant_range) return false; - uint32_t const maxPushConstantsSize = dev_data->phys_dev_properties.properties.limits.maxPushConstantsSize; - bool skip = false; - // Check that offset + size don't exceed the max. - // Prevent arithetic overflow here by avoiding addition and testing in this order. - if ((offset >= maxPushConstantsSize) || (size > maxPushConstantsSize - offset)) { - // This is a pain just to adapt the log message to the caller, but better to sort it out only when there is a problem. - if (0 == strcmp(caller_name, "vkCreatePipelineLayout()")) { - if (offset >= maxPushConstantsSize) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_11a0024c, - "%s call has push constants index %u with offset %u that exceeds this device's maxPushConstantSize of %u.", - caller_name, index, offset, maxPushConstantsSize); - } - if (size > maxPushConstantsSize - offset) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_11a00254, - "%s call has push constants index %u with offset %u and size %u that exceeds this device's " - "maxPushConstantSize of %u.", - caller_name, index, offset, size, maxPushConstantsSize); - } - } else if (0 == strcmp(caller_name, "vkCmdPushConstants()")) { - if (offset >= maxPushConstantsSize) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1bc002e4, - "%s call has push constants index %u with offset %u that exceeds this device's maxPushConstantSize of %u.", - caller_name, index, offset, maxPushConstantsSize); - } - if (size > maxPushConstantsSize - offset) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1bc002e6, - "%s call has push constants index %u with offset %u and size %u that exceeds this device's " - "maxPushConstantSize of %u.", - caller_name, index, offset, size, maxPushConstantsSize); - } - } else { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INTERNAL_ERROR, "%s caller not supported.", caller_name); - } - } - // size needs to be non-zero and a multiple of 4. - if ((size == 0) || ((size & 0x3) != 0)) { - if (0 == strcmp(caller_name, "vkCreatePipelineLayout()")) { - if (size == 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_11a00250, - "%s call has push constants index %u with size %u. Size must be greater than zero.", caller_name, - index, size); - } - if (size & 0x3) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_11a00252, - "%s call has push constants index %u with size %u. Size must be a multiple of 4.", caller_name, - index, size); - } - } else if (0 == strcmp(caller_name, "vkCmdPushConstants()")) { - if (size == 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1bc2c21b, - "%s call has push constants index %u with size %u. Size must be greater than zero.", caller_name, - index, size); - } - if (size & 0x3) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1bc002e2, - "%s call has push constants index %u with size %u. Size must be a multiple of 4.", caller_name, - index, size); - } - } else { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INTERNAL_ERROR, "%s caller not supported.", caller_name); - } - } - // offset needs to be a multiple of 4. - if ((offset & 0x3) != 0) { - if (0 == strcmp(caller_name, "vkCreatePipelineLayout()")) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_11a0024e, - "%s call has push constants index %u with offset %u. Offset must be a multiple of 4.", caller_name, - index, offset); - } else if (0 == strcmp(caller_name, "vkCmdPushConstants()")) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1bc002e0, "%s call has push constants with offset %u. Offset must be a multiple of 4.", - caller_name, offset); - } else { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INTERNAL_ERROR, "%s caller not supported.", caller_name); - } - } - return skip; -} - -enum DSL_DESCRIPTOR_GROUPS { - DSL_TYPE_SAMPLERS = 0, - DSL_TYPE_UNIFORM_BUFFERS, - DSL_TYPE_STORAGE_BUFFERS, - DSL_TYPE_SAMPLED_IMAGES, - DSL_TYPE_STORAGE_IMAGES, - DSL_TYPE_INPUT_ATTACHMENTS, - DSL_NUM_DESCRIPTOR_GROUPS -}; - -// Used by PreCallValiateCreatePipelineLayout. -// Returns an array of size DSL_NUM_DESCRIPTOR_GROUPS of the maximum number of descriptors used in any single pipeline stage -std::valarray GetDescriptorCountMaxPerStage( - const layer_data *dev_data, const std::vector> set_layouts, - bool skip_update_after_bind) { - // Identify active pipeline stages - std::vector stage_flags = {VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, - VK_SHADER_STAGE_COMPUTE_BIT}; - if (dev_data->enabled_features2.features.geometryShader) { - stage_flags.push_back(VK_SHADER_STAGE_GEOMETRY_BIT); - } - if (dev_data->enabled_features2.features.tessellationShader) { - stage_flags.push_back(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT); - stage_flags.push_back(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT); - } - - // Allow iteration over enum values - std::vector dsl_groups = {DSL_TYPE_SAMPLERS, DSL_TYPE_UNIFORM_BUFFERS, DSL_TYPE_STORAGE_BUFFERS, - DSL_TYPE_SAMPLED_IMAGES, DSL_TYPE_STORAGE_IMAGES, DSL_TYPE_INPUT_ATTACHMENTS}; - - // Sum by layouts per stage, then pick max of stages per type - std::valarray max_sum(0U, DSL_NUM_DESCRIPTOR_GROUPS); // max descriptor sum among all pipeline stages - for (auto stage : stage_flags) { - std::valarray stage_sum(0U, DSL_NUM_DESCRIPTOR_GROUPS); // per-stage sums - for (auto dsl : set_layouts) { - if (skip_update_after_bind && - (dsl->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT)) { - continue; - } - - for (uint32_t binding_idx = 0; binding_idx < dsl->GetBindingCount(); binding_idx++) { - const VkDescriptorSetLayoutBinding *binding = dsl->GetDescriptorSetLayoutBindingPtrFromIndex(binding_idx); - if (0 != (stage & binding->stageFlags)) { - switch (binding->descriptorType) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - stage_sum[DSL_TYPE_SAMPLERS] += binding->descriptorCount; - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - stage_sum[DSL_TYPE_UNIFORM_BUFFERS] += binding->descriptorCount; - break; - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - stage_sum[DSL_TYPE_STORAGE_BUFFERS] += binding->descriptorCount; - break; - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - stage_sum[DSL_TYPE_SAMPLED_IMAGES] += binding->descriptorCount; - break; - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - stage_sum[DSL_TYPE_STORAGE_IMAGES] += binding->descriptorCount; - break; - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - stage_sum[DSL_TYPE_SAMPLED_IMAGES] += binding->descriptorCount; - stage_sum[DSL_TYPE_SAMPLERS] += binding->descriptorCount; - break; - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - stage_sum[DSL_TYPE_INPUT_ATTACHMENTS] += binding->descriptorCount; - break; - default: - break; - } - } - } - } - for (auto type : dsl_groups) { - max_sum[type] = std::max(stage_sum[type], max_sum[type]); - } - } - return max_sum; -} - -// Used by PreCallValidateCreatePipelineLayout. -// Returns an array of size VK_DESCRIPTOR_TYPE_RANGE_SIZE of the summed descriptors by type. -// Note: descriptors only count against the limit once even if used by multiple stages. -std::valarray GetDescriptorSum( - const layer_data *dev_data, const std::vector> &set_layouts, - bool skip_update_after_bind) { - std::valarray sum_by_type(0U, VK_DESCRIPTOR_TYPE_RANGE_SIZE); - for (auto dsl : set_layouts) { - if (skip_update_after_bind && (dsl->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT)) { - continue; - } - - for (uint32_t binding_idx = 0; binding_idx < dsl->GetBindingCount(); binding_idx++) { - const VkDescriptorSetLayoutBinding *binding = dsl->GetDescriptorSetLayoutBindingPtrFromIndex(binding_idx); - sum_by_type[binding->descriptorType] += binding->descriptorCount; - } - } - return sum_by_type; -} - -static bool PreCallValiateCreatePipelineLayout(const layer_data *dev_data, const VkPipelineLayoutCreateInfo *pCreateInfo) { - bool skip = false; - - // Validate layout count against device physical limit - if (pCreateInfo->setLayoutCount > dev_data->phys_dev_props.limits.maxBoundDescriptorSets) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe0023c, - "vkCreatePipelineLayout(): setLayoutCount (%d) exceeds physical device maxBoundDescriptorSets limit (%d).", - pCreateInfo->setLayoutCount, dev_data->phys_dev_props.limits.maxBoundDescriptorSets); - } - - // Validate Push Constant ranges - uint32_t i, j; - for (i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) { - skip |= validatePushConstantRange(dev_data, pCreateInfo->pPushConstantRanges[i].offset, - pCreateInfo->pPushConstantRanges[i].size, "vkCreatePipelineLayout()", i); - if (0 == pCreateInfo->pPushConstantRanges[i].stageFlags) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_11a2dc03, "vkCreatePipelineLayout() call has no stageFlags set."); - } - } - - // As of 1.0.28, there is a VU that states that a stage flag cannot appear more than once in the list of push constant ranges. - for (i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) { - for (j = i + 1; j < pCreateInfo->pushConstantRangeCount; ++j) { - if (0 != (pCreateInfo->pPushConstantRanges[i].stageFlags & pCreateInfo->pPushConstantRanges[j].stageFlags)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00248, - "vkCreatePipelineLayout() Duplicate stage flags found in ranges %d and %d.", i, j); - } - } - } - - // Early-out - if (skip) return skip; - - std::vector> set_layouts(pCreateInfo->setLayoutCount, nullptr); - unsigned int push_descriptor_set_count = 0; - { - unique_lock_t lock(global_lock); // Lock while accessing global state - for (i = 0; i < pCreateInfo->setLayoutCount; ++i) { - set_layouts[i] = GetDescriptorSetLayout(dev_data, pCreateInfo->pSetLayouts[i]); - if (set_layouts[i]->IsPushDescriptor()) ++push_descriptor_set_count; - } - } // Unlock - - if (push_descriptor_set_count > 1) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe0024a, "vkCreatePipelineLayout() Multiple push descriptor sets found."); - } - - // Max descriptors by type, within a single pipeline stage - std::valarray max_descriptors_per_stage = GetDescriptorCountMaxPerStage(dev_data, set_layouts, true); - // Samplers - if (max_descriptors_per_stage[DSL_TYPE_SAMPLERS] > dev_data->phys_dev_props.limits.maxPerStageDescriptorSamplers) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe0023e, - "vkCreatePipelineLayout(): max per-stage sampler bindings count (%d) exceeds device " - "maxPerStageDescriptorSamplers limit (%d).", - max_descriptors_per_stage[DSL_TYPE_SAMPLERS], dev_data->phys_dev_props.limits.maxPerStageDescriptorSamplers); - } - - // Uniform buffers - if (max_descriptors_per_stage[DSL_TYPE_UNIFORM_BUFFERS] > dev_data->phys_dev_props.limits.maxPerStageDescriptorUniformBuffers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00240, - "vkCreatePipelineLayout(): max per-stage uniform buffer bindings count (%d) exceeds device " - "maxPerStageDescriptorUniformBuffers limit (%d).", - max_descriptors_per_stage[DSL_TYPE_UNIFORM_BUFFERS], - dev_data->phys_dev_props.limits.maxPerStageDescriptorUniformBuffers); - } - - // Storage buffers - if (max_descriptors_per_stage[DSL_TYPE_STORAGE_BUFFERS] > dev_data->phys_dev_props.limits.maxPerStageDescriptorStorageBuffers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00242, - "vkCreatePipelineLayout(): max per-stage storage buffer bindings count (%d) exceeds device " - "maxPerStageDescriptorStorageBuffers limit (%d).", - max_descriptors_per_stage[DSL_TYPE_STORAGE_BUFFERS], - dev_data->phys_dev_props.limits.maxPerStageDescriptorStorageBuffers); - } - - // Sampled images - if (max_descriptors_per_stage[DSL_TYPE_SAMPLED_IMAGES] > dev_data->phys_dev_props.limits.maxPerStageDescriptorSampledImages) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00244, - "vkCreatePipelineLayout(): max per-stage sampled image bindings count (%d) exceeds device " - "maxPerStageDescriptorSampledImages limit (%d).", - max_descriptors_per_stage[DSL_TYPE_SAMPLED_IMAGES], - dev_data->phys_dev_props.limits.maxPerStageDescriptorSampledImages); - } - - // Storage images - if (max_descriptors_per_stage[DSL_TYPE_STORAGE_IMAGES] > dev_data->phys_dev_props.limits.maxPerStageDescriptorStorageImages) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00246, - "vkCreatePipelineLayout(): max per-stage storage image bindings count (%d) exceeds device " - "maxPerStageDescriptorStorageImages limit (%d).", - max_descriptors_per_stage[DSL_TYPE_STORAGE_IMAGES], - dev_data->phys_dev_props.limits.maxPerStageDescriptorStorageImages); - } - - // Input attachments - if (max_descriptors_per_stage[DSL_TYPE_INPUT_ATTACHMENTS] > - dev_data->phys_dev_props.limits.maxPerStageDescriptorInputAttachments) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d18, - "vkCreatePipelineLayout(): max per-stage input attachment bindings count (%d) exceeds device " - "maxPerStageDescriptorInputAttachments limit (%d).", - max_descriptors_per_stage[DSL_TYPE_INPUT_ATTACHMENTS], - dev_data->phys_dev_props.limits.maxPerStageDescriptorInputAttachments); - } - - // Total descriptors by type - // - std::valarray sum_all_stages = GetDescriptorSum(dev_data, set_layouts, true); - // Samplers - uint32_t sum = sum_all_stages[VK_DESCRIPTOR_TYPE_SAMPLER] + sum_all_stages[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER]; - if (sum > dev_data->phys_dev_props.limits.maxDescriptorSetSamplers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d1a, - "vkCreatePipelineLayout(): sum of sampler bindings among all stages (%d) exceeds device " - "maxDescriptorSetSamplers limit (%d).", - sum, dev_data->phys_dev_props.limits.maxDescriptorSetSamplers); - } - - // Uniform buffers - if (sum_all_stages[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER] > dev_data->phys_dev_props.limits.maxDescriptorSetUniformBuffers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d1c, - "vkCreatePipelineLayout(): sum of uniform buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetUniformBuffers limit (%d).", - sum_all_stages[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER], - dev_data->phys_dev_props.limits.maxDescriptorSetUniformBuffers); - } - - // Dynamic uniform buffers - if (sum_all_stages[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC] > - dev_data->phys_dev_props.limits.maxDescriptorSetUniformBuffersDynamic) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d1e, - "vkCreatePipelineLayout(): sum of dynamic uniform buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetUniformBuffersDynamic limit (%d).", - sum_all_stages[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC], - dev_data->phys_dev_props.limits.maxDescriptorSetUniformBuffersDynamic); - } - - // Storage buffers - if (sum_all_stages[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] > dev_data->phys_dev_props.limits.maxDescriptorSetStorageBuffers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d20, - "vkCreatePipelineLayout(): sum of storage buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetStorageBuffers limit (%d).", - sum_all_stages[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER], - dev_data->phys_dev_props.limits.maxDescriptorSetStorageBuffers); - } - - // Dynamic storage buffers - if (sum_all_stages[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC] > - dev_data->phys_dev_props.limits.maxDescriptorSetStorageBuffersDynamic) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d22, - "vkCreatePipelineLayout(): sum of dynamic storage buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetStorageBuffersDynamic limit (%d).", - sum_all_stages[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC], - dev_data->phys_dev_props.limits.maxDescriptorSetStorageBuffersDynamic); - } - - // Sampled images - sum = sum_all_stages[VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE] + sum_all_stages[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] + - sum_all_stages[VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER]; - if (sum > dev_data->phys_dev_props.limits.maxDescriptorSetSampledImages) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d24, - "vkCreatePipelineLayout(): sum of sampled image bindings among all stages (%d) exceeds device " - "maxDescriptorSetSampledImages limit (%d).", - sum, dev_data->phys_dev_props.limits.maxDescriptorSetSampledImages); - } - - // Storage images - sum = sum_all_stages[VK_DESCRIPTOR_TYPE_STORAGE_IMAGE] + sum_all_stages[VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER]; - if (sum > dev_data->phys_dev_props.limits.maxDescriptorSetStorageImages) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d26, - "vkCreatePipelineLayout(): sum of storage image bindings among all stages (%d) exceeds device " - "maxDescriptorSetStorageImages limit (%d).", - sum, dev_data->phys_dev_props.limits.maxDescriptorSetStorageImages); - } - - // Input attachments - if (sum_all_stages[VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT] > dev_data->phys_dev_props.limits.maxDescriptorSetInputAttachments) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe00d28, - "vkCreatePipelineLayout(): sum of input attachment bindings among all stages (%d) exceeds device " - "maxDescriptorSetInputAttachments limit (%d).", - sum_all_stages[VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT], - dev_data->phys_dev_props.limits.maxDescriptorSetInputAttachments); - } - - if (dev_data->extensions.vk_ext_descriptor_indexing) { - // XXX TODO: replace with correct VU messages - - // Max descriptors by type, within a single pipeline stage - std::valarray max_descriptors_per_stage_update_after_bind = - GetDescriptorCountMaxPerStage(dev_data, set_layouts, false); - // Samplers - if (max_descriptors_per_stage_update_after_bind[DSL_TYPE_SAMPLERS] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindSamplers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe0179c, - "vkCreatePipelineLayout(): max per-stage sampler bindings count (%d) exceeds device " - "maxPerStageDescriptorUpdateAfterBindSamplers limit (%d).", - max_descriptors_per_stage_update_after_bind[DSL_TYPE_SAMPLERS], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindSamplers); - } - - // Uniform buffers - if (max_descriptors_per_stage_update_after_bind[DSL_TYPE_UNIFORM_BUFFERS] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindUniformBuffers) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe0179e, - "vkCreatePipelineLayout(): max per-stage uniform buffer bindings count (%d) exceeds device " - "maxPerStageDescriptorUpdateAfterBindUniformBuffers limit (%d).", - max_descriptors_per_stage_update_after_bind[DSL_TYPE_UNIFORM_BUFFERS], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindUniformBuffers); - } - - // Storage buffers - if (max_descriptors_per_stage_update_after_bind[DSL_TYPE_STORAGE_BUFFERS] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindStorageBuffers) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017a0, - "vkCreatePipelineLayout(): max per-stage storage buffer bindings count (%d) exceeds device " - "maxPerStageDescriptorUpdateAfterBindStorageBuffers limit (%d).", - max_descriptors_per_stage_update_after_bind[DSL_TYPE_STORAGE_BUFFERS], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindStorageBuffers); - } - - // Sampled images - if (max_descriptors_per_stage_update_after_bind[DSL_TYPE_SAMPLED_IMAGES] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindSampledImages) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017a2, - "vkCreatePipelineLayout(): max per-stage sampled image bindings count (%d) exceeds device " - "maxPerStageDescriptorUpdateAfterBindSampledImages limit (%d).", - max_descriptors_per_stage_update_after_bind[DSL_TYPE_SAMPLED_IMAGES], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindSampledImages); - } - - // Storage images - if (max_descriptors_per_stage_update_after_bind[DSL_TYPE_STORAGE_IMAGES] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindStorageImages) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017a4, - "vkCreatePipelineLayout(): max per-stage storage image bindings count (%d) exceeds device " - "maxPerStageDescriptorUpdateAfterBindStorageImages limit (%d).", - max_descriptors_per_stage_update_after_bind[DSL_TYPE_STORAGE_IMAGES], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindStorageImages); - } - - // Input attachments - if (max_descriptors_per_stage_update_after_bind[DSL_TYPE_INPUT_ATTACHMENTS] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindInputAttachments) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017a6, - "vkCreatePipelineLayout(): max per-stage input attachment bindings count (%d) exceeds device " - "maxPerStageDescriptorUpdateAfterBindInputAttachments limit (%d).", - max_descriptors_per_stage_update_after_bind[DSL_TYPE_INPUT_ATTACHMENTS], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxPerStageDescriptorUpdateAfterBindInputAttachments); - } - - // Total descriptors by type, summed across all pipeline stages - // - std::valarray sum_all_stages_update_after_bind = GetDescriptorSum(dev_data, set_layouts, false); - // Samplers - sum = sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_SAMPLER] + - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER]; - if (sum > dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindSamplers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017b8, - "vkCreatePipelineLayout(): sum of sampler bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindSamplers limit (%d).", - sum, dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindSamplers); - } - - // Uniform buffers - if (sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindUniformBuffers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017ba, - "vkCreatePipelineLayout(): sum of uniform buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindUniformBuffers limit (%d).", - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindUniformBuffers); - } - - // Dynamic uniform buffers - if (sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017bc, - "vkCreatePipelineLayout(): sum of dynamic uniform buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic limit (%d).", - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); - } - - // Storage buffers - if (sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindStorageBuffers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017be, - "vkCreatePipelineLayout(): sum of storage buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindStorageBuffers limit (%d).", - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindStorageBuffers); - } - - // Dynamic storage buffers - if (sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017c0, - "vkCreatePipelineLayout(): sum of dynamic storage buffer bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic limit (%d).", - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); - } - - // Sampled images - sum = sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE] + - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] + - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER]; - if (sum > dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindSampledImages) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017c2, - "vkCreatePipelineLayout(): sum of sampled image bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindSampledImages limit (%d).", - sum, dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindSampledImages); - } - - // Storage images - sum = sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_STORAGE_IMAGE] + - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER]; - if (sum > dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindStorageImages) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017c4, - "vkCreatePipelineLayout(): sum of storage image bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindStorageImages limit (%d).", - sum, dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindStorageImages); - } - - // Input attachments - if (sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT] > - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindInputAttachments) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0fe017c6, - "vkCreatePipelineLayout(): sum of input attachment bindings among all stages (%d) exceeds device " - "maxDescriptorSetUpdateAfterBindInputAttachments limit (%d).", - sum_all_stages_update_after_bind[VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT], - dev_data->phys_dev_ext_props.descriptor_indexing_props.maxDescriptorSetUpdateAfterBindInputAttachments); - } - } - return skip; -} - -// For repeatable sorting, not very useful for "memory in range" search -struct PushConstantRangeCompare { - bool operator()(const VkPushConstantRange *lhs, const VkPushConstantRange *rhs) const { - if (lhs->offset == rhs->offset) { - if (lhs->size == rhs->size) { - // The comparison is arbitrary, but avoids false aliasing by comparing all fields. - return lhs->stageFlags < rhs->stageFlags; - } - // If the offsets are the same then sorting by the end of range is useful for validation - return lhs->size < rhs->size; - } - return lhs->offset < rhs->offset; - } -}; - -static PushConstantRangesDict push_constant_ranges_dict; - -PushConstantRangesId get_canonical_id(const VkPipelineLayoutCreateInfo *info) { - if (!info->pPushConstantRanges) { - // Hand back the empty entry (creating as needed)... - return push_constant_ranges_dict.look_up(PushConstantRanges()); - } - - // Sort the input ranges to ensure equivalent ranges map to the same id - std::set sorted; - for (uint32_t i = 0; i < info->pushConstantRangeCount; i++) { - sorted.insert(info->pPushConstantRanges + i); - } - - PushConstantRanges ranges(sorted.size()); - for (const auto range : sorted) { - ranges.emplace_back(*range); - } - return push_constant_ranges_dict.look_up(std::move(ranges)); -} - -// Dictionary of canoncial form of the pipeline set layout of descriptor set layouts -static PipelineLayoutSetLayoutsDict pipeline_layout_set_layouts_dict; - -// Dictionary of canonical form of the "compatible for set" records -static PipelineLayoutCompatDict pipeline_layout_compat_dict; - -static PipelineLayoutCompatId get_canonical_id(const uint32_t set_index, const PushConstantRangesId pcr_id, - const PipelineLayoutSetLayoutsId set_layouts_id) { - return pipeline_layout_compat_dict.look_up(PipelineLayoutCompatDef(set_index, pcr_id, set_layouts_id)); -} - -static void PostCallRecordCreatePipelineLayout(layer_data *dev_data, const VkPipelineLayoutCreateInfo *pCreateInfo, - const VkPipelineLayout *pPipelineLayout) { - unique_lock_t lock(global_lock); // Lock while accessing state - - PIPELINE_LAYOUT_NODE &plNode = dev_data->pipelineLayoutMap[*pPipelineLayout]; - plNode.layout = *pPipelineLayout; - plNode.set_layouts.resize(pCreateInfo->setLayoutCount); - PipelineLayoutSetLayoutsDef set_layouts(pCreateInfo->setLayoutCount); - for (uint32_t i = 0; i < pCreateInfo->setLayoutCount; ++i) { - plNode.set_layouts[i] = GetDescriptorSetLayout(dev_data, pCreateInfo->pSetLayouts[i]); - set_layouts[i] = plNode.set_layouts[i]->get_layout_id(); - } - - // Get canonical form IDs for the "compatible for set" contents - plNode.push_constant_ranges = get_canonical_id(pCreateInfo); - auto set_layouts_id = pipeline_layout_set_layouts_dict.look_up(set_layouts); - plNode.compat_for_set.reserve(pCreateInfo->setLayoutCount); - - // Create table of "compatible for set N" cannonical forms for trivial accept validation - for (uint32_t i = 0; i < pCreateInfo->setLayoutCount; ++i) { - plNode.compat_for_set.emplace_back(get_canonical_id(i, plNode.push_constant_ranges, set_layouts_id)); - } - - // Implicit unlock -}; - -VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - bool skip = PreCallValiateCreatePipelineLayout(dev_data, pCreateInfo); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); - - if (VK_SUCCESS == result) { - PostCallRecordCreatePipelineLayout(dev_data, pCreateInfo, pPipelineLayout); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); - if (VK_SUCCESS == result) { - DESCRIPTOR_POOL_STATE *pNewNode = new DESCRIPTOR_POOL_STATE(*pDescriptorPool, pCreateInfo); - if (NULL == pNewNode) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - HandleToUint64(*pDescriptorPool), DRAWSTATE_OUT_OF_MEMORY, - "Out of memory while attempting to allocate DESCRIPTOR_POOL_STATE in vkCreateDescriptorPool()")) - return VK_ERROR_VALIDATION_FAILED_EXT; - } else { - lock_guard_t lock(global_lock); - dev_data->descriptorPoolMap[*pDescriptorPool] = pNewNode; - } - } else { - // Need to do anything if pool create fails? - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - unique_lock_t lock(global_lock); - // Make sure sets being destroyed are not currently in-use - bool skip = validateIdleDescriptorSetForPoolReset(dev_data, descriptorPool); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags); - if (VK_SUCCESS == result) { - lock.lock(); - clearDescriptorPool(dev_data, device, descriptorPool, flags); - lock.unlock(); - } - return result; -} -// Ensure the pool contains enough descriptors and descriptor sets to satisfy -// an allocation request. Fills common_data with the total number of descriptors of each type required, -// as well as DescriptorSetLayout ptrs used for later update. -static bool PreCallValidateAllocateDescriptorSets(layer_data *dev_data, const VkDescriptorSetAllocateInfo *pAllocateInfo, - cvdescriptorset::AllocateDescriptorSetsData *common_data) { - // Always update common data - cvdescriptorset::UpdateAllocateDescriptorSetsData(dev_data, pAllocateInfo, common_data); - if (dev_data->instance_data->disabled.allocate_descriptor_sets) return false; - // All state checks for AllocateDescriptorSets is done in single function - return cvdescriptorset::ValidateAllocateDescriptorSets(dev_data, pAllocateInfo, common_data); -} -// Allocation state was good and call down chain was made so update state based on allocating descriptor sets -static void PostCallRecordAllocateDescriptorSets(layer_data *dev_data, const VkDescriptorSetAllocateInfo *pAllocateInfo, - VkDescriptorSet *pDescriptorSets, - const cvdescriptorset::AllocateDescriptorSetsData *common_data) { - // All the updates are contained in a single cvdescriptorset function - cvdescriptorset::PerformAllocateDescriptorSets(pAllocateInfo, pDescriptorSets, common_data, &dev_data->descriptorPoolMap, - &dev_data->setMap, dev_data); -} - -// TODO: PostCallRecord routine is dependent on data generated in PreCallValidate -- needs to be moved out -VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, - VkDescriptorSet *pDescriptorSets) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - cvdescriptorset::AllocateDescriptorSetsData common_data(pAllocateInfo->descriptorSetCount); - bool skip = PreCallValidateAllocateDescriptorSets(dev_data, pAllocateInfo, &common_data); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); - - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordAllocateDescriptorSets(dev_data, pAllocateInfo, pDescriptorSets, &common_data); - lock.unlock(); - } - return result; -} -// Verify state before freeing DescriptorSets -static bool PreCallValidateFreeDescriptorSets(const layer_data *dev_data, VkDescriptorPool pool, uint32_t count, - const VkDescriptorSet *descriptor_sets) { - if (dev_data->instance_data->disabled.free_descriptor_sets) return false; - bool skip = false; - // First make sure sets being destroyed are not currently in-use - for (uint32_t i = 0; i < count; ++i) { - if (descriptor_sets[i] != VK_NULL_HANDLE) { - skip |= validateIdleDescriptorSet(dev_data, descriptor_sets[i], "vkFreeDescriptorSets"); - } - } - - DESCRIPTOR_POOL_STATE *pool_state = GetDescriptorPoolState(dev_data, pool); - if (pool_state && !(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT & pool_state->createInfo.flags)) { - // Can't Free from a NON_FREE pool - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - HandleToUint64(pool), VALIDATION_ERROR_28600270, - "It is invalid to call vkFreeDescriptorSets() with a pool created without setting " - "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT."); - } - return skip; -} -// Sets are being returned to the pool so update the pool state -static void PreCallRecordFreeDescriptorSets(layer_data *dev_data, VkDescriptorPool pool, uint32_t count, - const VkDescriptorSet *descriptor_sets) { - DESCRIPTOR_POOL_STATE *pool_state = GetDescriptorPoolState(dev_data, pool); - // Update available descriptor sets in pool - pool_state->availableSets += count; - - // For each freed descriptor add its resources back into the pool as available and remove from pool and setMap - for (uint32_t i = 0; i < count; ++i) { - if (descriptor_sets[i] != VK_NULL_HANDLE) { - auto descriptor_set = dev_data->setMap[descriptor_sets[i]]; - uint32_t type_index = 0, descriptor_count = 0; - for (uint32_t j = 0; j < descriptor_set->GetBindingCount(); ++j) { - type_index = static_cast(descriptor_set->GetTypeFromIndex(j)); - descriptor_count = descriptor_set->GetDescriptorCountFromIndex(j); - pool_state->availableDescriptorTypeCount[type_index] += descriptor_count; - } - freeDescriptorSet(dev_data, descriptor_set); - pool_state->sets.erase(descriptor_set); - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, - const VkDescriptorSet *pDescriptorSets) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - // Make sure that no sets being destroyed are in-flight - unique_lock_t lock(global_lock); - bool skip = PreCallValidateFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets); - - VkResult result; - if (skip) { - result = VK_ERROR_VALIDATION_FAILED_EXT; - } else { - // A race here is invalid (descriptorPool should be externally sync'd), but code defensively against an invalid race - PreCallRecordFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets); - lock.unlock(); - result = dev_data->dispatch_table.FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets); - } - return result; -} -// TODO : This is a Proof-of-concept for core validation architecture -// Really we'll want to break out these functions to separate files but -// keeping it all together here to prove out design -// PreCallValidate* handles validating all of the state prior to calling down chain to UpdateDescriptorSets() -static bool PreCallValidateUpdateDescriptorSets(layer_data *dev_data, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, - const VkCopyDescriptorSet *pDescriptorCopies) { - if (dev_data->instance_data->disabled.update_descriptor_sets) return false; - // First thing to do is perform map look-ups. - // NOTE : UpdateDescriptorSets is somewhat unique in that it's operating on a number of DescriptorSets - // so we can't just do a single map look-up up-front, but do them individually in functions below - - // Now make call(s) that validate state, but don't perform state updates in this function - // Note, here DescriptorSets is unique in that we don't yet have an instance. Using a helper function in the - // namespace which will parse params and make calls into specific class instances - return cvdescriptorset::ValidateUpdateDescriptorSets(dev_data->report_data, dev_data, descriptorWriteCount, pDescriptorWrites, - descriptorCopyCount, pDescriptorCopies); -} -// PostCallRecord* handles recording state updates following call down chain to UpdateDescriptorSets() -static void PreCallRecordUpdateDescriptorSets(layer_data *dev_data, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, - const VkCopyDescriptorSet *pDescriptorCopies) { - cvdescriptorset::PerformUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, - pDescriptorCopies); -} - -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, - const VkCopyDescriptorSet *pDescriptorCopies) { - // Only map look-up at top level is for device-level layer_data - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, - pDescriptorCopies); - if (!skip) { - // Since UpdateDescriptorSets() is void, nothing to check prior to updating state & we can update before call down chain - PreCallRecordUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, - pDescriptorCopies); - lock.unlock(); - dev_data->dispatch_table.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, - pDescriptorCopies); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo, - VkCommandBuffer *pCommandBuffer) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer); - if (VK_SUCCESS == result) { - unique_lock_t lock(global_lock); - auto pPool = GetCommandPoolNode(dev_data, pCreateInfo->commandPool); - - if (pPool) { - for (uint32_t i = 0; i < pCreateInfo->commandBufferCount; i++) { - // Add command buffer to its commandPool map - pPool->commandBuffers.insert(pCommandBuffer[i]); - GLOBAL_CB_NODE *pCB = new GLOBAL_CB_NODE; - // Add command buffer to map - dev_data->commandBufferMap[pCommandBuffer[i]] = pCB; - ResetCommandBufferState(dev_data, pCommandBuffer[i]); - pCB->createInfo = *pCreateInfo; - pCB->device = device; - } - } - lock.unlock(); - } - return result; -} - -// Add bindings between the given cmd buffer & framebuffer and the framebuffer's children -static void AddFramebufferBinding(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, FRAMEBUFFER_STATE *fb_state) { - addCommandBufferBinding(&fb_state->cb_bindings, {HandleToUint64(fb_state->framebuffer), kVulkanObjectTypeFramebuffer}, - cb_state); - for (auto attachment : fb_state->attachments) { - auto view_state = attachment.view_state; - if (view_state) { - AddCommandBufferBindingImageView(dev_data, cb_state, view_state); - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - // Validate command buffer level - GLOBAL_CB_NODE *cb_node = GetCBNode(dev_data, commandBuffer); - if (cb_node) { - // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references - if (cb_node->in_use.load()) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_16e00062, - "Calling vkBeginCommandBuffer() on active command buffer %" PRIx64 - " before it has completed. You must check command buffer fence before this call.", - HandleToUint64(commandBuffer)); - } - clear_cmd_buf_and_mem_references(dev_data, cb_node); - if (cb_node->createInfo.level != VK_COMMAND_BUFFER_LEVEL_PRIMARY) { - // Secondary Command Buffer - const VkCommandBufferInheritanceInfo *pInfo = pBeginInfo->pInheritanceInfo; - if (!pInfo) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_16e00066, - "vkBeginCommandBuffer(): Secondary Command Buffer (0x%" PRIx64 ") must have inheritance info.", - HandleToUint64(commandBuffer)); - } else { - if (pBeginInfo->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { - assert(pInfo->renderPass); - string errorString = ""; - auto framebuffer = GetFramebufferState(dev_data, pInfo->framebuffer); - if (framebuffer) { - if (framebuffer->createInfo.renderPass != pInfo->renderPass) { - // renderPass that framebuffer was created with must be compatible with local renderPass - skip |= - validateRenderPassCompatibility(dev_data, "framebuffer", framebuffer->rp_state.get(), - "command buffer", GetRenderPassState(dev_data, pInfo->renderPass), - "vkBeginCommandBuffer()", VALIDATION_ERROR_0280006e); - } - // Connect this framebuffer and its children to this cmdBuffer - AddFramebufferBinding(dev_data, cb_node, framebuffer); - } - } - if ((pInfo->occlusionQueryEnable == VK_FALSE || - dev_data->enabled_features2.features.occlusionQueryPrecise == VK_FALSE) && - (pInfo->queryFlags & VK_QUERY_CONTROL_PRECISE_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer), - VALIDATION_ERROR_16e00068, - "vkBeginCommandBuffer(): Secondary Command Buffer (0x%" PRIx64 - ") must not have VK_QUERY_CONTROL_PRECISE_BIT if occulusionQuery is disabled or the device " - "does not support precise occlusion queries.", - HandleToUint64(commandBuffer)); - } - } - if (pInfo && pInfo->renderPass != VK_NULL_HANDLE) { - auto renderPass = GetRenderPassState(dev_data, pInfo->renderPass); - if (renderPass) { - if (pInfo->subpass >= renderPass->createInfo.subpassCount) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer), - VALIDATION_ERROR_0280006c, - "vkBeginCommandBuffer(): Secondary Command Buffers (0x%" PRIx64 - ") must have a subpass index (%d) that is less than the number of subpasses (%d).", - HandleToUint64(commandBuffer), pInfo->subpass, renderPass->createInfo.subpassCount); - } - } - } - } - if (CB_RECORDING == cb_node->state) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_16e00062, - "vkBeginCommandBuffer(): Cannot call Begin on command buffer (0x%" PRIx64 - ") in the RECORDING state. Must first call vkEndCommandBuffer().", - HandleToUint64(commandBuffer)); - } else if (CB_RECORDED == cb_node->state || CB_INVALID_COMPLETE == cb_node->state) { - VkCommandPool cmdPool = cb_node->createInfo.commandPool; - auto pPool = GetCommandPoolNode(dev_data, cmdPool); - if (!(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT & pPool->createFlags)) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_16e00064, - "Call to vkBeginCommandBuffer() on command buffer (0x%" PRIx64 - ") attempts to implicitly reset cmdBuffer created from command pool (0x%" PRIx64 - ") that does NOT have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT bit set.", - HandleToUint64(commandBuffer), HandleToUint64(cmdPool)); - } - ResetCommandBufferState(dev_data, commandBuffer); - } - // Set updated state here in case implicit reset occurs above - cb_node->state = CB_RECORDING; - cb_node->beginInfo = *pBeginInfo; - if (cb_node->beginInfo.pInheritanceInfo) { - cb_node->inheritanceInfo = *(cb_node->beginInfo.pInheritanceInfo); - cb_node->beginInfo.pInheritanceInfo = &cb_node->inheritanceInfo; - // If we are a secondary command-buffer and inheriting. Update the items we should inherit. - if ((cb_node->createInfo.level != VK_COMMAND_BUFFER_LEVEL_PRIMARY) && - (cb_node->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) { - cb_node->activeRenderPass = GetRenderPassState(dev_data, cb_node->beginInfo.pInheritanceInfo->renderPass); - cb_node->activeSubpass = cb_node->beginInfo.pInheritanceInfo->subpass; - cb_node->activeFramebuffer = cb_node->beginInfo.pInheritanceInfo->framebuffer; - cb_node->framebuffers.insert(cb_node->beginInfo.pInheritanceInfo->framebuffer); - } - } - } - lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = dev_data->dispatch_table.BeginCommandBuffer(commandBuffer, pBeginInfo); - - return result; -} -static void PostCallRecordEndCommandBuffer(layer_data *dev_data, GLOBAL_CB_NODE *cb_state) { - // Cached validation is specific to a specific recording of a specific command buffer. - for (auto descriptor_set : cb_state->validated_descriptor_sets) { - descriptor_set->ClearCachedValidation(cb_state); - } - cb_state->validated_descriptor_sets.clear(); -} - -VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - if ((VK_COMMAND_BUFFER_LEVEL_PRIMARY == pCB->createInfo.level) || - !(pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) { - // This needs spec clarification to update valid usage, see comments in PR: - // https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers/pull/516#discussion_r63013756 - skip |= insideRenderPass(dev_data, pCB, "vkEndCommandBuffer()", VALIDATION_ERROR_27400078); - } - skip |= ValidateCmd(dev_data, pCB, CMD_ENDCOMMANDBUFFER, "vkEndCommandBuffer()"); - for (auto query : pCB->activeQueries) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_2740007a, - "Ending command buffer with in progress query: queryPool 0x%" PRIx64 ", index %d.", - HandleToUint64(query.pool), query.index); - } - } - if (!skip) { - lock.unlock(); - auto result = dev_data->dispatch_table.EndCommandBuffer(commandBuffer); - lock.lock(); - PostCallRecordEndCommandBuffer(dev_data, pCB); - if (VK_SUCCESS == result) { - pCB->state = CB_RECORDED; - } - return result; - } else { - return VK_ERROR_VALIDATION_FAILED_EXT; - } -} - -VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - VkCommandPool cmdPool = pCB->createInfo.commandPool; - auto pPool = GetCommandPoolNode(dev_data, cmdPool); - if (!(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT & pPool->createFlags)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_3260005c, - "Attempt to reset command buffer (0x%" PRIx64 ") created from command pool (0x%" PRIx64 - ") that does NOT have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT bit set.", - HandleToUint64(commandBuffer), HandleToUint64(cmdPool)); - } - skip |= checkCommandBufferInFlight(dev_data, pCB, "reset", VALIDATION_ERROR_3260005a); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = dev_data->dispatch_table.ResetCommandBuffer(commandBuffer, flags); - if (VK_SUCCESS == result) { - lock.lock(); - ResetCommandBufferState(dev_data, commandBuffer); - lock.unlock(); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - if (cb_state) { - skip |= ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdBindPipeline()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_18002415); - skip |= ValidateCmd(dev_data, cb_state, CMD_BINDPIPELINE, "vkCmdBindPipeline()"); - // TODO: VALIDATION_ERROR_18000612 VALIDATION_ERROR_18000616 -- using ValidatePipelineBindPoint - - auto pipe_state = getPipelineState(dev_data, pipeline); - if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) { - cb_state->status &= ~cb_state->static_status; - cb_state->static_status = MakeStaticStateMask(pipe_state->graphicsPipelineCI.ptr()->pDynamicState); - cb_state->status |= cb_state->static_status; - } - cb_state->lastBound[pipelineBindPoint].pipeline_state = pipe_state; - set_pipeline_state(pipe_state); - addCommandBufferBinding(&pipe_state->cb_bindings, {HandleToUint64(pipeline), kVulkanObjectTypePipeline}, cb_state); - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, - const VkViewport *pViewports) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetViewport()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1e002415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETVIEWPORT, "vkCmdSetViewport()"); - if (pCB->static_status & CBSTATUS_VIEWPORT_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1e00098a, - "vkCmdSetViewport(): pipeline was created without VK_DYNAMIC_STATE_VIEWPORT flag.."); - } - if (!skip) { - pCB->viewportMask |= ((1u << viewportCount) - 1u) << firstViewport; - pCB->status |= CBSTATUS_VIEWPORT_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, - const VkRect2D *pScissors) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetScissor()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1d802415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETSCISSOR, "vkCmdSetScissor()"); - if (pCB->static_status & CBSTATUS_SCISSOR_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d80049c, - "vkCmdSetScissor(): pipeline was created without VK_DYNAMIC_STATE_SCISSOR flag.."); - } - if (!skip) { - pCB->scissorMask |= ((1u << scissorCount) - 1u) << firstScissor; - pCB->status |= CBSTATUS_SCISSOR_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetLineWidth()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1d602415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETLINEWIDTH, "vkCmdSetLineWidth()"); - - if (pCB->static_status & CBSTATUS_LINE_WIDTH_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d600626, - "vkCmdSetLineWidth called but pipeline was created without VK_DYNAMIC_STATE_LINE_WIDTH flag."); - } - if (!skip) { - pCB->status |= CBSTATUS_LINE_WIDTH_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetLineWidth(commandBuffer, lineWidth); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, - float depthBiasSlopeFactor) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetDepthBias()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1cc02415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETDEPTHBIAS, "vkCmdSetDepthBias()"); - if (pCB->static_status & CBSTATUS_DEPTH_BIAS_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1cc0062a, - "vkCmdSetDepthBias(): pipeline was created without VK_DYNAMIC_STATE_DEPTH_BIAS flag.."); - } - if ((depthBiasClamp != 0.0) && (!dev_data->enabled_features2.features.depthBiasClamp)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1cc0062c, - "vkCmdSetDepthBias(): the depthBiasClamp device feature is disabled: the depthBiasClamp parameter must " - "be set to 0.0."); - } - if (!skip) { - pCB->status |= CBSTATUS_DEPTH_BIAS_SET; - } - } - lock.unlock(); - if (!skip) - dev_data->dispatch_table.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetBlendConstants()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1ca02415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETBLENDCONSTANTS, "vkCmdSetBlendConstants()"); - if (pCB->static_status & CBSTATUS_BLEND_CONSTANTS_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1ca004c8, - "vkCmdSetBlendConstants(): pipeline was created without VK_DYNAMIC_STATE_BLEND_CONSTANTS flag.."); - } - if (!skip) { - pCB->status |= CBSTATUS_BLEND_CONSTANTS_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetBlendConstants(commandBuffer, blendConstants); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetDepthBounds()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1ce02415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETDEPTHBOUNDS, "vkCmdSetDepthBounds()"); - if (pCB->static_status & CBSTATUS_DEPTH_BOUNDS_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1ce004ae, - "vkCmdSetDepthBounds(): pipeline was created without VK_DYNAMIC_STATE_DEPTH_BOUNDS flag.."); - } - if (!skip) { - pCB->status |= CBSTATUS_DEPTH_BOUNDS_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, - uint32_t compareMask) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= - ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetStencilCompareMask()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1da02415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETSTENCILCOMPAREMASK, "vkCmdSetStencilCompareMask()"); - if (pCB->static_status & CBSTATUS_STENCIL_READ_MASK_SET) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1da004b4, - "vkCmdSetStencilCompareMask(): pipeline was created without VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK flag.."); - } - if (!skip) { - pCB->status |= CBSTATUS_STENCIL_READ_MASK_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= - ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetStencilWriteMask()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1de02415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETSTENCILWRITEMASK, "vkCmdSetStencilWriteMask()"); - if (pCB->static_status & CBSTATUS_STENCIL_WRITE_MASK_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1de004b6, - "vkCmdSetStencilWriteMask(): pipeline was created without VK_DYNAMIC_STATE_STENCIL_WRITE_MASK flag.."); - } - if (!skip) { - pCB->status |= CBSTATUS_STENCIL_WRITE_MASK_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= - ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetStencilReference()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1dc02415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETSTENCILREFERENCE, "vkCmdSetStencilReference()"); - if (pCB->static_status & CBSTATUS_STENCIL_REFERENCE_SET) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1dc004b8, - "vkCmdSetStencilReference(): pipeline was created without VK_DYNAMIC_STATE_STENCIL_REFERENCE flag.."); - } - if (!skip) { - pCB->status |= CBSTATUS_STENCIL_REFERENCE_SET; - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetStencilReference(commandBuffer, faceMask, reference); -} - -// Update pipeline_layout bind points applying the "Pipeline Layout Compatibility" rules -static void UpdateLastBoundDescriptorSets(layer_data *device_data, GLOBAL_CB_NODE *cb_state, - VkPipelineBindPoint pipeline_bind_point, const PIPELINE_LAYOUT_NODE *pipeline_layout, - uint32_t first_set, uint32_t set_count, - const std::vector descriptor_sets, - uint32_t dynamic_offset_count, const uint32_t *p_dynamic_offsets) { - // Defensive - assert(set_count); - if (0 == set_count) return; - assert(pipeline_layout); - if (!pipeline_layout) return; - - uint32_t required_size = first_set + set_count; - const uint32_t last_binding_index = required_size - 1; - assert(last_binding_index < pipeline_layout->compat_for_set.size()); - - // Some useful shorthand - auto &last_bound = cb_state->lastBound[pipeline_bind_point]; - - auto &bound_sets = last_bound.boundDescriptorSets; - auto &dynamic_offsets = last_bound.dynamicOffsets; - auto &bound_compat_ids = last_bound.compat_id_for_set; - auto &pipe_compat_ids = pipeline_layout->compat_for_set; - - const uint32_t current_size = static_cast(bound_sets.size()); - assert(current_size == dynamic_offsets.size()); - assert(current_size == bound_compat_ids.size()); - - // We need this three times in this function, but nowhere else - auto push_descriptor_cleanup = [&last_bound](const cvdescriptorset::DescriptorSet *ds) -> bool { - if (ds && ds->IsPushDescriptor()) { - assert(ds == last_bound.push_descriptor_set.get()); - last_bound.push_descriptor_set = nullptr; - return true; - } - return false; - }; - - // Clean up the "disturbed" before and after the range to be set - if (required_size < current_size) { - if (bound_compat_ids[last_binding_index] != pipe_compat_ids[last_binding_index]) { - // We're disturbing those after last, we'll shrink below, but first need to check for and cleanup the push_descriptor - for (auto set_idx = required_size; set_idx < current_size; ++set_idx) { - if (push_descriptor_cleanup(bound_sets[set_idx])) break; - } - } else { - // We're not disturbing past last, so leave the upper binding data alone. - required_size = current_size; - } - } - - // We resize if we need more set entries or if those past "last" are disturbed - if (required_size != current_size) { - // TODO: put these size tied things in a struct (touches many lines) - bound_sets.resize(required_size); - dynamic_offsets.resize(required_size); - bound_compat_ids.resize(required_size); - } - - // For any previously bound sets, need to set them to "invalid" if they were disturbed by this update - for (uint32_t set_idx = 0; set_idx < first_set; ++set_idx) { - if (bound_compat_ids[set_idx] != pipe_compat_ids[set_idx]) { - push_descriptor_cleanup(bound_sets[set_idx]); - bound_sets[set_idx] = nullptr; - dynamic_offsets[set_idx].clear(); - bound_compat_ids[set_idx] = pipe_compat_ids[set_idx]; - } - } - - // Now update the bound sets with the input sets - const uint32_t *input_dynamic_offsets = p_dynamic_offsets; // "read" pointer for dynamic offset data - for (uint32_t input_idx = 0; input_idx < set_count; input_idx++) { - auto set_idx = input_idx + first_set; // set_idx is index within layout, input_idx is index within input descriptor sets - cvdescriptorset::DescriptorSet *descriptor_set = descriptor_sets[input_idx]; - - // Record binding (or push) - push_descriptor_cleanup(bound_sets[set_idx]); - bound_sets[set_idx] = descriptor_set; - bound_compat_ids[set_idx] = pipe_compat_ids[set_idx]; // compat ids are canonical *per* set index - - if (descriptor_set) { - auto set_dynamic_descriptor_count = descriptor_set->GetDynamicDescriptorCount(); - // TODO: Add logic for tracking push_descriptor offsets (here or in caller) - if (set_dynamic_descriptor_count && input_dynamic_offsets) { - const uint32_t *end_offset = input_dynamic_offsets + set_dynamic_descriptor_count; - dynamic_offsets[set_idx] = std::vector(input_dynamic_offsets, end_offset); - input_dynamic_offsets = end_offset; - assert(input_dynamic_offsets <= (p_dynamic_offsets + dynamic_offset_count)); - } else { - dynamic_offsets[set_idx].clear(); - } - if (!descriptor_set->IsPushDescriptor()) { - // Can't cache validation of push_descriptors - cb_state->validated_descriptor_sets.insert(descriptor_set); - } - } - } -} - -// Update the bound state for the bind point, including the effects of incompatible pipeline layouts -static void PreCallRecordCmdBindDescriptorSets(layer_data *device_data, GLOBAL_CB_NODE *cb_state, - VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, - uint32_t setCount, const VkDescriptorSet *pDescriptorSets, - uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { - auto pipeline_layout = getPipelineLayout(device_data, layout); - std::vector descriptor_sets; - descriptor_sets.reserve(setCount); - - // Construct a list of the descriptors - bool found_non_null = false; - for (uint32_t i = 0; i < setCount; i++) { - cvdescriptorset::DescriptorSet *descriptor_set = GetSetNode(device_data, pDescriptorSets[i]); - descriptor_sets.emplace_back(descriptor_set); - found_non_null |= descriptor_set != nullptr; - } - if (found_non_null) { // which implies setCount > 0 - UpdateLastBoundDescriptorSets(device_data, cb_state, pipelineBindPoint, pipeline_layout, firstSet, setCount, - descriptor_sets, dynamicOffsetCount, pDynamicOffsets); - cb_state->lastBound[pipelineBindPoint].pipeline_layout = layout; - } -} - -static bool PreCallValidateCmdBindDescriptorSets(layer_data *device_data, GLOBAL_CB_NODE *cb_state, - VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, - uint32_t setCount, const VkDescriptorSet *pDescriptorSets, - uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { - bool skip = false; - skip |= ValidateCmdQueueFlags(device_data, cb_state, "vkCmdBindDescriptorSets()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_17c02415); - skip |= ValidateCmd(device_data, cb_state, CMD_BINDDESCRIPTORSETS, "vkCmdBindDescriptorSets()"); - // Track total count of dynamic descriptor types to make sure we have an offset for each one - uint32_t total_dynamic_descriptors = 0; - string error_string = ""; - uint32_t last_set_index = firstSet + setCount - 1; - - if (last_set_index >= cb_state->lastBound[pipelineBindPoint].boundDescriptorSets.size()) { - cb_state->lastBound[pipelineBindPoint].boundDescriptorSets.resize(last_set_index + 1); - cb_state->lastBound[pipelineBindPoint].dynamicOffsets.resize(last_set_index + 1); - cb_state->lastBound[pipelineBindPoint].compat_id_for_set.resize(last_set_index + 1); - } - auto pipeline_layout = getPipelineLayout(device_data, layout); - for (uint32_t set_idx = 0; set_idx < setCount; set_idx++) { - cvdescriptorset::DescriptorSet *descriptor_set = GetSetNode(device_data, pDescriptorSets[set_idx]); - if (descriptor_set) { - if (!descriptor_set->IsUpdated() && (descriptor_set->GetTotalDescriptorCount() != 0)) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(pDescriptorSets[set_idx]), DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, - "Descriptor Set 0x%" PRIx64 " bound but it was never updated. You may want to either update it or not bind it.", - HandleToUint64(pDescriptorSets[set_idx])); - } - // Verify that set being bound is compatible with overlapping setLayout of pipelineLayout - if (!verify_set_layout_compatibility(descriptor_set, pipeline_layout, set_idx + firstSet, error_string)) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(pDescriptorSets[set_idx]), VALIDATION_ERROR_17c002cc, - "descriptorSet #%u being bound is not compatible with overlapping descriptorSetLayout at index %u of " - "pipelineLayout 0x%" PRIx64 " due to: %s.", - set_idx, set_idx + firstSet, HandleToUint64(layout), error_string.c_str()); - } - - auto set_dynamic_descriptor_count = descriptor_set->GetDynamicDescriptorCount(); - - if (set_dynamic_descriptor_count) { - // First make sure we won't overstep bounds of pDynamicOffsets array - if ((total_dynamic_descriptors + set_dynamic_descriptor_count) > dynamicOffsetCount) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, HandleToUint64(pDescriptorSets[set_idx]), - DRAWSTATE_INVALID_DYNAMIC_OFFSET_COUNT, - "descriptorSet #%u (0x%" PRIx64 - ") requires %u dynamicOffsets, but only %u dynamicOffsets are left in pDynamicOffsets array. " - "There must be one dynamic offset for each dynamic descriptor being bound.", - set_idx, HandleToUint64(pDescriptorSets[set_idx]), descriptor_set->GetDynamicDescriptorCount(), - (dynamicOffsetCount - total_dynamic_descriptors)); - } else { // Validate dynamic offsets and Dynamic Offset Minimums - uint32_t cur_dyn_offset = total_dynamic_descriptors; - for (uint32_t d = 0; d < descriptor_set->GetTotalDescriptorCount(); d++) { - if (descriptor_set->GetTypeFromGlobalIndex(d) == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) { - if (SafeModulo(pDynamicOffsets[cur_dyn_offset], - device_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment) != - 0) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, VALIDATION_ERROR_17c002d4, - "vkCmdBindDescriptorSets(): pDynamicOffsets[%d] is %d but must be a multiple of " - "device limit minUniformBufferOffsetAlignment 0x%" PRIxLEAST64 ".", - cur_dyn_offset, pDynamicOffsets[cur_dyn_offset], - device_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment); - } - cur_dyn_offset++; - } else if (descriptor_set->GetTypeFromGlobalIndex(d) == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) { - if (SafeModulo(pDynamicOffsets[cur_dyn_offset], - device_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment) != - 0) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, VALIDATION_ERROR_17c002d4, - "vkCmdBindDescriptorSets(): pDynamicOffsets[%d] is %d but must be a multiple of " - "device limit minStorageBufferOffsetAlignment 0x%" PRIxLEAST64 ".", - cur_dyn_offset, pDynamicOffsets[cur_dyn_offset], - device_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment); - } - cur_dyn_offset++; - } - } - // Keep running total of dynamic descriptor count to verify at the end - total_dynamic_descriptors += set_dynamic_descriptor_count; - } - } - } else { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(pDescriptorSets[set_idx]), DRAWSTATE_INVALID_SET, - "Attempt to bind descriptor set 0x%" PRIx64 " that doesn't exist!", - HandleToUint64(pDescriptorSets[set_idx])); - } - } - // dynamicOffsetCount must equal the total number of dynamic descriptors in the sets being bound - if (total_dynamic_descriptors != dynamicOffsetCount) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_17c002ce, - "Attempting to bind %u descriptorSets with %u dynamic descriptors, but dynamicOffsetCount is %u. It should " - "exactly match the number of dynamic descriptors.", - setCount, total_dynamic_descriptors, dynamicOffsetCount); - } - return skip; -} - -VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, - const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, - const uint32_t *pDynamicOffsets) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_state = GetCBNode(device_data, commandBuffer); - assert(cb_state); - skip = PreCallValidateCmdBindDescriptorSets(device_data, cb_state, pipelineBindPoint, layout, firstSet, setCount, - pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); - if (!skip) { - PreCallRecordCmdBindDescriptorSets(device_data, cb_state, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, - dynamicOffsetCount, pDynamicOffsets); - lock.unlock(); - device_data->dispatch_table.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, - pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); - } else { - lock.unlock(); - } -} - -// Validates that the supplied bind point is supported for the command buffer (vis. the command pool) -// Takes array of error codes as some of the VUID's (e.g. vkCmdBindPipeline) are written per bindpoint -// TODO add vkCmdBindPipeline bind_point validation using this call. -bool ValidatePipelineBindPoint(layer_data *device_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point, - const char *func_name, - const std::array &bind_errors) { - bool skip = false; - auto pool = GetCommandPoolNode(device_data, cb_state->createInfo.commandPool); - if (pool) { // The loss of a pool in a recording cmd is reported in DestroyCommandPool - static const VkQueueFlags flag_mask[VK_PIPELINE_BIND_POINT_RANGE_SIZE] = {VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT}; - const auto bind_point_index = bind_point - VK_PIPELINE_BIND_POINT_BEGIN_RANGE; // typeof enum is not defined, use auto - const auto &qfp = GetPhysDevProperties(device_data)->queue_family_properties[pool->queueFamilyIndex]; - if (0 == (qfp.queueFlags & flag_mask[bind_point_index])) { - const UNIQUE_VALIDATION_ERROR_CODE error = bind_errors[bind_point_index]; - auto cb_u64 = HandleToUint64(cb_state->commandBuffer); - auto cp_u64 = HandleToUint64(cb_state->createInfo.commandPool); - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - cb_u64, error, - "%s: CommandBuffer 0x%" PRIxLEAST64 " was allocated from VkCommandPool 0x%" PRIxLEAST64 - " that does not support bindpoint %s.", - func_name, cb_u64, cp_u64, string_VkPipelineBindPoint(bind_point)); - } - } - return skip; -} - -static bool PreCallValidateCmdPushDescriptorSetKHR(layer_data *device_data, GLOBAL_CB_NODE *cb_state, - const VkPipelineBindPoint bind_point, const VkPipelineLayout layout, - const uint32_t set, const uint32_t descriptor_write_count, - const VkWriteDescriptorSet *descriptor_writes, const char *func_name) { - bool skip = false; - skip |= ValidateCmd(device_data, cb_state, CMD_PUSHDESCRIPTORSETKHR, func_name); - skip |= ValidateCmdQueueFlags(device_data, cb_state, func_name, (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT), - VALIDATION_ERROR_1be02415); - skip |= ValidatePipelineBindPoint(device_data, cb_state, bind_point, func_name, - {{VALIDATION_ERROR_1be002d6, VALIDATION_ERROR_1be002d6}}); - auto layout_data = getPipelineLayout(device_data, layout); - - // Validate the set index points to a push descriptor set and is in range - if (layout_data) { - const auto &set_layouts = layout_data->set_layouts; - const auto layout_u64 = HandleToUint64(layout); - if (set < set_layouts.size()) { - const auto *dsl = set_layouts[set].get(); - if (dsl && (0 == (dsl->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR))) { - skip = log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, layout_u64, VALIDATION_ERROR_1be002da, - "%s: Set index %" PRIu32 - " does not match push descriptor set layout index for VkPipelineLayout 0x%" PRIxLEAST64 ".", - func_name, set, layout_u64); - } - } else { - skip = log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, - layout_u64, VALIDATION_ERROR_1be002d8, - "%s: Set index %" PRIu32 " is outside of range for VkPipelineLayout 0x%" PRIxLEAST64 " (set < %" PRIu32 - ").", - func_name, set, layout_u64, static_cast(set_layouts.size())); - } - } - - return skip; -} -static void PreCallRecordCmdPushDescriptorSetKHR(layer_data *device_data, GLOBAL_CB_NODE *cb_state, - VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, - uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites) { - const auto &pipeline_layout = getPipelineLayout(device_data, layout); - if (!pipeline_layout) return; - std::unique_ptr new_desc{ - new cvdescriptorset::DescriptorSet(0, 0, pipeline_layout->set_layouts[set], 0, device_data)}; - - std::vector descriptor_sets = {new_desc.get()}; - UpdateLastBoundDescriptorSets(device_data, cb_state, pipelineBindPoint, pipeline_layout, set, 1, descriptor_sets, 0, nullptr); - cb_state->lastBound[pipelineBindPoint].push_descriptor_set = std::move(new_desc); - cb_state->lastBound[pipelineBindPoint].pipeline_layout = layout; -} - -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - auto cb_state = GetCBNode(device_data, commandBuffer); - bool skip = PreCallValidateCmdPushDescriptorSetKHR(device_data, cb_state, pipelineBindPoint, layout, set, descriptorWriteCount, - pDescriptorWrites, "vkCmdPushDescriptorSetKHR()"); - if (!skip) { - PreCallRecordCmdPushDescriptorSetKHR(device_data, cb_state, pipelineBindPoint, layout, set, descriptorWriteCount, - pDescriptorWrites); - lock.unlock(); - device_data->dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, - pDescriptorWrites); - } -} - -static VkDeviceSize GetIndexAlignment(VkIndexType indexType) { - switch (indexType) { - case VK_INDEX_TYPE_UINT16: - return 2; - case VK_INDEX_TYPE_UINT32: - return 4; - default: - // Not a real index type. Express no alignment requirement here; we expect upper layer - // to have already picked up on the enum being nonsense. - return 1; - } -} - -VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, - VkIndexType indexType) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto buffer_state = GetBufferState(dev_data, buffer); - auto cb_node = GetCBNode(dev_data, commandBuffer); - assert(cb_node); - assert(buffer_state); - - skip |= ValidateBufferUsageFlags(dev_data, buffer_state, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, true, VALIDATION_ERROR_17e00362, - "vkCmdBindIndexBuffer()", "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"); - skip |= ValidateCmdQueueFlags(dev_data, cb_node, "vkCmdBindIndexBuffer()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_17e02415); - skip |= ValidateCmd(dev_data, cb_node, CMD_BINDINDEXBUFFER, "vkCmdBindIndexBuffer()"); - skip |= ValidateMemoryIsBoundToBuffer(dev_data, buffer_state, "vkCmdBindIndexBuffer()", VALIDATION_ERROR_17e00364); - auto offset_align = GetIndexAlignment(indexType); - if (offset % offset_align) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_17e00360, - "vkCmdBindIndexBuffer() offset (0x%" PRIxLEAST64 ") does not fall on alignment (%s) boundary.", offset, - string_VkIndexType(indexType)); - } - - if (skip) return; - - cb_node->status |= CBSTATUS_INDEX_BUFFER_BOUND; - cb_node->index_buffer_binding.buffer = buffer; - cb_node->index_buffer_binding.size = buffer_state->createInfo.size; - cb_node->index_buffer_binding.offset = offset; - cb_node->index_buffer_binding.index_type = indexType; - - lock.unlock(); - dev_data->dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); -} - -void updateResourceTracking(GLOBAL_CB_NODE *pCB, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers) { - uint32_t end = firstBinding + bindingCount; - if (pCB->currentDrawData.buffers.size() < end) { - pCB->currentDrawData.buffers.resize(end); - } - for (uint32_t i = 0; i < bindingCount; ++i) { - pCB->currentDrawData.buffers[i + firstBinding] = pBuffers[i]; - } -} - -static inline void updateResourceTrackingOnDraw(GLOBAL_CB_NODE *pCB) { pCB->drawData.push_back(pCB->currentDrawData); } - -VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, - const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_node = GetCBNode(dev_data, commandBuffer); - assert(cb_node); - - skip |= ValidateCmdQueueFlags(dev_data, cb_node, "vkCmdBindVertexBuffers()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_18202415); - skip |= ValidateCmd(dev_data, cb_node, CMD_BINDVERTEXBUFFERS, "vkCmdBindVertexBuffers()"); - for (uint32_t i = 0; i < bindingCount; ++i) { - auto buffer_state = GetBufferState(dev_data, pBuffers[i]); - assert(buffer_state); - skip |= ValidateBufferUsageFlags(dev_data, buffer_state, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, true, VALIDATION_ERROR_182004e6, - "vkCmdBindVertexBuffers()", "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"); - skip |= ValidateMemoryIsBoundToBuffer(dev_data, buffer_state, "vkCmdBindVertexBuffers()", VALIDATION_ERROR_182004e8); - if (pOffsets[i] >= buffer_state->createInfo.size) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - HandleToUint64(buffer_state->buffer), VALIDATION_ERROR_182004e4, - "vkCmdBindVertexBuffers() offset (0x%" PRIxLEAST64 ") is beyond the end of the buffer.", pOffsets[i]); - } - } - - if (skip) return; - - updateResourceTracking(cb_node, firstBinding, bindingCount, pBuffers); - - lock.unlock(); - dev_data->dispatch_table.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); -} - -// Generic function to handle validation for all CmdDraw* type functions -static bool ValidateCmdDrawType(layer_data *dev_data, VkCommandBuffer cmd_buffer, bool indexed, VkPipelineBindPoint bind_point, - CMD_TYPE cmd_type, GLOBAL_CB_NODE **cb_state, const char *caller, VkQueueFlags queue_flags, - UNIQUE_VALIDATION_ERROR_CODE queue_flag_code, UNIQUE_VALIDATION_ERROR_CODE msg_code, - UNIQUE_VALIDATION_ERROR_CODE const dynamic_state_msg_code) { - bool skip = false; - *cb_state = GetCBNode(dev_data, cmd_buffer); - if (*cb_state) { - skip |= ValidateCmdQueueFlags(dev_data, *cb_state, caller, queue_flags, queue_flag_code); - skip |= ValidateCmd(dev_data, *cb_state, cmd_type, caller); - skip |= ValidateDrawState(dev_data, *cb_state, cmd_type, indexed, bind_point, caller, dynamic_state_msg_code); - skip |= (VK_PIPELINE_BIND_POINT_GRAPHICS == bind_point) ? outsideRenderPass(dev_data, *cb_state, caller, msg_code) - : insideRenderPass(dev_data, *cb_state, caller, msg_code); - } - return skip; -} - -// Generic function to handle state update for all CmdDraw* and CmdDispatch* type functions -static void UpdateStateCmdDrawDispatchType(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point) { - UpdateDrawState(dev_data, cb_state, bind_point); -} - -// Generic function to handle state update for all CmdDraw* type functions -static void UpdateStateCmdDrawType(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point) { - UpdateStateCmdDrawDispatchType(dev_data, cb_state, bind_point); - updateResourceTrackingOnDraw(cb_state); - cb_state->hasDrawCmd = true; -} - -static bool PreCallValidateCmdDraw(layer_data *dev_data, VkCommandBuffer cmd_buffer, bool indexed, VkPipelineBindPoint bind_point, - GLOBAL_CB_NODE **cb_state, const char *caller) { - return ValidateCmdDrawType(dev_data, cmd_buffer, indexed, bind_point, CMD_DRAW, cb_state, caller, VK_QUEUE_GRAPHICS_BIT, - VALIDATION_ERROR_1a202415, VALIDATION_ERROR_1a200017, VALIDATION_ERROR_1a200376); -} - -static void PostCallRecordCmdDraw(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point) { - UpdateStateCmdDrawType(dev_data, cb_state, bind_point); -} - -VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, - uint32_t firstVertex, uint32_t firstInstance) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *cb_state = nullptr; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCmdDraw(dev_data, commandBuffer, false, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, "vkCmdDraw()"); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); - lock.lock(); - PostCallRecordCmdDraw(dev_data, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); - lock.unlock(); - } -} - -static bool PreCallValidateCmdDrawIndexed(layer_data *dev_data, VkCommandBuffer cmd_buffer, bool indexed, - VkPipelineBindPoint bind_point, GLOBAL_CB_NODE **cb_state, const char *caller, - uint32_t indexCount, uint32_t firstIndex) { - bool skip = - ValidateCmdDrawType(dev_data, cmd_buffer, indexed, bind_point, CMD_DRAWINDEXED, cb_state, caller, VK_QUEUE_GRAPHICS_BIT, - VALIDATION_ERROR_1a402415, VALIDATION_ERROR_1a400017, VALIDATION_ERROR_1a40039c); - if (!skip && ((*cb_state)->status & CBSTATUS_INDEX_BUFFER_BOUND)) { - unsigned int index_size = 0; - const auto &index_buffer_binding = (*cb_state)->index_buffer_binding; - if (index_buffer_binding.index_type == VK_INDEX_TYPE_UINT16) { - index_size = 2; - } else if (index_buffer_binding.index_type == VK_INDEX_TYPE_UINT32) { - index_size = 4; - } - VkDeviceSize end_offset = (index_size * ((VkDeviceSize)firstIndex + indexCount)) + index_buffer_binding.offset; - if (end_offset > index_buffer_binding.size) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - HandleToUint64(index_buffer_binding.buffer), VALIDATION_ERROR_1a40039e, - "vkCmdDrawIndexed() index size (%d) * (firstIndex (%d) + indexCount (%d)) " - "+ binding offset (%" PRIuLEAST64 ") = an ending offset of %" PRIuLEAST64 - " bytes, " - "which is greater than the index buffer size (%" PRIuLEAST64 ").", - index_size, firstIndex, indexCount, index_buffer_binding.offset, end_offset, index_buffer_binding.size); - } - } - return skip; -} - -static void PostCallRecordCmdDrawIndexed(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point) { - UpdateStateCmdDrawType(dev_data, cb_state, bind_point); -} - -VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, - uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *cb_state = nullptr; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCmdDrawIndexed(dev_data, commandBuffer, true, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, - "vkCmdDrawIndexed()", indexCount, firstIndex); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); - lock.lock(); - PostCallRecordCmdDrawIndexed(dev_data, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); - lock.unlock(); - } -} - -static bool PreCallValidateCmdDrawIndirect(layer_data *dev_data, VkCommandBuffer cmd_buffer, VkBuffer buffer, bool indexed, - VkPipelineBindPoint bind_point, GLOBAL_CB_NODE **cb_state, BUFFER_STATE **buffer_state, - const char *caller) { - bool skip = - ValidateCmdDrawType(dev_data, cmd_buffer, indexed, bind_point, CMD_DRAWINDIRECT, cb_state, caller, VK_QUEUE_GRAPHICS_BIT, - VALIDATION_ERROR_1aa02415, VALIDATION_ERROR_1aa00017, VALIDATION_ERROR_1aa003cc); - *buffer_state = GetBufferState(dev_data, buffer); - skip |= ValidateMemoryIsBoundToBuffer(dev_data, *buffer_state, caller, VALIDATION_ERROR_1aa003b4); - // TODO: If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the - // VkDrawIndirectCommand structures accessed by this command must be 0, which will require access to the contents of 'buffer'. - return skip; -} - -static void PostCallRecordCmdDrawIndirect(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point, - BUFFER_STATE *buffer_state) { - UpdateStateCmdDrawType(dev_data, cb_state, bind_point); - AddCommandBufferBindingBuffer(dev_data, cb_state, buffer_state); -} - -VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, - uint32_t stride) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *cb_state = nullptr; - BUFFER_STATE *buffer_state = nullptr; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCmdDrawIndirect(dev_data, commandBuffer, buffer, false, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, - &buffer_state, "vkCmdDrawIndirect()"); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, count, stride); - lock.lock(); - PostCallRecordCmdDrawIndirect(dev_data, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, buffer_state); - lock.unlock(); - } -} - -static bool PreCallValidateCmdDrawIndexedIndirect(layer_data *dev_data, VkCommandBuffer cmd_buffer, VkBuffer buffer, bool indexed, - VkPipelineBindPoint bind_point, GLOBAL_CB_NODE **cb_state, - BUFFER_STATE **buffer_state, const char *caller) { - bool skip = - ValidateCmdDrawType(dev_data, cmd_buffer, indexed, bind_point, CMD_DRAWINDEXEDINDIRECT, cb_state, caller, - VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1a602415, VALIDATION_ERROR_1a600017, VALIDATION_ERROR_1a600434); - *buffer_state = GetBufferState(dev_data, buffer); - skip |= ValidateMemoryIsBoundToBuffer(dev_data, *buffer_state, caller, VALIDATION_ERROR_1a60041c); - // TODO: If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the - // VkDrawIndexedIndirectCommand structures accessed by this command must be 0, which will require access to the contents of - // 'buffer'. - return skip; -} - -static void PostCallRecordCmdDrawIndexedIndirect(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point, - BUFFER_STATE *buffer_state) { - UpdateStateCmdDrawType(dev_data, cb_state, bind_point); - AddCommandBufferBindingBuffer(dev_data, cb_state, buffer_state); -} - -VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, - uint32_t count, uint32_t stride) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *cb_state = nullptr; - BUFFER_STATE *buffer_state = nullptr; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCmdDrawIndexedIndirect(dev_data, commandBuffer, buffer, true, VK_PIPELINE_BIND_POINT_GRAPHICS, - &cb_state, &buffer_state, "vkCmdDrawIndexedIndirect()"); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride); - lock.lock(); - PostCallRecordCmdDrawIndexedIndirect(dev_data, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, buffer_state); - lock.unlock(); - } -} - -static bool PreCallValidateCmdDispatch(layer_data *dev_data, VkCommandBuffer cmd_buffer, bool indexed, - VkPipelineBindPoint bind_point, GLOBAL_CB_NODE **cb_state, const char *caller) { - return ValidateCmdDrawType(dev_data, cmd_buffer, indexed, bind_point, CMD_DISPATCH, cb_state, caller, VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_19c02415, VALIDATION_ERROR_19c00017, VALIDATION_ERROR_UNDEFINED); -} - -static void PostCallRecordCmdDispatch(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point) { - UpdateStateCmdDrawDispatchType(dev_data, cb_state, bind_point); -} - -VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *cb_state = nullptr; - unique_lock_t lock(global_lock); - bool skip = - PreCallValidateCmdDispatch(dev_data, commandBuffer, false, VK_PIPELINE_BIND_POINT_COMPUTE, &cb_state, "vkCmdDispatch()"); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdDispatch(commandBuffer, x, y, z); - lock.lock(); - PostCallRecordCmdDispatch(dev_data, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE); - lock.unlock(); - } -} - -static bool PreCallValidateCmdDispatchIndirect(layer_data *dev_data, VkCommandBuffer cmd_buffer, VkBuffer buffer, bool indexed, - VkPipelineBindPoint bind_point, GLOBAL_CB_NODE **cb_state, - BUFFER_STATE **buffer_state, const char *caller) { - bool skip = - ValidateCmdDrawType(dev_data, cmd_buffer, indexed, bind_point, CMD_DISPATCHINDIRECT, cb_state, caller, VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_1a002415, VALIDATION_ERROR_1a000017, VALIDATION_ERROR_UNDEFINED); - *buffer_state = GetBufferState(dev_data, buffer); - skip |= ValidateMemoryIsBoundToBuffer(dev_data, *buffer_state, caller, VALIDATION_ERROR_1a000322); - return skip; -} - -static void PostCallRecordCmdDispatchIndirect(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, VkPipelineBindPoint bind_point, - BUFFER_STATE *buffer_state) { - UpdateStateCmdDrawDispatchType(dev_data, cb_state, bind_point); - AddCommandBufferBindingBuffer(dev_data, cb_state, buffer_state); -} - -VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *cb_state = nullptr; - BUFFER_STATE *buffer_state = nullptr; - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCmdDispatchIndirect(dev_data, commandBuffer, buffer, false, VK_PIPELINE_BIND_POINT_COMPUTE, - &cb_state, &buffer_state, "vkCmdDispatchIndirect()"); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset); - lock.lock(); - PostCallRecordCmdDispatchIndirect(dev_data, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE, buffer_state); - lock.unlock(); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, - uint32_t regionCount, const VkBufferCopy *pRegions) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_node = GetCBNode(device_data, commandBuffer); - auto src_buffer_state = GetBufferState(device_data, srcBuffer); - auto dst_buffer_state = GetBufferState(device_data, dstBuffer); - - if (cb_node && src_buffer_state && dst_buffer_state) { - bool skip = PreCallValidateCmdCopyBuffer(device_data, cb_node, src_buffer_state, dst_buffer_state); - if (!skip) { - PreCallRecordCmdCopyBuffer(device_data, cb_node, src_buffer_state, dst_buffer_state); - lock.unlock(); - device_data->dispatch_table.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); - } - } else { - lock.unlock(); - assert(0); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, - VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageCopy *pRegions) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_node = GetCBNode(device_data, commandBuffer); - auto src_image_state = GetImageState(device_data, srcImage); - auto dst_image_state = GetImageState(device_data, dstImage); - if (cb_node && src_image_state && dst_image_state) { - skip = PreCallValidateCmdCopyImage(device_data, cb_node, src_image_state, dst_image_state, regionCount, pRegions, - srcImageLayout, dstImageLayout); - if (!skip) { - PreCallRecordCmdCopyImage(device_data, cb_node, src_image_state, dst_image_state, regionCount, pRegions, srcImageLayout, - dstImageLayout); - lock.unlock(); - device_data->dispatch_table.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, - pRegions); - } - } else { - lock.unlock(); - assert(0); - } -} - -// Validate that an image's sampleCount matches the requirement for a specific API call -bool ValidateImageSampleCount(layer_data *dev_data, IMAGE_STATE *image_state, VkSampleCountFlagBits sample_count, - const char *location, UNIQUE_VALIDATION_ERROR_CODE msgCode) { - bool skip = false; - if (image_state->createInfo.samples != sample_count) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), msgCode, - "%s for image 0x%" PRIx64 " was created with a sample count of %s but must be %s.", location, - HandleToUint64(image_state->image), string_VkSampleCountFlagBits(image_state->createInfo.samples), - string_VkSampleCountFlagBits(sample_count)); - } - return skip; -} - -VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, - VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageBlit *pRegions, VkFilter filter) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_node = GetCBNode(dev_data, commandBuffer); - auto src_image_state = GetImageState(dev_data, srcImage); - auto dst_image_state = GetImageState(dev_data, dstImage); - - bool skip = PreCallValidateCmdBlitImage(dev_data, cb_node, src_image_state, dst_image_state, regionCount, pRegions, - srcImageLayout, dstImageLayout, filter); - - if (!skip) { - PreCallRecordCmdBlitImage(dev_data, cb_node, src_image_state, dst_image_state, regionCount, pRegions, srcImageLayout, - dstImageLayout); - lock.unlock(); - dev_data->dispatch_table.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, - pRegions, filter); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkBufferImageCopy *pRegions) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = false; - auto cb_node = GetCBNode(device_data, commandBuffer); - auto src_buffer_state = GetBufferState(device_data, srcBuffer); - auto dst_image_state = GetImageState(device_data, dstImage); - if (cb_node && src_buffer_state && dst_image_state) { - skip = PreCallValidateCmdCopyBufferToImage(device_data, dstImageLayout, cb_node, src_buffer_state, dst_image_state, - regionCount, pRegions, "vkCmdCopyBufferToImage()"); - } else { - lock.unlock(); - assert(0); - // TODO: report VU01244 here, or put in object tracker? - } - if (!skip) { - PreCallRecordCmdCopyBufferToImage(device_data, cb_node, src_buffer_state, dst_image_state, regionCount, pRegions, - dstImageLayout); - lock.unlock(); - device_data->dispatch_table.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, - VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_node = GetCBNode(device_data, commandBuffer); - auto src_image_state = GetImageState(device_data, srcImage); - auto dst_buffer_state = GetBufferState(device_data, dstBuffer); - if (cb_node && src_image_state && dst_buffer_state) { - skip = PreCallValidateCmdCopyImageToBuffer(device_data, srcImageLayout, cb_node, src_image_state, dst_buffer_state, - regionCount, pRegions, "vkCmdCopyImageToBuffer()"); - } else { - lock.unlock(); - assert(0); - // TODO: report VU01262 here, or put in object tracker? - } - if (!skip) { - PreCallRecordCmdCopyImageToBuffer(device_data, cb_node, src_image_state, dst_buffer_state, regionCount, pRegions, - srcImageLayout); - lock.unlock(); - device_data->dispatch_table.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); - } -} - -static bool PreCallCmdUpdateBuffer(layer_data *device_data, const GLOBAL_CB_NODE *cb_state, const BUFFER_STATE *dst_buffer_state) { - bool skip = false; - skip |= ValidateMemoryIsBoundToBuffer(device_data, dst_buffer_state, "vkCmdUpdateBuffer()", VALIDATION_ERROR_1e400046); - // Validate that DST buffer has correct usage flags set - skip |= ValidateBufferUsageFlags(device_data, dst_buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, - VALIDATION_ERROR_1e400044, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); - skip |= ValidateCmdQueueFlags(device_data, cb_state, "vkCmdUpdateBuffer()", - VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, VALIDATION_ERROR_1e402415); - skip |= ValidateCmd(device_data, cb_state, CMD_UPDATEBUFFER, "vkCmdUpdateBuffer()"); - skip |= insideRenderPass(device_data, cb_state, "vkCmdUpdateBuffer()", VALIDATION_ERROR_1e400017); - return skip; -} - -static void PostCallRecordCmdUpdateBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_state, BUFFER_STATE *dst_buffer_state) { - // Update bindings between buffer and cmd buffer - AddCommandBufferBindingBuffer(device_data, cb_state, dst_buffer_state); -} - -VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, - VkDeviceSize dataSize, const uint32_t *pData) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_state = GetCBNode(dev_data, commandBuffer); - assert(cb_state); - auto dst_buff_state = GetBufferState(dev_data, dstBuffer); - assert(dst_buff_state); - skip |= PreCallCmdUpdateBuffer(dev_data, cb_state, dst_buff_state); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); - lock.lock(); - PostCallRecordCmdUpdateBuffer(dev_data, cb_state, dst_buff_state); - lock.unlock(); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, - VkDeviceSize size, uint32_t data) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - auto cb_node = GetCBNode(device_data, commandBuffer); - auto buffer_state = GetBufferState(device_data, dstBuffer); - - if (cb_node && buffer_state) { - bool skip = PreCallValidateCmdFillBuffer(device_data, cb_node, buffer_state); - if (!skip) { - PreCallRecordCmdFillBuffer(device_data, cb_node, buffer_state); - lock.unlock(); - device_data->dispatch_table.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); - } - } else { - lock.unlock(); - assert(0); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, - const VkClearAttachment *pAttachments, uint32_t rectCount, - const VkClearRect *pRects) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - { - lock_guard_t lock(global_lock); - skip = PreCallValidateCmdClearAttachments(dev_data, commandBuffer, attachmentCount, pAttachments, rectCount, pRects); - } - if (!skip) dev_data->dispatch_table.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); -} - -VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, - const VkClearColorValue *pColor, uint32_t rangeCount, - const VkImageSubresourceRange *pRanges) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - bool skip = PreCallValidateCmdClearColorImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); - if (!skip) { - PreCallRecordCmdClearImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); - lock.unlock(); - dev_data->dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, - const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, - const VkImageSubresourceRange *pRanges) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - bool skip = PreCallValidateCmdClearDepthStencilImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); - if (!skip) { - PreCallRecordCmdClearImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); - lock.unlock(); - dev_data->dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, - VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageResolve *pRegions) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_node = GetCBNode(dev_data, commandBuffer); - auto src_image_state = GetImageState(dev_data, srcImage); - auto dst_image_state = GetImageState(dev_data, dstImage); - - bool skip = PreCallValidateCmdResolveImage(dev_data, cb_node, src_image_state, dst_image_state, regionCount, pRegions); - - if (!skip) { - PreCallRecordCmdResolveImage(dev_data, cb_node, src_image_state, dst_image_state); - lock.unlock(); - dev_data->dispatch_table.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, - pRegions); - } -} - -VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, - VkSubresourceLayout *pLayout) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - - bool skip = PreCallValidateGetImageSubresourceLayout(device_data, image, pSubresource); - if (!skip) { - lock.unlock(); - device_data->dispatch_table.GetImageSubresourceLayout(device, image, pSubresource, pLayout); - } -} - -bool setEventStageMask(VkQueue queue, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - pCB->eventToStageMap[event] = stageMask; - } - auto queue_data = dev_data->queueMap.find(queue); - if (queue_data != dev_data->queueMap.end()) { - queue_data->second.eventToStageMap[event] = stageMask; - } - return false; -} - -VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetEvent()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_1d402415); - skip |= ValidateCmd(dev_data, pCB, CMD_SETEVENT, "vkCmdSetEvent()"); - skip |= insideRenderPass(dev_data, pCB, "vkCmdSetEvent()", VALIDATION_ERROR_1d400017); - skip |= ValidateStageMaskGsTsEnables(dev_data, stageMask, "vkCmdSetEvent()", VALIDATION_ERROR_1d4008fc, - VALIDATION_ERROR_1d4008fe); - auto event_state = GetEventNode(dev_data, event); - if (event_state) { - addCommandBufferBinding(&event_state->cb_bindings, {HandleToUint64(event), kVulkanObjectTypeEvent}, pCB); - event_state->cb_bindings.insert(pCB); - } - pCB->events.push_back(event); - if (!pCB->waitedEvents.count(event)) { - pCB->writeEventsBeforeWait.push_back(event); - } - pCB->eventUpdates.emplace_back([=](VkQueue q) { return setEventStageMask(q, commandBuffer, event, stageMask); }); - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdSetEvent(commandBuffer, event, stageMask); -} - -VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdResetEvent()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_1c402415); - skip |= ValidateCmd(dev_data, pCB, CMD_RESETEVENT, "vkCmdResetEvent()"); - skip |= insideRenderPass(dev_data, pCB, "vkCmdResetEvent()", VALIDATION_ERROR_1c400017); - skip |= ValidateStageMaskGsTsEnables(dev_data, stageMask, "vkCmdResetEvent()", VALIDATION_ERROR_1c400904, - VALIDATION_ERROR_1c400906); - auto event_state = GetEventNode(dev_data, event); - if (event_state) { - addCommandBufferBinding(&event_state->cb_bindings, {HandleToUint64(event), kVulkanObjectTypeEvent}, pCB); - event_state->cb_bindings.insert(pCB); - } - pCB->events.push_back(event); - if (!pCB->waitedEvents.count(event)) { - pCB->writeEventsBeforeWait.push_back(event); - } - // TODO : Add check for VALIDATION_ERROR_32c008f8 - pCB->eventUpdates.emplace_back( - [=](VkQueue q) { return setEventStageMask(q, commandBuffer, event, VkPipelineStageFlags(0)); }); - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdResetEvent(commandBuffer, event, stageMask); -} - -// Return input pipeline stage flags, expanded for individual bits if VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT -static VkPipelineStageFlags ExpandPipelineStageFlags(VkPipelineStageFlags inflags) { - return (inflags != VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) - ? inflags - : (VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT | VK_PIPELINE_STAGE_VERTEX_INPUT_BIT | - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); -} - -// Verify image barrier image state and that the image is consistent with FB image -static bool ValidateImageBarrierImage(layer_data *device_data, const char *funcName, GLOBAL_CB_NODE const *cb_state, - VkFramebuffer framebuffer, uint32_t active_subpass, const safe_VkSubpassDescription &sub_desc, - uint64_t rp_handle, uint32_t img_index, const VkImageMemoryBarrier &img_barrier) { - bool skip = false; - const auto &fb_state = GetFramebufferState(device_data, framebuffer); - assert(fb_state); - const auto img_bar_image = img_barrier.image; - bool image_match = false; - bool sub_image_found = false; // Do we find a corresponding subpass description - VkImageLayout sub_image_layout = VK_IMAGE_LAYOUT_UNDEFINED; - uint32_t attach_index = 0; - uint32_t index_count = 0; - // Verify that a framebuffer image matches barrier image - for (const auto &fb_attach : fb_state->attachments) { - if (img_bar_image == fb_attach.image) { - image_match = true; - attach_index = index_count; - break; - } - index_count++; - } - if (image_match) { // Make sure subpass is referring to matching attachment - if (sub_desc.pDepthStencilAttachment && sub_desc.pDepthStencilAttachment->attachment == attach_index) { - sub_image_layout = sub_desc.pDepthStencilAttachment->layout; - sub_image_found = true; - } else { - for (uint32_t j = 0; j < sub_desc.colorAttachmentCount; ++j) { - if (sub_desc.pColorAttachments && sub_desc.pColorAttachments[j].attachment == attach_index) { - sub_image_layout = sub_desc.pColorAttachments[j].layout; - sub_image_found = true; - break; - } else if (sub_desc.pResolveAttachments && sub_desc.pResolveAttachments[j].attachment == attach_index) { - sub_image_layout = sub_desc.pResolveAttachments[j].layout; - sub_image_found = true; - break; - } - } - } - if (!sub_image_found) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, rp_handle, - VALIDATION_ERROR_1b800936, - "%s: Barrier pImageMemoryBarriers[%d].image (0x%" PRIx64 - ") is not referenced by the VkSubpassDescription for active subpass (%d) of current renderPass (0x%" PRIx64 ").", - funcName, img_index, HandleToUint64(img_bar_image), active_subpass, rp_handle); - } - } else { // !image_match - auto const fb_handle = HandleToUint64(fb_state->framebuffer); - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, - fb_handle, VALIDATION_ERROR_1b800936, - "%s: Barrier pImageMemoryBarriers[%d].image (0x%" PRIx64 - ") does not match an image from the current framebuffer (0x%" PRIx64 ").", - funcName, img_index, HandleToUint64(img_bar_image), fb_handle); - } - if (img_barrier.oldLayout != img_barrier.newLayout) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_1b80093a, - "%s: As the Image Barrier for image 0x%" PRIx64 - " is being executed within a render pass instance, oldLayout must equal newLayout yet they are %s and %s.", - funcName, HandleToUint64(img_barrier.image), string_VkImageLayout(img_barrier.oldLayout), - string_VkImageLayout(img_barrier.newLayout)); - } else { - if (sub_image_found && sub_image_layout != img_barrier.oldLayout) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b800938, - "%s: Barrier pImageMemoryBarriers[%d].image (0x%" PRIx64 - ") is referenced by the VkSubpassDescription for active subpass (%d) of current renderPass (0x%" PRIx64 - ") as having layout %s, but image barrier has layout %s.", - funcName, img_index, HandleToUint64(img_bar_image), active_subpass, rp_handle, - string_VkImageLayout(img_barrier.oldLayout), string_VkImageLayout(sub_image_layout)); - } - } - return skip; -} - -// Validate image barriers within a renderPass -static bool ValidateRenderPassImageBarriers(layer_data *device_data, const char *funcName, GLOBAL_CB_NODE *cb_state, - uint32_t active_subpass, const safe_VkSubpassDescription &sub_desc, uint64_t rp_handle, - VkAccessFlags sub_src_access_mask, VkAccessFlags sub_dst_access_mask, - uint32_t image_mem_barrier_count, const VkImageMemoryBarrier *image_barriers) { - bool skip = false; - for (uint32_t i = 0; i < image_mem_barrier_count; ++i) { - const auto &img_barrier = image_barriers[i]; - const auto &img_src_access_mask = img_barrier.srcAccessMask; - if (img_src_access_mask != (sub_src_access_mask & img_src_access_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b80092e, - "%s: Barrier pImageMemoryBarriers[%d].srcAccessMask(0x%X) is not a subset of VkSubpassDependency " - "srcAccessMask(0x%X) of subpass %d of renderPass 0x%" PRIx64 ".", - funcName, i, img_src_access_mask, sub_src_access_mask, active_subpass, rp_handle); - } - const auto &img_dst_access_mask = img_barrier.dstAccessMask; - if (img_dst_access_mask != (sub_dst_access_mask & img_dst_access_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b800930, - "%s: Barrier pImageMemoryBarriers[%d].dstAccessMask(0x%X) is not a subset of VkSubpassDependency " - "dstAccessMask(0x%X) of subpass %d of renderPass 0x%" PRIx64 ".", - funcName, i, img_dst_access_mask, sub_dst_access_mask, active_subpass, rp_handle); - } - if (VK_QUEUE_FAMILY_IGNORED != img_barrier.srcQueueFamilyIndex || - VK_QUEUE_FAMILY_IGNORED != img_barrier.dstQueueFamilyIndex) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b80093c, - "%s: Barrier pImageMemoryBarriers[%d].srcQueueFamilyIndex is %d and " - "pImageMemoryBarriers[%d].dstQueueFamilyIndex is %d but both must be VK_QUEUE_FAMILY_IGNORED.", - funcName, i, img_barrier.srcQueueFamilyIndex, i, img_barrier.dstQueueFamilyIndex); - } - // Secondary CBs can have null framebuffer so queue up validation in that case 'til FB is known - if (VK_NULL_HANDLE == cb_state->activeFramebuffer) { - assert(VK_COMMAND_BUFFER_LEVEL_SECONDARY == cb_state->createInfo.level); - // Secondary CB case w/o FB specified delay validation - cb_state->cmd_execute_commands_functions.emplace_back([=](GLOBAL_CB_NODE *primary_cb, VkFramebuffer fb) { - return ValidateImageBarrierImage(device_data, funcName, cb_state, fb, active_subpass, sub_desc, rp_handle, i, - img_barrier); - }); - } else { - skip |= ValidateImageBarrierImage(device_data, funcName, cb_state, cb_state->activeFramebuffer, active_subpass, - sub_desc, rp_handle, i, img_barrier); - } - } - return skip; -} - -// Validate VUs for Pipeline Barriers that are within a renderPass -// Pre: cb_state->activeRenderPass must be a pointer to valid renderPass state -static bool ValidateRenderPassPipelineBarriers(layer_data *device_data, const char *funcName, GLOBAL_CB_NODE *cb_state, - VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask, - VkDependencyFlags dependency_flags, uint32_t mem_barrier_count, - const VkMemoryBarrier *mem_barriers, uint32_t buffer_mem_barrier_count, - const VkBufferMemoryBarrier *buffer_mem_barriers, uint32_t image_mem_barrier_count, - const VkImageMemoryBarrier *image_barriers) { - bool skip = false; - auto rp_state = cb_state->activeRenderPass; - const auto active_subpass = cb_state->activeSubpass; - auto rp_handle = HandleToUint64(rp_state->renderPass); - if (!rp_state->hasSelfDependency[active_subpass]) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, rp_handle, - VALIDATION_ERROR_1b800928, - "%s: Barriers cannot be set during subpass %d of renderPass 0x%" PRIx64 " with no self-dependency specified.", - funcName, active_subpass, rp_handle); - } else { - assert(rp_state->subpass_to_dependency_index[cb_state->activeSubpass] != -1); - // Grab ref to current subpassDescription up-front for use below - const auto &sub_desc = rp_state->createInfo.pSubpasses[active_subpass]; - const auto &sub_dep = rp_state->createInfo.pDependencies[rp_state->subpass_to_dependency_index[active_subpass]]; - const auto &sub_src_stage_mask = ExpandPipelineStageFlags(sub_dep.srcStageMask); - const auto &sub_dst_stage_mask = ExpandPipelineStageFlags(sub_dep.dstStageMask); - if ((sub_src_stage_mask != VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) && - (src_stage_mask != (sub_src_stage_mask & src_stage_mask))) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b80092a, - "%s: Barrier srcStageMask(0x%X) is not a subset of VkSubpassDependency srcStageMask(0x%X) of subpass " - "%d of renderPass 0x%" PRIx64 ".", - funcName, src_stage_mask, sub_src_stage_mask, active_subpass, rp_handle); - } - if ((sub_dst_stage_mask != VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) && - (dst_stage_mask != (sub_dst_stage_mask & dst_stage_mask))) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b80092c, - "%s: Barrier dstStageMask(0x%X) is not a subset of VkSubpassDependency dstStageMask(0x%X) of subpass " - "%d of renderPass 0x%" PRIx64 ".", - funcName, dst_stage_mask, sub_dst_stage_mask, active_subpass, rp_handle); - } - if (0 != buffer_mem_barrier_count) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b800934, - "%s: bufferMemoryBarrierCount is non-zero (%d) for subpass %d of renderPass 0x%" PRIx64 ".", funcName, - buffer_mem_barrier_count, active_subpass, rp_handle); - } - const auto &sub_src_access_mask = sub_dep.srcAccessMask; - const auto &sub_dst_access_mask = sub_dep.dstAccessMask; - for (uint32_t i = 0; i < mem_barrier_count; ++i) { - const auto &mb_src_access_mask = mem_barriers[i].srcAccessMask; - if (mb_src_access_mask != (sub_src_access_mask & mb_src_access_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, rp_handle, VALIDATION_ERROR_1b80092e, - "%s: Barrier pMemoryBarriers[%d].srcAccessMask(0x%X) is not a subset of VkSubpassDependency " - "srcAccessMask(0x%X) of subpass %d of renderPass 0x%" PRIx64 ".", - funcName, i, mb_src_access_mask, sub_src_access_mask, active_subpass, rp_handle); - } - const auto &mb_dst_access_mask = mem_barriers[i].dstAccessMask; - if (mb_dst_access_mask != (sub_dst_access_mask & mb_dst_access_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, rp_handle, VALIDATION_ERROR_1b800930, - "%s: Barrier pMemoryBarriers[%d].dstAccessMask(0x%X) is not a subset of VkSubpassDependency " - "dstAccessMask(0x%X) of subpass %d of renderPass 0x%" PRIx64 ".", - funcName, i, mb_dst_access_mask, sub_dst_access_mask, active_subpass, rp_handle); - } - } - skip |= ValidateRenderPassImageBarriers(device_data, funcName, cb_state, active_subpass, sub_desc, rp_handle, - sub_src_access_mask, sub_dst_access_mask, image_mem_barrier_count, image_barriers); - if (sub_dep.dependencyFlags != dependency_flags) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - rp_handle, VALIDATION_ERROR_1b800932, - "%s: dependencyFlags param (0x%X) does not equal VkSubpassDependency dependencyFlags value (0x%X) for " - "subpass %d of renderPass 0x%" PRIx64 ".", - funcName, dependency_flags, sub_dep.dependencyFlags, cb_state->activeSubpass, rp_handle); - } - } - return skip; -} - -// Array to mask individual accessMask to corresponding stageMask -// accessMask active bit position (0-31) maps to index -const static VkPipelineStageFlags AccessMaskToPipeStage[20] = { - // VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0 - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, - // VK_ACCESS_INDEX_READ_BIT = 1 - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, - // VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 2 - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, - // VK_ACCESS_UNIFORM_READ_BIT = 3 - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - // VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 4 - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - // VK_ACCESS_SHADER_READ_BIT = 5 - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - // VK_ACCESS_SHADER_WRITE_BIT = 6 - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - // VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 7 - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - // VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 8 - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - // VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 9 - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, - // VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 10 - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, - // VK_ACCESS_TRANSFER_READ_BIT = 11 - VK_PIPELINE_STAGE_TRANSFER_BIT, - // VK_ACCESS_TRANSFER_WRITE_BIT = 12 - VK_PIPELINE_STAGE_TRANSFER_BIT, - // VK_ACCESS_HOST_READ_BIT = 13 - VK_PIPELINE_STAGE_HOST_BIT, - // VK_ACCESS_HOST_WRITE_BIT = 14 - VK_PIPELINE_STAGE_HOST_BIT, - // VK_ACCESS_MEMORY_READ_BIT = 15 - VK_ACCESS_FLAG_BITS_MAX_ENUM, // Always match - // VK_ACCESS_MEMORY_WRITE_BIT = 16 - VK_ACCESS_FLAG_BITS_MAX_ENUM, // Always match - // VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 17 - VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX, - // VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 18 - VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX, -}; - -// Verify that all bits of access_mask are supported by the src_stage_mask -static bool ValidateAccessMaskPipelineStage(VkAccessFlags access_mask, VkPipelineStageFlags stage_mask) { - // Early out if all commands set, or access_mask NULL - if ((stage_mask & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) || (0 == access_mask)) return true; - - stage_mask = ExpandPipelineStageFlags(stage_mask); - int index = 0; - // for each of the set bits in access_mask, make sure that supporting stage mask bit(s) are set - while (access_mask) { - index = (u_ffs(access_mask) - 1); - assert(index >= 0); - // Must have "!= 0" compare to prevent warning from MSVC - if ((AccessMaskToPipeStage[index] & stage_mask) == 0) return false; // early out - access_mask &= ~(1 << index); // Mask off bit that's been checked - } - return true; -} - -namespace barrier_queue_families { -enum VuIndex { - kSrcOrDstMustBeIgnore, - kSpecialOrIgnoreOnly, - kSrcIgnoreRequiresDstIgnore, - kDstValidOrSpecialIfNotIgnore, - kSrcValidOrSpecialIfNotIgnore, - kSrcAndDestMustBeIgnore, - kBothIgnoreOrBothValid, - kSubmitQueueMustMatchSrcOrDst -}; -static const char *vu_summary[] = {"Source or destination queue family must be ignored.", - "Source or destination queue family must be special or ignored.", - "Destination queue family must be ignored if source queue family is.", - "Destination queue family must be valid, ignored, or special.", - "Source queue family must be valid, ignored, or special.", - "Source and destination queue family must both be ignored.", - "Source and destination queue family must both be ignore or both valid.", - "Source or destination queue family must match submit queue family, if not ignored."}; - -static const UNIQUE_VALIDATION_ERROR_CODE image_error_codes[] = { - VALIDATION_ERROR_0a000aca, // VUID-VkImageMemoryBarrier-image-01381 -- kSrcOrDstMustBeIgnore - VALIDATION_ERROR_0a000dcc, // VUID-VkImageMemoryBarrier-image-01766 -- kSpecialOrIgnoreOnly - VALIDATION_ERROR_0a000962, // VUID-VkImageMemoryBarrier-image-01201 -- kSrcIgnoreRequiresDstIgnore - VALIDATION_ERROR_0a000dd0, // VUID-VkImageMemoryBarrier-image-01768 -- kDstValidOrSpecialIfNotIgnore - VALIDATION_ERROR_0a000dce, // VUID-VkImageMemoryBarrier-image-01767 -- kSrcValidOrSpecialIfNotIgnore - VALIDATION_ERROR_0a00095e, // VUID-VkImageMemoryBarrier-image-01199 -- kSrcAndDestMustBeIgnore - VALIDATION_ERROR_0a000960, // VUID-VkImageMemoryBarrier-image-01200 -- kBothIgnoreOrBothValid - VALIDATION_ERROR_0a00096a, // VUID-VkImageMemoryBarrier-image-01205 -- kSubmitQueueMustMatchSrcOrDst -}; - -static const UNIQUE_VALIDATION_ERROR_CODE buffer_error_codes[] = { - VALIDATION_ERROR_0180094e, // VUID-VkBufferMemoryBarrier-buffer-01191 -- kSrcOrDstMustBeIgnore - VALIDATION_ERROR_01800dc6, // VUID-VkBufferMemoryBarrier-buffer-01763 -- kSpecialOrIgnoreOnly - VALIDATION_ERROR_01800952, // VUID-VkBufferMemoryBarrier-buffer-01193 -- kSrcIgnoreRequiresDstIgnore - VALIDATION_ERROR_01800dca, // VUID-VkBufferMemoryBarrier-buffer-01765 -- kDstValidOrSpecialIfNotIgnore - VALIDATION_ERROR_01800dc8, // VUID-VkBufferMemoryBarrier-buffer-01764 -- kSrcValidOrSpecialIfNotIgnore - VALIDATION_ERROR_0180094c, // VUID-VkBufferMemoryBarrier-buffer-01190 -- kSrcAndDestMustBeIgnore - VALIDATION_ERROR_01800950, // VUID-VkBufferMemoryBarrier-buffer-01192 -- kBothIgnoreOrBothValid - VALIDATION_ERROR_01800958, // VUID-VkBufferMemoryBarrier-buffer-01196 -- kSubmitQueueMustMatchSrcOrDst -}; - -class ValidatorState { - public: - ValidatorState(const layer_data *device_data, const char *func_name, const GLOBAL_CB_NODE *cb_state, - const uint64_t barrier_handle64, const VkSharingMode sharing_mode, const VulkanObjectType object_type, - const UNIQUE_VALIDATION_ERROR_CODE *val_codes) - : report_data_(device_data->report_data), - func_name_(func_name), - cb_handle64_(HandleToUint64(cb_state->commandBuffer)), - barrier_handle64_(barrier_handle64), - sharing_mode_(sharing_mode), - object_type_(object_type), - val_codes_(val_codes), - limit_(static_cast(device_data->phys_dev_properties.queue_family_properties.size())), - mem_ext_(device_data->extensions.vk_khr_external_memory) {} - - // Create a validator state from an image state... reducing the image specific to the generic version. - ValidatorState(const layer_data *device_data, const char *func_name, const GLOBAL_CB_NODE *cb_state, - const VkImageMemoryBarrier *barrier, const IMAGE_STATE *state) - : ValidatorState(device_data, func_name, cb_state, HandleToUint64(barrier->image), state->createInfo.sharingMode, - kVulkanObjectTypeImage, image_error_codes) {} - - // Create a validator state from an buffer state... reducing the buffer specific to the generic version. - ValidatorState(const layer_data *device_data, const char *func_name, const GLOBAL_CB_NODE *cb_state, - const VkBufferMemoryBarrier *barrier, const BUFFER_STATE *state) - : ValidatorState(device_data, func_name, cb_state, HandleToUint64(barrier->buffer), state->createInfo.sharingMode, - kVulkanObjectTypeImage, buffer_error_codes) {} - - // Log the messages using boilerplate from object state, and Vu specific information from the template arg - // One and two family versions, in the single family version, Vu holds the name of the passed parameter - bool LogMsg(VuIndex vu_index, uint32_t family, const char *param_name) const { - const UNIQUE_VALIDATION_ERROR_CODE val_code = val_codes_[vu_index]; - const char *annotation = GetFamilyAnnotation(family); - return log_msg(report_data_, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, cb_handle64_, - val_code, "%s: Barrier using %s 0x%" PRIx64 " created with sharingMode %s, has %s %u%s. %s", func_name_, - GetTypeString(), barrier_handle64_, GetModeString(), param_name, family, annotation, vu_summary[vu_index]); - } - - bool LogMsg(VuIndex vu_index, uint32_t src_family, uint32_t dst_family) const { - const UNIQUE_VALIDATION_ERROR_CODE val_code = val_codes_[vu_index]; - const char *src_annotation = GetFamilyAnnotation(src_family); - const char *dst_annotation = GetFamilyAnnotation(dst_family); - return log_msg(report_data_, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, cb_handle64_, - val_code, - "%s: Barrier using %s 0x%" PRIx64 - " created with sharingMode %s, has srcQueueFamilyIndex %u%s and dstQueueFamilyIndex %u%s. %s", - func_name_, GetTypeString(), barrier_handle64_, GetModeString(), src_family, src_annotation, dst_family, - dst_annotation, vu_summary[vu_index]); - } - - // This abstract Vu can only be tested at submit time, thus we need a callback from the closure containing the needed - // data. Note that the mem_barrier is copied to the closure as the lambda lifespan exceed the guarantees of validity for - // application input. - static bool ValidateAtQueueSubmit(const VkQueue queue, const layer_data *device_data, uint32_t src_family, uint32_t dst_family, - const ValidatorState &val) { - auto queue_data_it = device_data->queueMap.find(queue); - if (queue_data_it == device_data->queueMap.end()) return false; - - uint32_t queue_family = queue_data_it->second.queueFamilyIndex; - if ((src_family != queue_family) && (dst_family != queue_family)) { - const UNIQUE_VALIDATION_ERROR_CODE val_code = val.val_codes_[kSubmitQueueMustMatchSrcOrDst]; - const char *src_annotation = val.GetFamilyAnnotation(src_family); - const char *dst_annotation = val.GetFamilyAnnotation(dst_family); - return log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - HandleToUint64(queue), val_code, - "%s: Barrier submitted to queue with family index %u, using %s 0x%" PRIx64 - " created with sharingMode %s, has srcQueueFamilyIndex %u%s and dstQueueFamilyIndex %u%s. %s", - "vkQueueSubmit", queue_family, val.GetTypeString(), val.barrier_handle64_, val.GetModeString(), - src_family, src_annotation, dst_family, dst_annotation, vu_summary[kSubmitQueueMustMatchSrcOrDst]); - } - return false; - } - // Logical helpers for semantic clarity - inline bool KhrExternalMem() const { return mem_ext_; } - inline bool IsValid(uint32_t queue_family) const { return (queue_family < limit_); } - inline bool IsSpecial(uint32_t queue_family) const { - return (queue_family == VK_QUEUE_FAMILY_EXTERNAL_KHR) || (queue_family == VK_QUEUE_FAMILY_FOREIGN_EXT); - } - inline bool IsValidOrSpecial(uint32_t queue_family) const { - return IsValid(queue_family) || (mem_ext_ && IsSpecial(queue_family)); - } - inline bool IsIgnored(uint32_t queue_family) const { return queue_family == VK_QUEUE_FAMILY_IGNORED; } - - // Helpers for LogMsg (and log_msg) - const char *GetModeString() const { return string_VkSharingMode(sharing_mode_); } - - // Descriptive text for the various types of queue family index - const char *GetFamilyAnnotation(uint32_t family) const { - const char *external = " (VK_QUEUE_FAMILY_EXTERNAL_KHR)"; - const char *foreign = " (VK_QUEUE_FAMILY_FOREIGN_EXT)"; - const char *ignored = " (VK_QUEUE_FAMILY_IGNORED)"; - const char *valid = " (VALID)"; - const char *invalid = " (INVALID)"; - switch (family) { - case VK_QUEUE_FAMILY_EXTERNAL_KHR: - return external; - case VK_QUEUE_FAMILY_FOREIGN_EXT: - return foreign; - case VK_QUEUE_FAMILY_IGNORED: - return ignored; - default: - if (IsValid(family)) { - return valid; - } - return invalid; - }; - } - const char *GetTypeString() const { return object_string[object_type_]; } - VkSharingMode GetSharingMode() const { return sharing_mode_; } - - protected: - const debug_report_data *const report_data_; - const char *const func_name_; - const uint64_t cb_handle64_; - const uint64_t barrier_handle64_; - const VkSharingMode sharing_mode_; - const VulkanObjectType object_type_; - const UNIQUE_VALIDATION_ERROR_CODE *val_codes_; - const uint32_t limit_; - const bool mem_ext_; -}; - -bool Validate(const layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state, const ValidatorState &val, - const uint32_t src_queue_family, const uint32_t dst_queue_family) { - bool skip = false; - - const bool mode_concurrent = val.GetSharingMode() == VK_SHARING_MODE_CONCURRENT; - const bool src_ignored = val.IsIgnored(src_queue_family); - const bool dst_ignored = val.IsIgnored(dst_queue_family); - if (val.KhrExternalMem()) { - if (mode_concurrent) { - if (!(src_ignored || dst_ignored)) { - skip |= val.LogMsg(kSrcOrDstMustBeIgnore, src_queue_family, dst_queue_family); - } - if ((src_ignored && !(dst_ignored || val.IsSpecial(dst_queue_family))) || - (dst_ignored && !(src_ignored || val.IsSpecial(src_queue_family)))) { - skip |= val.LogMsg(kSpecialOrIgnoreOnly, src_queue_family, dst_queue_family); - } - } else { - // VK_SHARING_MODE_EXCLUSIVE - if (src_ignored && !dst_ignored) { - skip |= val.LogMsg(kSrcIgnoreRequiresDstIgnore, src_queue_family, dst_queue_family); - } - if (!dst_ignored && !val.IsValidOrSpecial(dst_queue_family)) { - skip |= val.LogMsg(kDstValidOrSpecialIfNotIgnore, dst_queue_family, "dstQueueFamilyIndex"); - } - if (!src_ignored && !val.IsValidOrSpecial(src_queue_family)) { - skip |= val.LogMsg(kSrcValidOrSpecialIfNotIgnore, src_queue_family, "srcQueueFamilyIndex"); - } - } - } else { - // No memory extension - if (mode_concurrent) { - if (!src_ignored || !dst_ignored) { - skip |= val.LogMsg(kSrcAndDestMustBeIgnore, src_queue_family, dst_queue_family); - } - } else { - // VK_SHARING_MODE_EXCLUSIVE - if (!((src_ignored && dst_ignored) || (val.IsValid(src_queue_family) && val.IsValid(dst_queue_family)))) { - skip |= val.LogMsg(kBothIgnoreOrBothValid, src_queue_family, dst_queue_family); - } - } - } - if (!mode_concurrent && !src_ignored && !dst_ignored) { - // Only enqueue submit time check if it is needed. If more submit time checks are added, change the criteria - // TODO create a better named list, or rename the submit time lists to something that matches the broader usage... - // Note: if we want to create a semantic that separates state lookup, validation, and state update this should go - // to a local queue of update_state_actions or something. - cb_state->eventUpdates.emplace_back([device_data, src_queue_family, dst_queue_family, val](VkQueue queue) { - return ValidatorState::ValidateAtQueueSubmit(queue, device_data, src_queue_family, dst_queue_family, val); - }); - } - return skip; -} -} // namespace barrier_queue_families - -// Type specific wrapper for image barriers -bool ValidateBarrierQueueFamilies(const layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state, - const VkImageMemoryBarrier *barrier, const IMAGE_STATE *state_data) { - // State data is required - if (!state_data) { - return false; - } - - // Create the validator state from the image state - barrier_queue_families::ValidatorState val(device_data, func_name, cb_state, barrier, state_data); - const uint32_t src_queue_family = barrier->srcQueueFamilyIndex; - const uint32_t dst_queue_family = barrier->dstQueueFamilyIndex; - return barrier_queue_families::Validate(device_data, func_name, cb_state, val, src_queue_family, dst_queue_family); -} - -// Type specific wrapper for buffer barriers -bool ValidateBarrierQueueFamilies(const layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state, - const VkBufferMemoryBarrier *barrier, const BUFFER_STATE *state_data) { - // State data is required - if (!state_data) { - return false; - } - - // Create the validator state from the buffer state - barrier_queue_families::ValidatorState val(device_data, func_name, cb_state, barrier, state_data); - const uint32_t src_queue_family = barrier->srcQueueFamilyIndex; - const uint32_t dst_queue_family = barrier->dstQueueFamilyIndex; - return barrier_queue_families::Validate(device_data, func_name, cb_state, val, src_queue_family, dst_queue_family); -} - -static bool ValidateBarriers(layer_data *device_data, const char *funcName, GLOBAL_CB_NODE *cb_state, - VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask, uint32_t memBarrierCount, - const VkMemoryBarrier *pMemBarriers, uint32_t bufferBarrierCount, - const VkBufferMemoryBarrier *pBufferMemBarriers, uint32_t imageMemBarrierCount, - const VkImageMemoryBarrier *pImageMemBarriers) { - bool skip = false; - for (uint32_t i = 0; i < memBarrierCount; ++i) { - const auto &mem_barrier = pMemBarriers[i]; - if (!ValidateAccessMaskPipelineStage(mem_barrier.srcAccessMask, src_stage_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_1b800940, - "%s: pMemBarriers[%d].srcAccessMask (0x%X) is not supported by srcStageMask (0x%X).", funcName, i, - mem_barrier.srcAccessMask, src_stage_mask); - } - if (!ValidateAccessMaskPipelineStage(mem_barrier.dstAccessMask, dst_stage_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_1b800942, - "%s: pMemBarriers[%d].dstAccessMask (0x%X) is not supported by dstStageMask (0x%X).", funcName, i, - mem_barrier.dstAccessMask, dst_stage_mask); - } - } - for (uint32_t i = 0; i < imageMemBarrierCount; ++i) { - auto mem_barrier = &pImageMemBarriers[i]; - if (!ValidateAccessMaskPipelineStage(mem_barrier->srcAccessMask, src_stage_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_1b800940, - "%s: pImageMemBarriers[%d].srcAccessMask (0x%X) is not supported by srcStageMask (0x%X).", funcName, i, - mem_barrier->srcAccessMask, src_stage_mask); - } - if (!ValidateAccessMaskPipelineStage(mem_barrier->dstAccessMask, dst_stage_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_1b800942, - "%s: pImageMemBarriers[%d].dstAccessMask (0x%X) is not supported by dstStageMask (0x%X).", funcName, i, - mem_barrier->dstAccessMask, dst_stage_mask); - } - - auto image_data = GetImageState(device_data, mem_barrier->image); - skip |= ValidateBarrierQueueFamilies(device_data, funcName, cb_state, mem_barrier, image_data); - - if (mem_barrier->newLayout == VK_IMAGE_LAYOUT_UNDEFINED || mem_barrier->newLayout == VK_IMAGE_LAYOUT_PREINITIALIZED) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_0a00095c, - "%s: Image Layout cannot be transitioned to UNDEFINED or PREINITIALIZED.", funcName); - } - - if (image_data) { - // There is no VUID for this, but there is blanket text: - // "Non-sparse resources must be bound completely and contiguously to a single VkDeviceMemory object before - // recording commands in a command buffer." - // TODO: Update this when VUID is defined - skip |= ValidateMemoryIsBoundToImage(device_data, image_data, funcName, VALIDATION_ERROR_UNDEFINED); - - auto aspect_mask = mem_barrier->subresourceRange.aspectMask; - skip |= ValidateImageAspectMask(device_data, image_data->image, image_data->createInfo.format, aspect_mask, funcName); - - std::string param_name = "pImageMemoryBarriers[" + std::to_string(i) + "].subresourceRange"; - skip |= ValidateImageBarrierSubresourceRange(device_data, image_data, mem_barrier->subresourceRange, funcName, - param_name.c_str()); - } - } - - for (uint32_t i = 0; i < bufferBarrierCount; ++i) { - auto mem_barrier = &pBufferMemBarriers[i]; - if (!mem_barrier) continue; - - if (!ValidateAccessMaskPipelineStage(mem_barrier->srcAccessMask, src_stage_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_1b800940, - "%s: pBufferMemBarriers[%d].srcAccessMask (0x%X) is not supported by srcStageMask (0x%X).", funcName, i, - mem_barrier->srcAccessMask, src_stage_mask); - } - if (!ValidateAccessMaskPipelineStage(mem_barrier->dstAccessMask, dst_stage_mask)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_1b800942, - "%s: pBufferMemBarriers[%d].dstAccessMask (0x%X) is not supported by dstStageMask (0x%X).", funcName, i, - mem_barrier->dstAccessMask, dst_stage_mask); - } - // Validate buffer barrier queue family indices - auto buffer_state = GetBufferState(device_data, mem_barrier->buffer); - skip |= ValidateBarrierQueueFamilies(device_data, funcName, cb_state, mem_barrier, buffer_state); - - if (buffer_state) { - // There is no VUID for this, but there is blanket text: - // "Non-sparse resources must be bound completely and contiguously to a single VkDeviceMemory object before - // recording commands in a command buffer" - // TODO: Update this when VUID is defined - skip |= ValidateMemoryIsBoundToBuffer(device_data, buffer_state, funcName, VALIDATION_ERROR_UNDEFINED); - - auto buffer_size = buffer_state->createInfo.size; - if (mem_barrier->offset >= buffer_size) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_01800946, - "%s: Buffer Barrier 0x%" PRIx64 " has offset 0x%" PRIx64 " which is not less than total size 0x%" PRIx64 ".", - funcName, HandleToUint64(mem_barrier->buffer), HandleToUint64(mem_barrier->offset), - HandleToUint64(buffer_size)); - } else if (mem_barrier->size != VK_WHOLE_SIZE && (mem_barrier->offset + mem_barrier->size > buffer_size)) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(cb_state->commandBuffer), VALIDATION_ERROR_0180094a, - "%s: Buffer Barrier 0x%" PRIx64 " has offset 0x%" PRIx64 " and size 0x%" PRIx64 - " whose sum is greater than total size 0x%" PRIx64 ".", - funcName, HandleToUint64(mem_barrier->buffer), HandleToUint64(mem_barrier->offset), - HandleToUint64(mem_barrier->size), HandleToUint64(buffer_size)); - } - } - } - return skip; -} - -bool validateEventStageMask(VkQueue queue, GLOBAL_CB_NODE *pCB, uint32_t eventCount, size_t firstEventIndex, - VkPipelineStageFlags sourceStageMask) { - bool skip = false; - VkPipelineStageFlags stageMask = 0; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - for (uint32_t i = 0; i < eventCount; ++i) { - auto event = pCB->events[firstEventIndex + i]; - auto queue_data = dev_data->queueMap.find(queue); - if (queue_data == dev_data->queueMap.end()) return false; - auto event_data = queue_data->second.eventToStageMap.find(event); - if (event_data != queue_data->second.eventToStageMap.end()) { - stageMask |= event_data->second; - } else { - auto global_event_data = GetEventNode(dev_data, event); - if (!global_event_data) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, - HandleToUint64(event), DRAWSTATE_INVALID_EVENT, - "Event 0x%" PRIx64 " cannot be waited on if it has never been set.", HandleToUint64(event)); - } else { - stageMask |= global_event_data->stageMask; - } - } - } - // TODO: Need to validate that host_bit is only set if set event is called - // but set event can be called at any time. - if (sourceStageMask != stageMask && sourceStageMask != (stageMask | VK_PIPELINE_STAGE_HOST_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), VALIDATION_ERROR_1e62d401, - "Submitting cmdbuffer with call to VkCmdWaitEvents using srcStageMask 0x%X which must be the bitwise OR of " - "the stageMask parameters used in calls to vkCmdSetEvent and VK_PIPELINE_STAGE_HOST_BIT if used with " - "vkSetEvent but instead is 0x%X.", - sourceStageMask, stageMask); - } - return skip; -} - -// Note that we only check bits that HAVE required queueflags -- don't care entries are skipped -static std::unordered_map supported_pipeline_stages_table = { - {VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX, VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT}, - {VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT}, - {VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_QUEUE_GRAPHICS_BIT}, - {VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_QUEUE_COMPUTE_BIT}, - {VK_PIPELINE_STAGE_TRANSFER_BIT, VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT}, - {VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_QUEUE_GRAPHICS_BIT}}; - -static const VkPipelineStageFlags stage_flag_bit_array[] = {VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX, - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, - VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, - VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_TRANSFER_BIT, - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT}; - -bool CheckStageMaskQueueCompatibility(layer_data *dev_data, VkCommandBuffer command_buffer, VkPipelineStageFlags stage_mask, - VkQueueFlags queue_flags, const char *function, const char *src_or_dest, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - // Lookup each bit in the stagemask and check for overlap between its table bits and queue_flags - for (const auto &item : stage_flag_bit_array) { - if (stage_mask & item) { - if ((supported_pipeline_stages_table[item] & queue_flags) == 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(command_buffer), error_code, - "%s(): %s flag %s is not compatible with the queue family properties of this command buffer.", - function, src_or_dest, string_VkPipelineStageFlagBits(static_cast(item))); - } - } - } - return skip; -} - -// Check if all barriers are of a given operation type. -template -static bool AllTransferOp(const COMMAND_POOL_NODE *pool, OpCheck &op_check, uint32_t count, const Barrier *barriers) { - if (!pool) return false; - - for (uint32_t b = 0; b < count; b++) { - if (!op_check(pool, barriers + b)) return false; - } - return true; -} - -enum BarrierOperationsType { - kAllAcquire, // All Barrier operations are "ownership acquire" operations - kAllRelease, // All Barrier operations are "ownership release" operations - kGeneral, // Either no ownership operations or a mix of ownership operation types and/or non-ownership operations -}; - -// Look at the barriers to see if we they are all release or all acquire, the result impacts queue properties validation -BarrierOperationsType ComputeBarrierOperationsType(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t buffer_barrier_count, - const VkBufferMemoryBarrier *buffer_barriers, uint32_t image_barrier_count, - const VkImageMemoryBarrier *image_barriers) { - auto pool = GetCommandPoolNode(device_data, cb_state->createInfo.commandPool); - BarrierOperationsType op_type = kGeneral; - - // Look at the barrier details only if they exist - // Note: AllTransferOp returns true for count == 0 - if ((buffer_barrier_count + image_barrier_count) != 0) { - if (AllTransferOp(pool, IsReleaseOp, buffer_barrier_count, buffer_barriers) && - AllTransferOp(pool, IsReleaseOp, image_barrier_count, image_barriers)) { - op_type = kAllRelease; - } else if (AllTransferOp(pool, IsAcquireOp, buffer_barrier_count, buffer_barriers) && - AllTransferOp(pool, IsAcquireOp, image_barrier_count, image_barriers)) { - op_type = kAllAcquire; - } - } - - return op_type; -} - -bool ValidateStageMasksAgainstQueueCapabilities(layer_data *dev_data, GLOBAL_CB_NODE const *cb_state, - VkPipelineStageFlags source_stage_mask, VkPipelineStageFlags dest_stage_mask, - BarrierOperationsType barrier_op_type, const char *function, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - uint32_t queue_family_index = dev_data->commandPoolMap[cb_state->createInfo.commandPool].queueFamilyIndex; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dev_data->physical_device), instance_layer_data_map); - auto physical_device_state = GetPhysicalDeviceState(instance_data, dev_data->physical_device); - - // Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family - // specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool - // that commandBuffer was allocated from, as specified in the table of supported pipeline stages. - - if (queue_family_index < physical_device_state->queue_family_properties.size()) { - VkQueueFlags specified_queue_flags = physical_device_state->queue_family_properties[queue_family_index].queueFlags; - - // Only check the source stage mask if any barriers aren't "acquire ownership" - if ((barrier_op_type != kAllAcquire) && (source_stage_mask & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) == 0) { - skip |= CheckStageMaskQueueCompatibility(dev_data, cb_state->commandBuffer, source_stage_mask, specified_queue_flags, - function, "srcStageMask", error_code); - } - // Only check the dest stage mask if any barriers aren't "release ownership" - if ((barrier_op_type != kAllRelease) && (dest_stage_mask & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) == 0) { - skip |= CheckStageMaskQueueCompatibility(dev_data, cb_state->commandBuffer, dest_stage_mask, specified_queue_flags, - function, "dstStageMask", error_code); - } - } - return skip; -} - -VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, - VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - if (cb_state) { - auto barrier_op_type = ComputeBarrierOperationsType(dev_data, cb_state, bufferMemoryBarrierCount, pBufferMemoryBarriers, - imageMemoryBarrierCount, pImageMemoryBarriers); - skip |= ValidateStageMasksAgainstQueueCapabilities(dev_data, cb_state, sourceStageMask, dstStageMask, barrier_op_type, - "vkCmdWaitEvents", VALIDATION_ERROR_1e600918); - skip |= ValidateStageMaskGsTsEnables(dev_data, sourceStageMask, "vkCmdWaitEvents()", VALIDATION_ERROR_1e60090e, - VALIDATION_ERROR_1e600912); - skip |= ValidateStageMaskGsTsEnables(dev_data, dstStageMask, "vkCmdWaitEvents()", VALIDATION_ERROR_1e600910, - VALIDATION_ERROR_1e600914); - skip |= ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdWaitEvents()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_1e602415); - skip |= ValidateCmd(dev_data, cb_state, CMD_WAITEVENTS, "vkCmdWaitEvents()"); - skip |= ValidateBarriersToImages(dev_data, cb_state, imageMemoryBarrierCount, pImageMemoryBarriers, "vkCmdWaitEvents()"); - skip |= ValidateBarriers(dev_data, "vkCmdWaitEvents()", cb_state, sourceStageMask, dstStageMask, memoryBarrierCount, - pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, - pImageMemoryBarriers); - if (!skip) { - auto first_event_index = cb_state->events.size(); - for (uint32_t i = 0; i < eventCount; ++i) { - auto event_state = GetEventNode(dev_data, pEvents[i]); - if (event_state) { - addCommandBufferBinding(&event_state->cb_bindings, {HandleToUint64(pEvents[i]), kVulkanObjectTypeEvent}, - cb_state); - event_state->cb_bindings.insert(cb_state); - } - cb_state->waitedEvents.insert(pEvents[i]); - cb_state->events.push_back(pEvents[i]); - } - cb_state->eventUpdates.emplace_back( - [=](VkQueue q) { return validateEventStageMask(q, cb_state, eventCount, first_event_index, sourceStageMask); }); - TransitionImageLayouts(dev_data, cb_state, imageMemoryBarrierCount, pImageMemoryBarriers); - } - } - lock.unlock(); - if (!skip) - dev_data->dispatch_table.CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, - memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, - imageMemoryBarrierCount, pImageMemoryBarriers); -} - -static bool PreCallValidateCmdPipelineBarrier(layer_data *device_data, GLOBAL_CB_NODE *cb_state, VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { - bool skip = false; - auto barrier_op_type = ComputeBarrierOperationsType(device_data, cb_state, bufferMemoryBarrierCount, pBufferMemoryBarriers, - imageMemoryBarrierCount, pImageMemoryBarriers); - skip |= ValidateStageMasksAgainstQueueCapabilities(device_data, cb_state, srcStageMask, dstStageMask, barrier_op_type, - "vkCmdPipelineBarrier", VALIDATION_ERROR_1b80093e); - skip |= ValidateCmdQueueFlags(device_data, cb_state, "vkCmdPipelineBarrier()", - VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, VALIDATION_ERROR_1b802415); - skip |= ValidateCmd(device_data, cb_state, CMD_PIPELINEBARRIER, "vkCmdPipelineBarrier()"); - skip |= ValidateStageMaskGsTsEnables(device_data, srcStageMask, "vkCmdPipelineBarrier()", VALIDATION_ERROR_1b800920, - VALIDATION_ERROR_1b800924); - skip |= ValidateStageMaskGsTsEnables(device_data, dstStageMask, "vkCmdPipelineBarrier()", VALIDATION_ERROR_1b800922, - VALIDATION_ERROR_1b800926); - if (cb_state->activeRenderPass) { - skip |= ValidateRenderPassPipelineBarriers(device_data, "vkCmdPipelineBarrier()", cb_state, srcStageMask, dstStageMask, - dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, - pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - if (skip) return true; // Early return to avoid redundant errors from below calls - } - skip |= - ValidateBarriersToImages(device_data, cb_state, imageMemoryBarrierCount, pImageMemoryBarriers, "vkCmdPipelineBarrier()"); - skip |= ValidateBarriers(device_data, "vkCmdPipelineBarrier()", cb_state, srcStageMask, dstStageMask, memoryBarrierCount, - pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, - pImageMemoryBarriers); - return skip; -} - -static void PreCallRecordCmdPipelineBarrier(layer_data *device_data, GLOBAL_CB_NODE *cb_state, VkCommandBuffer commandBuffer, - uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { - TransitionImageLayouts(device_data, cb_state, imageMemoryBarrierCount, pImageMemoryBarriers); -} - -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) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_state = GetCBNode(device_data, commandBuffer); - if (cb_state) { - skip |= PreCallValidateCmdPipelineBarrier(device_data, cb_state, srcStageMask, dstStageMask, dependencyFlags, - memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, - pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - if (!skip) { - PreCallRecordCmdPipelineBarrier(device_data, cb_state, commandBuffer, imageMemoryBarrierCount, pImageMemoryBarriers); - } - } else { - assert(0); - } - lock.unlock(); - if (!skip) { - device_data->dispatch_table.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, - memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, - pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - } -} - -static bool setQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject object, bool value) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - pCB->queryToStateMap[object] = value; - } - auto queue_data = dev_data->queueMap.find(queue); - if (queue_data != dev_data->queueMap.end()) { - queue_data->second.queryToStateMap[object] = value; - } - return false; -} - -VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdBeginQuery()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_17802415); - skip |= ValidateCmd(dev_data, pCB, CMD_BEGINQUERY, "vkCmdBeginQuery()"); - } - lock.unlock(); - - if (skip) return; - - dev_data->dispatch_table.CmdBeginQuery(commandBuffer, queryPool, slot, flags); - - lock.lock(); - if (pCB) { - QueryObject query = {queryPool, slot}; - pCB->activeQueries.insert(query); - pCB->startedQueries.insert(query); - addCommandBufferBinding(&GetQueryPoolNode(dev_data, queryPool)->cb_bindings, - {HandleToUint64(queryPool), kVulkanObjectTypeQueryPool}, pCB); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - QueryObject query = {queryPool, slot}; - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - if (cb_state) { - if (!cb_state->activeQueries.count(query)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1ae00f06, - "Ending a query before it was started: queryPool 0x%" PRIx64 ", index %d.", HandleToUint64(queryPool), - slot); - } - skip |= ValidateCmdQueueFlags(dev_data, cb_state, "VkCmdEndQuery()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_1ae02415); - skip |= ValidateCmd(dev_data, cb_state, CMD_ENDQUERY, "VkCmdEndQuery()"); - } - lock.unlock(); - - if (skip) return; - - dev_data->dispatch_table.CmdEndQuery(commandBuffer, queryPool, slot); - - lock.lock(); - if (cb_state) { - cb_state->activeQueries.erase(query); - cb_state->queryUpdates.emplace_back([=](VkQueue q) { return setQueryState(q, commandBuffer, query, true); }); - addCommandBufferBinding(&GetQueryPoolNode(dev_data, queryPool)->cb_bindings, - {HandleToUint64(queryPool), kVulkanObjectTypeQueryPool}, cb_state); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, - uint32_t queryCount) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - skip |= insideRenderPass(dev_data, cb_state, "vkCmdResetQueryPool()", VALIDATION_ERROR_1c600017); - skip |= ValidateCmd(dev_data, cb_state, CMD_RESETQUERYPOOL, "VkCmdResetQueryPool()"); - skip |= ValidateCmdQueueFlags(dev_data, cb_state, "VkCmdResetQueryPool()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_1c602415); - lock.unlock(); - - if (skip) return; - - dev_data->dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); - - lock.lock(); - for (uint32_t i = 0; i < queryCount; i++) { - QueryObject query = {queryPool, firstQuery + i}; - cb_state->waitedEventsBeforeQueryReset[query] = cb_state->waitedEvents; - cb_state->queryUpdates.emplace_back([=](VkQueue q) { return setQueryState(q, commandBuffer, query, false); }); - } - addCommandBufferBinding(&GetQueryPoolNode(dev_data, queryPool)->cb_bindings, - {HandleToUint64(queryPool), kVulkanObjectTypeQueryPool}, cb_state); -} - -static bool IsQueryInvalid(layer_data *dev_data, QUEUE_STATE *queue_data, VkQueryPool queryPool, uint32_t queryIndex) { - QueryObject query = {queryPool, queryIndex}; - auto query_data = queue_data->queryToStateMap.find(query); - if (query_data != queue_data->queryToStateMap.end()) { - if (!query_data->second) return true; - } else { - auto it = dev_data->queryToStateMap.find(query); - if (it == dev_data->queryToStateMap.end() || !it->second) return true; - } - - return false; -} - -static bool validateQuery(VkQueue queue, GLOBAL_CB_NODE *pCB, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(pCB->commandBuffer), layer_data_map); - auto queue_data = GetQueueState(dev_data, queue); - if (!queue_data) return false; - for (uint32_t i = 0; i < queryCount; i++) { - if (IsQueryInvalid(dev_data, queue_data, queryPool, firstQuery + i)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_QUERY, - "Requesting a copy from query to buffer with invalid query: queryPool 0x%" PRIx64 ", index %d", - HandleToUint64(queryPool), firstQuery + i); - } - } - return skip; -} - -VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, - uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, - VkDeviceSize stride, VkQueryResultFlags flags) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - - auto cb_node = GetCBNode(dev_data, commandBuffer); - auto dst_buff_state = GetBufferState(dev_data, dstBuffer); - if (cb_node && dst_buff_state) { - skip |= ValidateMemoryIsBoundToBuffer(dev_data, dst_buff_state, "vkCmdCopyQueryPoolResults()", VALIDATION_ERROR_19400674); - // Validate that DST buffer has correct usage flags set - skip |= - ValidateBufferUsageFlags(dev_data, dst_buff_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, VALIDATION_ERROR_19400672, - "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); - skip |= ValidateCmdQueueFlags(dev_data, cb_node, "vkCmdCopyQueryPoolResults()", - VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, VALIDATION_ERROR_19402415); - skip |= ValidateCmd(dev_data, cb_node, CMD_COPYQUERYPOOLRESULTS, "vkCmdCopyQueryPoolResults()"); - skip |= insideRenderPass(dev_data, cb_node, "vkCmdCopyQueryPoolResults()", VALIDATION_ERROR_19400017); - } - lock.unlock(); - - if (skip) return; - - dev_data->dispatch_table.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, - flags); - - lock.lock(); - if (cb_node && dst_buff_state) { - AddCommandBufferBindingBuffer(dev_data, cb_node, dst_buff_state); - cb_node->queryUpdates.emplace_back([=](VkQueue q) { return validateQuery(q, cb_node, queryPool, firstQuery, queryCount); }); - addCommandBufferBinding(&GetQueryPoolNode(dev_data, queryPool)->cb_bindings, - {HandleToUint64(queryPool), kVulkanObjectTypeQueryPool}, cb_node); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, - uint32_t offset, uint32_t size, const void *pValues) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - if (cb_state) { - skip |= ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdPushConstants()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, - VALIDATION_ERROR_1bc02415); - skip |= ValidateCmd(dev_data, cb_state, CMD_PUSHCONSTANTS, "vkCmdPushConstants()"); - } - skip |= validatePushConstantRange(dev_data, offset, size, "vkCmdPushConstants()"); - if (0 == stageFlags) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1bc2dc03, "vkCmdPushConstants() call has no stageFlags set."); - } - - // Check if pipeline_layout VkPushConstantRange(s) overlapping offset, size have stageFlags set for each stage in the command - // stageFlags argument, *and* that the command stageFlags argument has bits set for the stageFlags in each overlapping range. - if (!skip) { - const auto &ranges = *getPipelineLayout(dev_data, layout)->push_constant_ranges; - VkShaderStageFlags found_stages = 0; - for (const auto &range : ranges) { - if ((offset >= range.offset) && (offset + size <= range.offset + range.size)) { - VkShaderStageFlags matching_stages = range.stageFlags & stageFlags; - if (matching_stages != range.stageFlags) { - // VALIDATION_ERROR_1bc00e08 VUID-vkCmdPushConstants-offset-01796 - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer), - VALIDATION_ERROR_1bc00e08, - "vkCmdPushConstants(): stageFlags (0x%" PRIx32 ", offset (%" PRIu32 "), and size (%" PRIu32 - "), " - "must contain all stages in overlapping VkPushConstantRange stageFlags (0x%" PRIx32 - "), offset (%" PRIu32 "), and size (%" PRIu32 ") in pipeline layout 0x%" PRIx64 ".", - (uint32_t)stageFlags, offset, size, (uint32_t)range.stageFlags, range.offset, range.size, - HandleToUint64(layout)); - } - - // Accumulate all stages we've found - found_stages = matching_stages | found_stages; - } - } - if (found_stages != stageFlags) { - // VALIDATION_ERROR_1bc00e06 VUID-vkCmdPushConstants-offset-01795 - uint32_t missing_stages = ~found_stages & stageFlags; - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1bc00e06, - "vkCmdPushConstants(): stageFlags = 0x%" PRIx32 ", VkPushConstantRange in pipeline layout 0x%" PRIx64 - " overlapping offset = %d and size = %d, do not contain stageFlags 0x%" PRIx32 ".", - (uint32_t)stageFlags, HandleToUint64(layout), offset, size, missing_stages); - } - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); -} - -VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, uint32_t slot) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - if (cb_state) { - skip |= - ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdWriteTimestamp()", - VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT, VALIDATION_ERROR_1e802415); - skip |= ValidateCmd(dev_data, cb_state, CMD_WRITETIMESTAMP, "vkCmdWriteTimestamp()"); - } - lock.unlock(); - - if (skip) return; - - dev_data->dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot); - - lock.lock(); - if (cb_state) { - QueryObject query = {queryPool, slot}; - cb_state->queryUpdates.emplace_back([=](VkQueue q) { return setQueryState(q, commandBuffer, query, true); }); - } -} - -static bool MatchUsage(layer_data *dev_data, uint32_t count, const VkAttachmentReference *attachments, - const VkFramebufferCreateInfo *fbci, VkImageUsageFlagBits usage_flag, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - - for (uint32_t attach = 0; attach < count; attach++) { - if (attachments[attach].attachment != VK_ATTACHMENT_UNUSED) { - // Attachment counts are verified elsewhere, but prevent an invalid access - if (attachments[attach].attachment < fbci->attachmentCount) { - const VkImageView *image_view = &fbci->pAttachments[attachments[attach].attachment]; - auto view_state = GetImageViewState(dev_data, *image_view); - if (view_state) { - const VkImageCreateInfo *ici = &GetImageState(dev_data, view_state->create_info.image)->createInfo; - if (ici != nullptr) { - if ((ici->usage & usage_flag) == 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, error_code, - "vkCreateFramebuffer: Framebuffer Attachment (%d) conflicts with the image's " - "IMAGE_USAGE flags (%s).", - attachments[attach].attachment, string_VkImageUsageFlagBits(usage_flag)); - } - } - } - } - } - } - return skip; -} - -// Validate VkFramebufferCreateInfo which includes: -// 1. attachmentCount equals renderPass attachmentCount -// 2. corresponding framebuffer and renderpass attachments have matching formats -// 3. corresponding framebuffer and renderpass attachments have matching sample counts -// 4. fb attachments only have a single mip level -// 5. fb attachment dimensions are each at least as large as the fb -// 6. fb attachments use idenity swizzle -// 7. fb attachments used by renderPass for color/input/ds have correct usage bit set -// 8. fb dimensions are within physical device limits -static bool ValidateFramebufferCreateInfo(layer_data *dev_data, const VkFramebufferCreateInfo *pCreateInfo) { - bool skip = false; - - auto rp_state = GetRenderPassState(dev_data, pCreateInfo->renderPass); - if (rp_state) { - const VkRenderPassCreateInfo *rpci = rp_state->createInfo.ptr(); - if (rpci->attachmentCount != pCreateInfo->attachmentCount) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - HandleToUint64(pCreateInfo->renderPass), VALIDATION_ERROR_094006d8, - "vkCreateFramebuffer(): VkFramebufferCreateInfo attachmentCount of %u does not match attachmentCount " - "of %u of renderPass (0x%" PRIx64 ") being used to create Framebuffer.", - pCreateInfo->attachmentCount, rpci->attachmentCount, HandleToUint64(pCreateInfo->renderPass)); - } else { - // attachmentCounts match, so make sure corresponding attachment details line up - const VkImageView *image_views = pCreateInfo->pAttachments; - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - auto view_state = GetImageViewState(dev_data, image_views[i]); - auto &ivci = view_state->create_info; - if (ivci.format != rpci->pAttachments[i].format) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - HandleToUint64(pCreateInfo->renderPass), VALIDATION_ERROR_094006e0, - "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has format of %s that does not " - "match the format of %s used by the corresponding attachment for renderPass (0x%" PRIx64 ").", - i, string_VkFormat(ivci.format), string_VkFormat(rpci->pAttachments[i].format), - HandleToUint64(pCreateInfo->renderPass)); - } - const VkImageCreateInfo *ici = &GetImageState(dev_data, ivci.image)->createInfo; - if (ici->samples != rpci->pAttachments[i].samples) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - HandleToUint64(pCreateInfo->renderPass), VALIDATION_ERROR_094006e2, - "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has %s samples that do not match the %s " - "samples used by the corresponding attachment for renderPass (0x%" PRIx64 ").", - i, string_VkSampleCountFlagBits(ici->samples), string_VkSampleCountFlagBits(rpci->pAttachments[i].samples), - HandleToUint64(pCreateInfo->renderPass)); - } - // Verify that view only has a single mip level - if (ivci.subresourceRange.levelCount != 1) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, VALIDATION_ERROR_094006e6, - "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has mip levelCount of %u but " - "only a single mip level (levelCount == 1) is allowed when creating a Framebuffer.", - i, ivci.subresourceRange.levelCount); - } - const uint32_t mip_level = ivci.subresourceRange.baseMipLevel; - uint32_t mip_width = max(1u, ici->extent.width >> mip_level); - uint32_t mip_height = max(1u, ici->extent.height >> mip_level); - if ((ivci.subresourceRange.layerCount < pCreateInfo->layers) || (mip_width < pCreateInfo->width) || - (mip_height < pCreateInfo->height)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, VALIDATION_ERROR_094006e4, - "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u mip level %u has dimensions " - "smaller than the corresponding framebuffer dimensions. Here are the respective dimensions for " - "attachment #%u, framebuffer:\n" - "width: %u, %u\n" - "height: %u, %u\n" - "layerCount: %u, %u\n", - i, ivci.subresourceRange.baseMipLevel, i, mip_width, pCreateInfo->width, mip_height, - pCreateInfo->height, ivci.subresourceRange.layerCount, pCreateInfo->layers); - } - if (((ivci.components.r != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.r != VK_COMPONENT_SWIZZLE_R)) || - ((ivci.components.g != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.g != VK_COMPONENT_SWIZZLE_G)) || - ((ivci.components.b != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.b != VK_COMPONENT_SWIZZLE_B)) || - ((ivci.components.a != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.a != VK_COMPONENT_SWIZZLE_A))) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, VALIDATION_ERROR_094006e8, - "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has non-identy swizzle. All " - "framebuffer attachments must have been created with the identity swizzle. Here are the actual " - "swizzle values:\n" - "r swizzle = %s\n" - "g swizzle = %s\n" - "b swizzle = %s\n" - "a swizzle = %s\n", - i, string_VkComponentSwizzle(ivci.components.r), string_VkComponentSwizzle(ivci.components.g), - string_VkComponentSwizzle(ivci.components.b), string_VkComponentSwizzle(ivci.components.a)); - } - } - } - // Verify correct attachment usage flags - for (uint32_t subpass = 0; subpass < rpci->subpassCount; subpass++) { - // Verify input attachments: - skip |= - MatchUsage(dev_data, rpci->pSubpasses[subpass].inputAttachmentCount, rpci->pSubpasses[subpass].pInputAttachments, - pCreateInfo, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, VALIDATION_ERROR_094006de); - // Verify color attachments: - skip |= - MatchUsage(dev_data, rpci->pSubpasses[subpass].colorAttachmentCount, rpci->pSubpasses[subpass].pColorAttachments, - pCreateInfo, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VALIDATION_ERROR_094006da); - // Verify depth/stencil attachments: - if (rpci->pSubpasses[subpass].pDepthStencilAttachment != nullptr) { - skip |= MatchUsage(dev_data, 1, rpci->pSubpasses[subpass].pDepthStencilAttachment, pCreateInfo, - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VALIDATION_ERROR_094006dc); - } - } - } - // Verify FB dimensions are within physical device limits - if (pCreateInfo->width > dev_data->phys_dev_properties.properties.limits.maxFramebufferWidth) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_094006ec, - "vkCreateFramebuffer(): Requested VkFramebufferCreateInfo width exceeds physical device limits. Requested " - "width: %u, device max: %u\n", - pCreateInfo->width, dev_data->phys_dev_properties.properties.limits.maxFramebufferWidth); - } - if (pCreateInfo->height > dev_data->phys_dev_properties.properties.limits.maxFramebufferHeight) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_094006f0, - "vkCreateFramebuffer(): Requested VkFramebufferCreateInfo height exceeds physical device limits. Requested " - "height: %u, device max: %u\n", - pCreateInfo->height, dev_data->phys_dev_properties.properties.limits.maxFramebufferHeight); - } - if (pCreateInfo->layers > dev_data->phys_dev_properties.properties.limits.maxFramebufferLayers) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_094006f4, - "vkCreateFramebuffer(): Requested VkFramebufferCreateInfo layers exceeds physical device limits. Requested " - "layers: %u, device max: %u\n", - pCreateInfo->layers, dev_data->phys_dev_properties.properties.limits.maxFramebufferLayers); - } - // Verify FB dimensions are greater than zero - if (pCreateInfo->width <= 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_094006ea, - "vkCreateFramebuffer(): Requested VkFramebufferCreateInfo width must be greater than zero."); - } - if (pCreateInfo->height <= 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_094006ee, - "vkCreateFramebuffer(): Requested VkFramebufferCreateInfo height must be greater than zero."); - } - if (pCreateInfo->layers <= 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_094006f2, - "vkCreateFramebuffer(): Requested VkFramebufferCreateInfo layers must be greater than zero."); - } - return skip; -} - -// Validate VkFramebufferCreateInfo state prior to calling down chain to create Framebuffer object -// Return true if an error is encountered and callback returns true to skip call down chain -// false indicates that call down chain should proceed -static bool PreCallValidateCreateFramebuffer(layer_data *dev_data, const VkFramebufferCreateInfo *pCreateInfo) { - // TODO : Verify that renderPass FB is created with is compatible with FB - bool skip = false; - skip |= ValidateFramebufferCreateInfo(dev_data, pCreateInfo); - return skip; -} - -// CreateFramebuffer state has been validated and call down chain completed so record new framebuffer object -static void PostCallRecordCreateFramebuffer(layer_data *dev_data, const VkFramebufferCreateInfo *pCreateInfo, VkFramebuffer fb) { - // Shadow create info and store in map - std::unique_ptr fb_state( - new FRAMEBUFFER_STATE(fb, pCreateInfo, GetRenderPassStateSharedPtr(dev_data, pCreateInfo->renderPass))); - - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - VkImageView view = pCreateInfo->pAttachments[i]; - auto view_state = GetImageViewState(dev_data, view); - if (!view_state) { - continue; - } - MT_FB_ATTACHMENT_INFO fb_info; - fb_info.view_state = view_state; - fb_info.image = view_state->create_info.image; - fb_state->attachments.push_back(fb_info); - } - dev_data->frameBufferMap[fb] = std::move(fb_state); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCreateFramebuffer(dev_data, pCreateInfo); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); - - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordCreateFramebuffer(dev_data, pCreateInfo, *pFramebuffer); - lock.unlock(); - } - return result; -} - -static bool FindDependency(const uint32_t index, const uint32_t dependent, const std::vector &subpass_to_node, - std::unordered_set &processed_nodes) { - // If we have already checked this node we have not found a dependency path so return false. - if (processed_nodes.count(index)) return false; - processed_nodes.insert(index); - const DAGNode &node = subpass_to_node[index]; - // Look for a dependency path. If one exists return true else recurse on the previous nodes. - if (std::find(node.prev.begin(), node.prev.end(), dependent) == node.prev.end()) { - for (auto elem : node.prev) { - if (FindDependency(elem, dependent, subpass_to_node, processed_nodes)) return true; - } - } else { - return true; - } - return false; -} - -static bool CheckDependencyExists(const layer_data *dev_data, const uint32_t subpass, - const std::vector &dependent_subpasses, const std::vector &subpass_to_node, - bool &skip) { - bool result = true; - // Loop through all subpasses that share the same attachment and make sure a dependency exists - for (uint32_t k = 0; k < dependent_subpasses.size(); ++k) { - if (static_cast(subpass) == dependent_subpasses[k]) continue; - const DAGNode &node = subpass_to_node[subpass]; - // Check for a specified dependency between the two nodes. If one exists we are done. - auto prev_elem = std::find(node.prev.begin(), node.prev.end(), dependent_subpasses[k]); - auto next_elem = std::find(node.next.begin(), node.next.end(), dependent_subpasses[k]); - if (prev_elem == node.prev.end() && next_elem == node.next.end()) { - // If no dependency exits an implicit dependency still might. If not, throw an error. - std::unordered_set processed_nodes; - if (!(FindDependency(subpass, dependent_subpasses[k], subpass_to_node, processed_nodes) || - FindDependency(dependent_subpasses[k], subpass, subpass_to_node, processed_nodes))) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, - "A dependency between subpasses %d and %d must exist but one is not specified.", subpass, - dependent_subpasses[k]); - result = false; - } - } - } - return result; -} - -static bool CheckPreserved(const layer_data *dev_data, const VkRenderPassCreateInfo *pCreateInfo, const int index, - const uint32_t attachment, const std::vector &subpass_to_node, int depth, bool &skip) { - const DAGNode &node = subpass_to_node[index]; - // If this node writes to the attachment return true as next nodes need to preserve the attachment. - const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[index]; - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - if (attachment == subpass.pColorAttachments[j].attachment) return true; - } - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - if (attachment == subpass.pInputAttachments[j].attachment) return true; - } - if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - if (attachment == subpass.pDepthStencilAttachment->attachment) return true; - } - bool result = false; - // Loop through previous nodes and see if any of them write to the attachment. - for (auto elem : node.prev) { - result |= CheckPreserved(dev_data, pCreateInfo, elem, attachment, subpass_to_node, depth + 1, skip); - } - // If the attachment was written to by a previous node than this node needs to preserve it. - if (result && depth > 0) { - bool has_preserved = false; - for (uint32_t j = 0; j < subpass.preserveAttachmentCount; ++j) { - if (subpass.pPreserveAttachments[j] == attachment) { - has_preserved = true; - break; - } - } - if (!has_preserved) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, - "Attachment %d is used by a later subpass and must be preserved in subpass %d.", attachment, index); - } - } - return result; -} - -template -bool isRangeOverlapping(T offset1, T size1, T offset2, T size2) { - return (((offset1 + size1) > offset2) && ((offset1 + size1) < (offset2 + size2))) || - ((offset1 > offset2) && (offset1 < (offset2 + size2))); -} - -bool isRegionOverlapping(VkImageSubresourceRange range1, VkImageSubresourceRange range2) { - return (isRangeOverlapping(range1.baseMipLevel, range1.levelCount, range2.baseMipLevel, range2.levelCount) && - isRangeOverlapping(range1.baseArrayLayer, range1.layerCount, range2.baseArrayLayer, range2.layerCount)); -} - -static bool ValidateDependencies(const layer_data *dev_data, FRAMEBUFFER_STATE const *framebuffer, - RENDER_PASS_STATE const *renderPass) { - bool skip = false; - auto const pFramebufferInfo = framebuffer->createInfo.ptr(); - auto const pCreateInfo = renderPass->createInfo.ptr(); - auto const &subpass_to_node = renderPass->subpassToNode; - std::vector> output_attachment_to_subpass(pCreateInfo->attachmentCount); - std::vector> input_attachment_to_subpass(pCreateInfo->attachmentCount); - std::vector> overlapping_attachments(pCreateInfo->attachmentCount); - // Find overlapping attachments - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - for (uint32_t j = i + 1; j < pCreateInfo->attachmentCount; ++j) { - VkImageView viewi = pFramebufferInfo->pAttachments[i]; - VkImageView viewj = pFramebufferInfo->pAttachments[j]; - if (viewi == viewj) { - overlapping_attachments[i].push_back(j); - overlapping_attachments[j].push_back(i); - continue; - } - auto view_state_i = GetImageViewState(dev_data, viewi); - auto view_state_j = GetImageViewState(dev_data, viewj); - if (!view_state_i || !view_state_j) { - continue; - } - auto view_ci_i = view_state_i->create_info; - auto view_ci_j = view_state_j->create_info; - if (view_ci_i.image == view_ci_j.image && isRegionOverlapping(view_ci_i.subresourceRange, view_ci_j.subresourceRange)) { - overlapping_attachments[i].push_back(j); - overlapping_attachments[j].push_back(i); - continue; - } - auto image_data_i = GetImageState(dev_data, view_ci_i.image); - auto image_data_j = GetImageState(dev_data, view_ci_j.image); - if (!image_data_i || !image_data_j) { - continue; - } - if (image_data_i->binding.mem == image_data_j->binding.mem && - isRangeOverlapping(image_data_i->binding.offset, image_data_i->binding.size, image_data_j->binding.offset, - image_data_j->binding.size)) { - overlapping_attachments[i].push_back(j); - overlapping_attachments[j].push_back(i); - } - } - } - for (uint32_t i = 0; i < overlapping_attachments.size(); ++i) { - uint32_t attachment = i; - for (auto other_attachment : overlapping_attachments[i]) { - if (!(pCreateInfo->pAttachments[attachment].flags & VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, - HandleToUint64(framebuffer->framebuffer), VALIDATION_ERROR_12200682, - "Attachment %d aliases attachment %d but doesn't set VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT.", - attachment, other_attachment); - } - if (!(pCreateInfo->pAttachments[other_attachment].flags & VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, - HandleToUint64(framebuffer->framebuffer), VALIDATION_ERROR_12200682, - "Attachment %d aliases attachment %d but doesn't set VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT.", - other_attachment, attachment); - } - } - } - // Find for each attachment the subpasses that use them. - unordered_set attachmentIndices; - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[i]; - attachmentIndices.clear(); - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - uint32_t attachment = subpass.pInputAttachments[j].attachment; - if (attachment == VK_ATTACHMENT_UNUSED) continue; - input_attachment_to_subpass[attachment].push_back(i); - for (auto overlapping_attachment : overlapping_attachments[attachment]) { - input_attachment_to_subpass[overlapping_attachment].push_back(i); - } - } - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - uint32_t attachment = subpass.pColorAttachments[j].attachment; - if (attachment == VK_ATTACHMENT_UNUSED) continue; - output_attachment_to_subpass[attachment].push_back(i); - for (auto overlapping_attachment : overlapping_attachments[attachment]) { - output_attachment_to_subpass[overlapping_attachment].push_back(i); - } - attachmentIndices.insert(attachment); - } - if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - uint32_t attachment = subpass.pDepthStencilAttachment->attachment; - output_attachment_to_subpass[attachment].push_back(i); - for (auto overlapping_attachment : overlapping_attachments[attachment]) { - output_attachment_to_subpass[overlapping_attachment].push_back(i); - } - - if (attachmentIndices.count(attachment)) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, - "Cannot use same attachment (%u) as both color and depth output in same subpass (%u).", attachment, i); - } - } - } - // If there is a dependency needed make sure one exists - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[i]; - // If the attachment is an input then all subpasses that output must have a dependency relationship - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - uint32_t attachment = subpass.pInputAttachments[j].attachment; - if (attachment == VK_ATTACHMENT_UNUSED) continue; - CheckDependencyExists(dev_data, i, output_attachment_to_subpass[attachment], subpass_to_node, skip); - } - // If the attachment is an output then all subpasses that use the attachment must have a dependency relationship - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - uint32_t attachment = subpass.pColorAttachments[j].attachment; - if (attachment == VK_ATTACHMENT_UNUSED) continue; - CheckDependencyExists(dev_data, i, output_attachment_to_subpass[attachment], subpass_to_node, skip); - CheckDependencyExists(dev_data, i, input_attachment_to_subpass[attachment], subpass_to_node, skip); - } - if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - const uint32_t &attachment = subpass.pDepthStencilAttachment->attachment; - CheckDependencyExists(dev_data, i, output_attachment_to_subpass[attachment], subpass_to_node, skip); - CheckDependencyExists(dev_data, i, input_attachment_to_subpass[attachment], subpass_to_node, skip); - } - } - // Loop through implicit dependencies, if this pass reads make sure the attachment is preserved for all passes after it was - // written. - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[i]; - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - CheckPreserved(dev_data, pCreateInfo, i, subpass.pInputAttachments[j].attachment, subpass_to_node, 0, skip); - } - } - return skip; -} - -static bool CreatePassDAG(const layer_data *dev_data, const VkRenderPassCreateInfo *pCreateInfo, - std::vector &subpass_to_node, std::vector &has_self_dependency, - std::vector &subpass_to_dep_index) { - bool skip = false; - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - DAGNode &subpass_node = subpass_to_node[i]; - subpass_node.pass = i; - subpass_to_dep_index[i] = -1; // Default to no dependency and overwrite below as needed - } - for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) { - const VkSubpassDependency &dependency = pCreateInfo->pDependencies[i]; - if (dependency.srcSubpass == VK_SUBPASS_EXTERNAL || dependency.dstSubpass == VK_SUBPASS_EXTERNAL) { - if (dependency.srcSubpass == dependency.dstSubpass) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, "The src and dest subpasses cannot both be external."); - } - } else if (dependency.srcSubpass > dependency.dstSubpass) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, - "Dependency graph must be specified such that an earlier pass cannot depend on a later pass."); - } else if (dependency.srcSubpass == dependency.dstSubpass) { - has_self_dependency[dependency.srcSubpass] = true; - subpass_to_dep_index[dependency.srcSubpass] = i; - } else { - subpass_to_node[dependency.dstSubpass].prev.push_back(dependency.srcSubpass); - subpass_to_node[dependency.srcSubpass].next.push_back(dependency.dstSubpass); - } - } - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool spirv_valid; - - if (PreCallValidateCreateShaderModule(dev_data, pCreateInfo, &spirv_valid)) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult res = dev_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); - - if (res == VK_SUCCESS) { - lock_guard_t lock(global_lock); - unique_ptr new_shader_module(spirv_valid ? new shader_module(pCreateInfo) : new shader_module()); - dev_data->shaderModuleMap[*pShaderModule] = std::move(new_shader_module); - } - return res; -} - -static bool ValidateAttachmentIndex(layer_data *dev_data, uint32_t attachment, uint32_t attachment_count, const char *type) { - bool skip = false; - if (attachment >= attachment_count && attachment != VK_ATTACHMENT_UNUSED) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_12200684, - "CreateRenderPass: %s attachment %d must be less than the total number of attachments %d.", type, - attachment, attachment_count); - } - return skip; -} - -static bool IsPowerOfTwo(unsigned x) { return x && !(x & (x - 1)); } - -enum AttachmentType { - ATTACHMENT_COLOR = 1, - ATTACHMENT_DEPTH = 2, - ATTACHMENT_INPUT = 4, - ATTACHMENT_PRESERVE = 8, - ATTACHMENT_RESOLVE = 16, -}; - -char const *string_AttachmentType(uint8_t type) { - switch (type) { - case ATTACHMENT_COLOR: - return "color"; - case ATTACHMENT_DEPTH: - return "depth"; - case ATTACHMENT_INPUT: - return "input"; - case ATTACHMENT_PRESERVE: - return "preserve"; - case ATTACHMENT_RESOLVE: - return "resolve"; - default: - return "(multiple)"; - } -} - -static bool AddAttachmentUse(layer_data *dev_data, uint32_t subpass, std::vector &attachment_uses, - std::vector &attachment_layouts, uint32_t attachment, uint8_t new_use, - VkImageLayout new_layout) { - if (attachment >= attachment_uses.size()) return false; /* out of range, but already reported */ - - bool skip = false; - auto &uses = attachment_uses[attachment]; - if (uses & new_use) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDERPASS, "vkCreateRenderPass(): subpass %u already uses attachment %u as a %s attachment.", - subpass, attachment, string_AttachmentType(new_use)); - } else if (uses & ~ATTACHMENT_INPUT || (uses && (new_use == ATTACHMENT_RESOLVE || new_use == ATTACHMENT_PRESERVE))) { - /* Note: input attachments are assumed to be done first. */ - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_140006ac, "vkCreateRenderPass(): subpass %u uses attachment %u as both %s and %s attachment.", - subpass, attachment, string_AttachmentType(uses), string_AttachmentType(new_use)); - } else if (uses && attachment_layouts[attachment] != new_layout) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_140006ae, - "vkCreateRenderPass(): subpass %u uses attachment %u with conflicting layouts: input uses %s, but %s " - "attachment uses %s.", - subpass, attachment, string_VkImageLayout(attachment_layouts[attachment]), string_AttachmentType(new_use), - string_VkImageLayout(new_layout)); - } else { - attachment_layouts[attachment] = new_layout; - uses |= new_use; - } - - return skip; -} - -static bool ValidateRenderpassAttachmentUsage(layer_data *dev_data, const VkRenderPassCreateInfo *pCreateInfo) { - bool skip = false; - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[i]; - std::vector attachment_uses(pCreateInfo->attachmentCount); - std::vector attachment_layouts(pCreateInfo->attachmentCount); - - if (subpass.pipelineBindPoint != VK_PIPELINE_BIND_POINT_GRAPHICS) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_14000698, - "vkCreateRenderPass(): Pipeline bind point for subpass %d must be VK_PIPELINE_BIND_POINT_GRAPHICS.", i); - } - - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - auto const &attachment_ref = subpass.pInputAttachments[j]; - if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) { - skip |= ValidateAttachmentIndex(dev_data, attachment_ref.attachment, pCreateInfo->attachmentCount, "Input"); - skip |= AddAttachmentUse(dev_data, i, attachment_uses, attachment_layouts, attachment_ref.attachment, - ATTACHMENT_INPUT, attachment_ref.layout); - } - } - - for (uint32_t j = 0; j < subpass.preserveAttachmentCount; ++j) { - uint32_t attachment = subpass.pPreserveAttachments[j]; - if (attachment == VK_ATTACHMENT_UNUSED) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_140006aa, - "vkCreateRenderPass(): Preserve attachment (%d) must not be VK_ATTACHMENT_UNUSED.", j); - } else { - skip |= ValidateAttachmentIndex(dev_data, attachment, pCreateInfo->attachmentCount, "Preserve"); - skip |= AddAttachmentUse(dev_data, i, attachment_uses, attachment_layouts, attachment, ATTACHMENT_PRESERVE, - VkImageLayout(0) /* preserve doesn't have any layout */); - } - } - - unsigned sample_count = 0; - bool subpass_performs_resolve = false; - - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - if (subpass.pResolveAttachments) { - auto const &attachment_ref = subpass.pResolveAttachments[j]; - if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) { - skip |= ValidateAttachmentIndex(dev_data, attachment_ref.attachment, pCreateInfo->attachmentCount, "Resolve"); - skip |= AddAttachmentUse(dev_data, i, attachment_uses, attachment_layouts, attachment_ref.attachment, - ATTACHMENT_RESOLVE, attachment_ref.layout); - - subpass_performs_resolve = true; - - if (!skip && pCreateInfo->pAttachments[attachment_ref.attachment].samples != VK_SAMPLE_COUNT_1_BIT) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, VALIDATION_ERROR_140006a2, - "vkCreateRenderPass(): Subpass %u requests multisample resolve into attachment %u, which must " - "have VK_SAMPLE_COUNT_1_BIT but has %s.", - i, attachment_ref.attachment, - string_VkSampleCountFlagBits(pCreateInfo->pAttachments[attachment_ref.attachment].samples)); - } - } - } - } - - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - auto const &attachment_ref = subpass.pColorAttachments[j]; - skip |= ValidateAttachmentIndex(dev_data, attachment_ref.attachment, pCreateInfo->attachmentCount, "Color"); - if (!skip && attachment_ref.attachment != VK_ATTACHMENT_UNUSED) { - skip |= AddAttachmentUse(dev_data, i, attachment_uses, attachment_layouts, attachment_ref.attachment, - ATTACHMENT_COLOR, attachment_ref.layout); - sample_count |= (unsigned)pCreateInfo->pAttachments[attachment_ref.attachment].samples; - - if (subpass_performs_resolve && - pCreateInfo->pAttachments[attachment_ref.attachment].samples == VK_SAMPLE_COUNT_1_BIT) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, VALIDATION_ERROR_140006a0, - "vkCreateRenderPass(): Subpass %u requests multisample resolve from attachment %u which has " - "VK_SAMPLE_COUNT_1_BIT.", - i, attachment_ref.attachment); - } - - if (dev_data->extensions.vk_amd_mixed_attachment_samples && subpass.pDepthStencilAttachment && - subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - const auto depth_stencil_sample_count = - pCreateInfo->pAttachments[subpass.pDepthStencilAttachment->attachment].samples; - if (pCreateInfo->pAttachments[attachment_ref.attachment].samples > depth_stencil_sample_count) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, VALIDATION_ERROR_14000bc4, - "vkCreateRenderPass(): Subpass %u pColorAttachments[%u] has %s which is larger than " - "depth/stencil attachment %s.", - i, j, - string_VkSampleCountFlagBits(pCreateInfo->pAttachments[attachment_ref.attachment].samples), - string_VkSampleCountFlagBits(depth_stencil_sample_count)); - } - } - } - - if (!skip && subpass_performs_resolve && subpass.pResolveAttachments[j].attachment != VK_ATTACHMENT_UNUSED) { - if (attachment_ref.attachment == VK_ATTACHMENT_UNUSED) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, VALIDATION_ERROR_1400069e, - "vkCreateRenderPass(): Subpass %u requests multisample resolve from attachment %u which has " - "attachment=VK_ATTACHMENT_UNUSED.", - i, attachment_ref.attachment); - } else { - const auto &color_desc = pCreateInfo->pAttachments[attachment_ref.attachment]; - const auto &resolve_desc = pCreateInfo->pAttachments[subpass.pResolveAttachments[j].attachment]; - if (color_desc.format != resolve_desc.format) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, VALIDATION_ERROR_140006a4, - "vkCreateRenderPass(): Subpass %u pColorAttachments[%u] resolves to an attachment with a " - "different format. color format: %u, resolve format: %u.", - i, j, color_desc.format, resolve_desc.format); - } - } - } - } - - if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - auto const &attachment_ref = *subpass.pDepthStencilAttachment; - skip |= ValidateAttachmentIndex(dev_data, attachment_ref.attachment, pCreateInfo->attachmentCount, "Depth stencil"); - - if (!skip && attachment_ref.attachment != VK_ATTACHMENT_UNUSED) { - skip |= AddAttachmentUse(dev_data, i, attachment_uses, attachment_layouts, attachment_ref.attachment, - ATTACHMENT_DEPTH, attachment_ref.layout); - sample_count |= (unsigned)pCreateInfo->pAttachments[attachment_ref.attachment].samples; - } - } - - if (!dev_data->extensions.vk_amd_mixed_attachment_samples && sample_count && !IsPowerOfTwo(sample_count)) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0082b401, - "vkCreateRenderPass(): Subpass %u attempts to render to attachments with inconsistent sample counts.", i); - } - } - return skip; -} - -static void MarkAttachmentFirstUse(RENDER_PASS_STATE *render_pass, uint32_t index, bool is_read) { - if (index == VK_ATTACHMENT_UNUSED) return; - - if (!render_pass->attachment_first_read.count(index)) render_pass->attachment_first_read[index] = is_read; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - unique_lock_t lock(global_lock); - // TODO: As part of wrapping up the mem_tracker/core_validation merge the following routine should be consolidated with - // ValidateLayouts. - skip |= ValidateRenderpassAttachmentUsage(dev_data, pCreateInfo); - - std::vector has_self_dependency(pCreateInfo->subpassCount); - std::vector subpass_to_node(pCreateInfo->subpassCount); - std::vector subpass_to_dep_index(pCreateInfo->subpassCount); - skip |= CreatePassDAG(dev_data, pCreateInfo, subpass_to_node, has_self_dependency, subpass_to_dep_index); - - for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) { - auto const &dependency = pCreateInfo->pDependencies[i]; - skip |= ValidateStageMaskGsTsEnables(dev_data, dependency.srcStageMask, "vkCreateRenderPass()", VALIDATION_ERROR_13e006b8, - VALIDATION_ERROR_13e006bc); - skip |= ValidateStageMaskGsTsEnables(dev_data, dependency.dstStageMask, "vkCreateRenderPass()", VALIDATION_ERROR_13e006ba, - VALIDATION_ERROR_13e006be); - - if (!ValidateAccessMaskPipelineStage(dependency.srcAccessMask, dependency.srcStageMask)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_13e006c8, - "CreateRenderPass: pDependencies[%u].srcAccessMask (0x%X) is not supported by srcStageMask (0x%X).", i, - dependency.srcAccessMask, dependency.srcStageMask); - } - - if (!ValidateAccessMaskPipelineStage(dependency.dstAccessMask, dependency.dstStageMask)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_13e006ca, - "CreateRenderPass: pDependencies[%u].dstAccessMask (0x%X) is not supported by dstStageMask (0x%X).", i, - dependency.dstAccessMask, dependency.dstStageMask); - } - } - if (!skip) { - skip |= ValidateLayouts(dev_data, device, pCreateInfo); - } - lock.unlock(); - - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - VkResult result = dev_data->dispatch_table.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); - - if (VK_SUCCESS == result) { - lock.lock(); - - auto render_pass = std::make_shared(pCreateInfo); - render_pass->renderPass = *pRenderPass; - render_pass->hasSelfDependency = has_self_dependency; - render_pass->subpassToNode = subpass_to_node; - render_pass->subpass_to_dependency_index = subpass_to_dep_index; - - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[i]; - for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { - MarkAttachmentFirstUse(render_pass.get(), subpass.pColorAttachments[j].attachment, false); - - // resolve attachments are considered to be written - if (subpass.pResolveAttachments) { - MarkAttachmentFirstUse(render_pass.get(), subpass.pResolveAttachments[j].attachment, false); - } - } - if (subpass.pDepthStencilAttachment) { - MarkAttachmentFirstUse(render_pass.get(), subpass.pDepthStencilAttachment->attachment, false); - } - for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { - MarkAttachmentFirstUse(render_pass.get(), subpass.pInputAttachments[j].attachment, true); - } - } - - dev_data->renderPassMap[*pRenderPass] = std::move(render_pass); - } - return result; -} - -static bool validatePrimaryCommandBuffer(const layer_data *dev_data, const GLOBAL_CB_NODE *pCB, char const *cmd_name, - UNIQUE_VALIDATION_ERROR_CODE error_code) { - bool skip = false; - if (pCB->createInfo.level != VK_COMMAND_BUFFER_LEVEL_PRIMARY) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), error_code, "Cannot execute command %s on a secondary command buffer.", - cmd_name); - } - return skip; -} - -static bool VerifyRenderAreaBounds(const layer_data *dev_data, const VkRenderPassBeginInfo *pRenderPassBegin) { - bool skip = false; - const safe_VkFramebufferCreateInfo *pFramebufferInfo = - &GetFramebufferState(dev_data, pRenderPassBegin->framebuffer)->createInfo; - if (pRenderPassBegin->renderArea.offset.x < 0 || - (pRenderPassBegin->renderArea.offset.x + pRenderPassBegin->renderArea.extent.width) > pFramebufferInfo->width || - pRenderPassBegin->renderArea.offset.y < 0 || - (pRenderPassBegin->renderArea.offset.y + pRenderPassBegin->renderArea.extent.height) > pFramebufferInfo->height) { - skip |= static_cast(log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_INVALID_RENDER_AREA, - "Cannot execute a render pass with renderArea not within the bound of the framebuffer. RenderArea: x %d, y %d, width " - "%d, height %d. Framebuffer: width %d, height %d.", - pRenderPassBegin->renderArea.offset.x, pRenderPassBegin->renderArea.offset.y, pRenderPassBegin->renderArea.extent.width, - pRenderPassBegin->renderArea.extent.height, pFramebufferInfo->width, pFramebufferInfo->height)); - } - return skip; -} - -// If this is a stencil format, make sure the stencil[Load|Store]Op flag is checked, while if it is a depth/color attachment the -// [load|store]Op flag must be checked -// TODO: The memory valid flag in DEVICE_MEM_INFO should probably be split to track the validity of stencil memory separately. -template -static bool FormatSpecificLoadAndStoreOpSettings(VkFormat format, T color_depth_op, T stencil_op, T op) { - if (color_depth_op != op && stencil_op != op) { - return false; - } - bool check_color_depth_load_op = !FormatIsStencilOnly(format); - bool check_stencil_load_op = FormatIsDepthAndStencil(format) || !check_color_depth_load_op; - - return ((check_color_depth_load_op && (color_depth_op == op)) || (check_stencil_load_op && (stencil_op == op))); -} - -VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, - VkSubpassContents contents) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *cb_node = GetCBNode(dev_data, commandBuffer); - auto render_pass_state = pRenderPassBegin ? GetRenderPassState(dev_data, pRenderPassBegin->renderPass) : nullptr; - auto framebuffer = pRenderPassBegin ? GetFramebufferState(dev_data, pRenderPassBegin->framebuffer) : nullptr; - if (cb_node) { - if (render_pass_state) { - uint32_t clear_op_size = 0; // Make sure pClearValues is at least as large as last LOAD_OP_CLEAR - cb_node->activeFramebuffer = pRenderPassBegin->framebuffer; - - for (uint32_t i = 0; i < render_pass_state->createInfo.attachmentCount; ++i) { - auto pAttachment = &render_pass_state->createInfo.pAttachments[i]; - if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->loadOp, pAttachment->stencilLoadOp, - VK_ATTACHMENT_LOAD_OP_CLEAR)) { - clear_op_size = static_cast(i) + 1; - } - } - - if (clear_op_size > pRenderPassBegin->clearValueCount) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - HandleToUint64(render_pass_state->renderPass), VALIDATION_ERROR_1200070c, - "In vkCmdBeginRenderPass() the VkRenderPassBeginInfo struct has a clearValueCount of %u but there " - "must be at least %u entries in pClearValues array to account for the highest index attachment in " - "renderPass 0x%" PRIx64 - " that uses VK_ATTACHMENT_LOAD_OP_CLEAR is %u. Note that the pClearValues array is indexed by " - "attachment number so even if some pClearValues entries between 0 and %u correspond to attachments " - "that aren't cleared they will be ignored.", - pRenderPassBegin->clearValueCount, clear_op_size, HandleToUint64(render_pass_state->renderPass), - clear_op_size, clear_op_size - 1); - } - skip |= VerifyRenderAreaBounds(dev_data, pRenderPassBegin); - skip |= VerifyFramebufferAndRenderPassLayouts(dev_data, cb_node, pRenderPassBegin, - GetFramebufferState(dev_data, pRenderPassBegin->framebuffer)); - if (framebuffer->rp_state->renderPass != render_pass_state->renderPass) { - skip |= validateRenderPassCompatibility(dev_data, "render pass", render_pass_state, "framebuffer", - framebuffer->rp_state.get(), "vkCmdBeginRenderPass()", - VALIDATION_ERROR_12000710); - } - skip |= insideRenderPass(dev_data, cb_node, "vkCmdBeginRenderPass()", VALIDATION_ERROR_17a00017); - skip |= ValidateDependencies(dev_data, framebuffer, render_pass_state); - skip |= validatePrimaryCommandBuffer(dev_data, cb_node, "vkCmdBeginRenderPass()", VALIDATION_ERROR_17a00019); - skip |= ValidateCmdQueueFlags(dev_data, cb_node, "vkCmdBeginRenderPass()", VK_QUEUE_GRAPHICS_BIT, - VALIDATION_ERROR_17a02415); - skip |= ValidateCmd(dev_data, cb_node, CMD_BEGINRENDERPASS, "vkCmdBeginRenderPass()"); - cb_node->activeRenderPass = render_pass_state; - // This is a shallow copy as that is all that is needed for now - cb_node->activeRenderPassBeginInfo = *pRenderPassBegin; - cb_node->activeSubpass = 0; - cb_node->activeSubpassContents = contents; - cb_node->framebuffers.insert(pRenderPassBegin->framebuffer); - // Connect this framebuffer and its children to this cmdBuffer - AddFramebufferBinding(dev_data, cb_node, framebuffer); - // Connect this RP to cmdBuffer - addCommandBufferBinding(&render_pass_state->cb_bindings, - {HandleToUint64(render_pass_state->renderPass), kVulkanObjectTypeRenderPass}, cb_node); - // transition attachments to the correct layouts for beginning of renderPass and first subpass - TransitionBeginRenderPassLayouts(dev_data, cb_node, render_pass_state, framebuffer); - } - } - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - skip |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdNextSubpass()", VALIDATION_ERROR_1b600019); - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdNextSubpass()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1b602415); - skip |= ValidateCmd(dev_data, pCB, CMD_NEXTSUBPASS, "vkCmdNextSubpass()"); - skip |= outsideRenderPass(dev_data, pCB, "vkCmdNextSubpass()", VALIDATION_ERROR_1b600017); - - auto subpassCount = pCB->activeRenderPass->createInfo.subpassCount; - if (pCB->activeSubpass == subpassCount - 1) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1b60071a, - "vkCmdNextSubpass(): Attempted to advance beyond final subpass."); - } - } - lock.unlock(); - - if (skip) return; - - dev_data->dispatch_table.CmdNextSubpass(commandBuffer, contents); - - if (pCB) { - lock.lock(); - pCB->activeSubpass++; - pCB->activeSubpassContents = contents; - TransitionSubpassLayouts(dev_data, pCB, pCB->activeRenderPass, pCB->activeSubpass, - GetFramebufferState(dev_data, pCB->activeRenderPassBeginInfo.framebuffer)); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - auto pCB = GetCBNode(dev_data, commandBuffer); - FRAMEBUFFER_STATE *framebuffer = NULL; - if (pCB) { - RENDER_PASS_STATE *rp_state = pCB->activeRenderPass; - framebuffer = GetFramebufferState(dev_data, pCB->activeFramebuffer); - if (rp_state) { - if (pCB->activeSubpass != rp_state->createInfo.subpassCount - 1) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer), - VALIDATION_ERROR_1b00071c, "vkCmdEndRenderPass(): Called before reaching final subpass."); - } - } - skip |= outsideRenderPass(dev_data, pCB, "vkCmdEndRenderpass()", VALIDATION_ERROR_1b000017); - skip |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdEndRenderPass()", VALIDATION_ERROR_1b000019); - skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdEndRenderPass()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1b002415); - skip |= ValidateCmd(dev_data, pCB, CMD_ENDRENDERPASS, "vkCmdEndRenderPass()"); - } - lock.unlock(); - - if (skip) return; - - dev_data->dispatch_table.CmdEndRenderPass(commandBuffer); - - if (pCB) { - lock.lock(); - TransitionFinalSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo, framebuffer); - pCB->activeRenderPass = nullptr; - pCB->activeSubpass = 0; - pCB->activeFramebuffer = VK_NULL_HANDLE; - } -} - -static bool validateFramebuffer(layer_data *dev_data, VkCommandBuffer primaryBuffer, const GLOBAL_CB_NODE *pCB, - VkCommandBuffer secondaryBuffer, const GLOBAL_CB_NODE *pSubCB, const char *caller) { - bool skip = false; - if (!pSubCB->beginInfo.pInheritanceInfo) { - return skip; - } - VkFramebuffer primary_fb = pCB->activeFramebuffer; - VkFramebuffer secondary_fb = pSubCB->beginInfo.pInheritanceInfo->framebuffer; - if (secondary_fb != VK_NULL_HANDLE) { - if (primary_fb != secondary_fb) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(primaryBuffer), VALIDATION_ERROR_1b2000c6, - "vkCmdExecuteCommands() called w/ invalid secondary command buffer 0x%" PRIx64 - " which has a framebuffer 0x%" PRIx64 - " that is not the same as the primary command buffer's current active framebuffer 0x%" PRIx64 ".", - HandleToUint64(secondaryBuffer), HandleToUint64(secondary_fb), HandleToUint64(primary_fb)); - } - auto fb = GetFramebufferState(dev_data, secondary_fb); - if (!fb) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(primaryBuffer), DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, - "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%" PRIx64 - " which has invalid framebuffer 0x%" PRIx64 ".", - HandleToUint64(secondaryBuffer), HandleToUint64(secondary_fb)); - return skip; - } - } - return skip; -} - -static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB, GLOBAL_CB_NODE *pSubCB) { - bool skip = false; - unordered_set activeTypes; - for (auto queryObject : pCB->activeQueries) { - auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool); - if (queryPoolData != dev_data->queryPoolMap.end()) { - if (queryPoolData->second.createInfo.queryType == VK_QUERY_TYPE_PIPELINE_STATISTICS && - pSubCB->beginInfo.pInheritanceInfo) { - VkQueryPipelineStatisticFlags cmdBufStatistics = pSubCB->beginInfo.pInheritanceInfo->pipelineStatistics; - if ((cmdBufStatistics & queryPoolData->second.createInfo.pipelineStatistics) != cmdBufStatistics) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), VALIDATION_ERROR_1b2000d0, - "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%" PRIx64 - " which has invalid active query pool 0x%" PRIx64 - ". Pipeline statistics is being queried so the command buffer must have all bits set on the queryPool.", - HandleToUint64(pCB->commandBuffer), HandleToUint64(queryPoolData->first)); - } - } - activeTypes.insert(queryPoolData->second.createInfo.queryType); - } - } - for (auto queryObject : pSubCB->startedQueries) { - auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool); - if (queryPoolData != dev_data->queryPoolMap.end() && activeTypes.count(queryPoolData->second.createInfo.queryType)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, - "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%" PRIx64 - " which has invalid active query pool 0x%" PRIx64 - " of type %d but a query of that type has been started on secondary Cmd Buffer 0x%" PRIx64 ".", - HandleToUint64(pCB->commandBuffer), HandleToUint64(queryPoolData->first), - queryPoolData->second.createInfo.queryType, HandleToUint64(pSubCB->commandBuffer)); - } - } - - auto primary_pool = GetCommandPoolNode(dev_data, pCB->createInfo.commandPool); - auto secondary_pool = GetCommandPoolNode(dev_data, pSubCB->createInfo.commandPool); - if (primary_pool && secondary_pool && (primary_pool->queueFamilyIndex != secondary_pool->queueFamilyIndex)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pSubCB->commandBuffer), DRAWSTATE_INVALID_QUEUE_FAMILY, - "vkCmdExecuteCommands(): Primary command buffer 0x%" PRIx64 - " created in queue family %d has secondary command buffer 0x%" PRIx64 " created in queue family %d.", - HandleToUint64(pCB->commandBuffer), primary_pool->queueFamilyIndex, HandleToUint64(pSubCB->commandBuffer), - secondary_pool->queueFamilyIndex); - } - - return skip; -} - -VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, - const VkCommandBuffer *pCommandBuffers) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); - if (pCB) { - GLOBAL_CB_NODE *pSubCB = NULL; - for (uint32_t i = 0; i < commandBuffersCount; i++) { - pSubCB = GetCBNode(dev_data, pCommandBuffers[i]); - assert(pSubCB); - if (VK_COMMAND_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCommandBuffers[i]), VALIDATION_ERROR_1b2000b0, - "vkCmdExecuteCommands() called w/ Primary Cmd Buffer 0x%" PRIx64 - " in element %u of pCommandBuffers array. All cmd buffers in pCommandBuffers array must be secondary.", - HandleToUint64(pCommandBuffers[i]), i); - } else if (pCB->activeRenderPass) { // Secondary CB w/i RenderPass must have *CONTINUE_BIT set - if (pSubCB->beginInfo.pInheritanceInfo != nullptr) { - auto secondary_rp_state = GetRenderPassState(dev_data, pSubCB->beginInfo.pInheritanceInfo->renderPass); - if (!(pSubCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(pCommandBuffers[i]), - VALIDATION_ERROR_1b2000c0, - "vkCmdExecuteCommands(): Secondary Command Buffer (0x%" PRIx64 - ") executed within render pass (0x%" PRIx64 - ") must have had vkBeginCommandBuffer() called w/ " - "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT set.", - HandleToUint64(pCommandBuffers[i]), HandleToUint64(pCB->activeRenderPass->renderPass)); - } else { - // Make sure render pass is compatible with parent command buffer pass if has continue - if (pCB->activeRenderPass->renderPass != secondary_rp_state->renderPass) { - skip |= validateRenderPassCompatibility(dev_data, "primary command buffer", pCB->activeRenderPass, - "secondary command buffer", secondary_rp_state, - "vkCmdExecuteCommands()", VALIDATION_ERROR_1b2000c4); - } - // If framebuffer for secondary CB is not NULL, then it must match active FB from primaryCB - skip |= - validateFramebuffer(dev_data, commandBuffer, pCB, pCommandBuffers[i], pSubCB, "vkCmdExecuteCommands()"); - if (!pSubCB->cmd_execute_commands_functions.empty()) { - // Inherit primary's activeFramebuffer and while running validate functions - for (auto &function : pSubCB->cmd_execute_commands_functions) { - skip |= function(pCB, pCB->activeFramebuffer); - } - } - } - } - } - // TODO(mlentine): Move more logic into this method - skip |= validateSecondaryCommandBufferState(dev_data, pCB, pSubCB); - skip |= validateCommandBufferState(dev_data, pSubCB, "vkCmdExecuteCommands()", 0, VALIDATION_ERROR_1b2000b2); - if (!(pSubCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)) { - if (pSubCB->in_use.load() || pCB->linkedCommandBuffers.count(pSubCB)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(pCB->commandBuffer), - VALIDATION_ERROR_1b2000b4, - "Attempt to simultaneously execute command buffer 0x%" PRIx64 - " without VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set!", - HandleToUint64(pCB->commandBuffer)); - } - if (pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT) { - // Warn that non-simultaneous secondary cmd buffer renders primary non-simultaneous - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(pCommandBuffers[i]), - DRAWSTATE_INVALID_CB_SIMULTANEOUS_USE, - "vkCmdExecuteCommands(): Secondary Command Buffer (0x%" PRIx64 - ") does not have VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set and will cause primary " - "command buffer (0x%" PRIx64 - ") to be treated as if it does not have VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set, even " - "though it does.", - HandleToUint64(pCommandBuffers[i]), HandleToUint64(pCB->commandBuffer)); - pCB->beginInfo.flags &= ~VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; - } - } - if (!pCB->activeQueries.empty() && !dev_data->enabled_features2.features.inheritedQueries) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(pCommandBuffers[i]), VALIDATION_ERROR_1b2000ca, - "vkCmdExecuteCommands(): Secondary Command Buffer (0x%" PRIx64 - ") cannot be submitted with a query in flight and inherited queries not supported on this device.", - HandleToUint64(pCommandBuffers[i])); - } - // TODO: separate validate from update! This is very tangled. - // Propagate layout transitions to the primary cmd buffer - for (auto ilm_entry : pSubCB->imageLayoutMap) { - if (pCB->imageLayoutMap.find(ilm_entry.first) != pCB->imageLayoutMap.end()) { - pCB->imageLayoutMap[ilm_entry.first].layout = ilm_entry.second.layout; - } else { - assert(ilm_entry.first.hasSubresource); - IMAGE_CMD_BUF_LAYOUT_NODE node; - if (!FindCmdBufLayout(dev_data, pCB, ilm_entry.first.image, ilm_entry.first.subresource, node)) { - node.initialLayout = ilm_entry.second.initialLayout; - } - node.layout = ilm_entry.second.layout; - SetLayout(dev_data, pCB, ilm_entry.first, node); - } - } - pSubCB->primaryCommandBuffer = pCB->commandBuffer; - pCB->linkedCommandBuffers.insert(pSubCB); - pSubCB->linkedCommandBuffers.insert(pCB); - for (auto &function : pSubCB->queryUpdates) { - pCB->queryUpdates.push_back(function); - } - for (auto &function : pSubCB->queue_submit_functions) { - pCB->queue_submit_functions.push_back(function); - } - } - skip |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdExecuteCommands()", VALIDATION_ERROR_1b200019); - skip |= - ValidateCmdQueueFlags(dev_data, pCB, "vkCmdExecuteCommands()", - VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, VALIDATION_ERROR_1b202415); - skip |= ValidateCmd(dev_data, pCB, CMD_EXECUTECOMMANDS, "vkCmdExecuteCommands()"); - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers); -} - -VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, - void **ppData) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - bool skip = false; - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - unique_lock_t lock(global_lock); - DEVICE_MEM_INFO *mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - auto end_offset = (VK_WHOLE_SIZE == size) ? mem_info->alloc_info.allocationSize - 1 : offset + size - 1; - skip |= ValidateMapImageLayouts(dev_data, device, mem_info, offset, end_offset); - if ((dev_data->phys_dev_mem_props.memoryTypes[mem_info->alloc_info.memoryTypeIndex].propertyFlags & - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) { - skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem), VALIDATION_ERROR_31200554, - "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj 0x%" PRIx64 ".", - HandleToUint64(mem)); - } - } - skip |= ValidateMapMemRange(dev_data, mem, offset, size); - lock.unlock(); - - if (!skip) { - result = dev_data->dispatch_table.MapMemory(device, mem, offset, size, flags, ppData); - if (VK_SUCCESS == result) { - lock.lock(); - // TODO : What's the point of this range? See comment on creating new "bound_range" above, which may replace this - storeMemRanges(dev_data, mem, offset, size); - initializeAndTrackMemory(dev_data, mem, offset, size, ppData); - lock.unlock(); - } - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory mem) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - - unique_lock_t lock(global_lock); - skip |= deleteMemRanges(dev_data, mem); - lock.unlock(); - if (!skip) { - dev_data->dispatch_table.UnmapMemory(device, mem); - } -} - -static bool validateMemoryIsMapped(layer_data *dev_data, const char *funcName, uint32_t memRangeCount, - const VkMappedMemoryRange *pMemRanges) { - bool skip = false; - for (uint32_t i = 0; i < memRangeCount; ++i) { - auto mem_info = GetMemObjInfo(dev_data, pMemRanges[i].memory); - if (mem_info) { - if (pMemRanges[i].size == VK_WHOLE_SIZE) { - if (mem_info->mem_range.offset > pMemRanges[i].offset) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(pMemRanges[i].memory), VALIDATION_ERROR_0c20055c, - "%s: Flush/Invalidate offset (" PRINTF_SIZE_T_SPECIFIER - ") is less than Memory Object's offset (" PRINTF_SIZE_T_SPECIFIER ").", - funcName, static_cast(pMemRanges[i].offset), static_cast(mem_info->mem_range.offset)); - } - } else { - const uint64_t data_end = (mem_info->mem_range.size == VK_WHOLE_SIZE) - ? mem_info->alloc_info.allocationSize - : (mem_info->mem_range.offset + mem_info->mem_range.size); - if ((mem_info->mem_range.offset > pMemRanges[i].offset) || - (data_end < (pMemRanges[i].offset + pMemRanges[i].size))) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(pMemRanges[i].memory), VALIDATION_ERROR_0c20055a, - "%s: Flush/Invalidate size or offset (" PRINTF_SIZE_T_SPECIFIER ", " PRINTF_SIZE_T_SPECIFIER - ") exceed the Memory Object's upper-bound (" PRINTF_SIZE_T_SPECIFIER ").", - funcName, static_cast(pMemRanges[i].offset + pMemRanges[i].size), - static_cast(pMemRanges[i].offset), static_cast(data_end)); - } - } - } - } - return skip; -} - -static bool ValidateAndCopyNoncoherentMemoryToDriver(layer_data *dev_data, uint32_t mem_range_count, - const VkMappedMemoryRange *mem_ranges) { - bool skip = false; - for (uint32_t i = 0; i < mem_range_count; ++i) { - auto mem_info = GetMemObjInfo(dev_data, mem_ranges[i].memory); - if (mem_info) { - if (mem_info->shadow_copy) { - VkDeviceSize size = (mem_info->mem_range.size != VK_WHOLE_SIZE) - ? mem_info->mem_range.size - : (mem_info->alloc_info.allocationSize - mem_info->mem_range.offset); - char *data = static_cast(mem_info->shadow_copy); - for (uint64_t j = 0; j < mem_info->shadow_pad_size; ++j) { - if (data[j] != NoncoherentMemoryFillValue) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, HandleToUint64(mem_ranges[i].memory), - MEMTRACK_INVALID_MAP, "Memory underflow was detected on mem obj 0x%" PRIx64, - HandleToUint64(mem_ranges[i].memory)); - } - } - for (uint64_t j = (size + mem_info->shadow_pad_size); j < (2 * mem_info->shadow_pad_size + size); ++j) { - if (data[j] != NoncoherentMemoryFillValue) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, HandleToUint64(mem_ranges[i].memory), - MEMTRACK_INVALID_MAP, "Memory overflow was detected on mem obj 0x%" PRIx64, - HandleToUint64(mem_ranges[i].memory)); - } - } - memcpy(mem_info->p_driver_data, static_cast(data + mem_info->shadow_pad_size), (size_t)(size)); - } - } - } - return skip; -} - -static void CopyNoncoherentMemoryFromDriver(layer_data *dev_data, uint32_t mem_range_count, const VkMappedMemoryRange *mem_ranges) { - for (uint32_t i = 0; i < mem_range_count; ++i) { - auto mem_info = GetMemObjInfo(dev_data, mem_ranges[i].memory); - if (mem_info && mem_info->shadow_copy) { - VkDeviceSize size = (mem_info->mem_range.size != VK_WHOLE_SIZE) - ? mem_info->mem_range.size - : (mem_info->alloc_info.allocationSize - mem_ranges[i].offset); - char *data = static_cast(mem_info->shadow_copy); - memcpy(data + mem_info->shadow_pad_size, mem_info->p_driver_data, (size_t)(size)); - } - } -} - -static bool ValidateMappedMemoryRangeDeviceLimits(layer_data *dev_data, const char *func_name, uint32_t mem_range_count, - const VkMappedMemoryRange *mem_ranges) { - bool skip = false; - for (uint32_t i = 0; i < mem_range_count; ++i) { - uint64_t atom_size = dev_data->phys_dev_properties.properties.limits.nonCoherentAtomSize; - if (SafeModulo(mem_ranges[i].offset, atom_size) != 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem_ranges->memory), VALIDATION_ERROR_0c20055e, - "%s: Offset in pMemRanges[%d] is 0x%" PRIxLEAST64 - ", which is not a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize (0x%" PRIxLEAST64 ").", - func_name, i, mem_ranges[i].offset, atom_size); - } - auto mem_info = GetMemObjInfo(dev_data, mem_ranges[i].memory); - if ((mem_ranges[i].size != VK_WHOLE_SIZE) && - (mem_ranges[i].size + mem_ranges[i].offset != mem_info->alloc_info.allocationSize) && - (SafeModulo(mem_ranges[i].size, atom_size) != 0)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - HandleToUint64(mem_ranges->memory), VALIDATION_ERROR_0c200adc, - "%s: Size in pMemRanges[%d] is 0x%" PRIxLEAST64 - ", which is not a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize (0x%" PRIxLEAST64 ").", - func_name, i, mem_ranges[i].size, atom_size); - } - } - return skip; -} - -static bool PreCallValidateFlushMappedMemoryRanges(layer_data *dev_data, uint32_t mem_range_count, - const VkMappedMemoryRange *mem_ranges) { - bool skip = false; - lock_guard_t lock(global_lock); - skip |= ValidateMappedMemoryRangeDeviceLimits(dev_data, "vkFlushMappedMemoryRanges", mem_range_count, mem_ranges); - skip |= ValidateAndCopyNoncoherentMemoryToDriver(dev_data, mem_range_count, mem_ranges); - skip |= validateMemoryIsMapped(dev_data, "vkFlushMappedMemoryRanges", mem_range_count, mem_ranges); - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, - const VkMappedMemoryRange *pMemRanges) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - if (!PreCallValidateFlushMappedMemoryRanges(dev_data, memRangeCount, pMemRanges)) { - result = dev_data->dispatch_table.FlushMappedMemoryRanges(device, memRangeCount, pMemRanges); - } - return result; -} - -static bool PreCallValidateInvalidateMappedMemoryRanges(layer_data *dev_data, uint32_t mem_range_count, - const VkMappedMemoryRange *mem_ranges) { - bool skip = false; - lock_guard_t lock(global_lock); - skip |= ValidateMappedMemoryRangeDeviceLimits(dev_data, "vkInvalidateMappedMemoryRanges", mem_range_count, mem_ranges); - skip |= validateMemoryIsMapped(dev_data, "vkInvalidateMappedMemoryRanges", mem_range_count, mem_ranges); - return skip; -} - -static void PostCallRecordInvalidateMappedMemoryRanges(layer_data *dev_data, uint32_t mem_range_count, - const VkMappedMemoryRange *mem_ranges) { - lock_guard_t lock(global_lock); - // Update our shadow copy with modified driver data - CopyNoncoherentMemoryFromDriver(dev_data, mem_range_count, mem_ranges); -} - -VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, - const VkMappedMemoryRange *pMemRanges) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - if (!PreCallValidateInvalidateMappedMemoryRanges(dev_data, memRangeCount, pMemRanges)) { - result = dev_data->dispatch_table.InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges); - if (result == VK_SUCCESS) { - PostCallRecordInvalidateMappedMemoryRanges(dev_data, memRangeCount, pMemRanges); - } - } - return result; -} - -static bool PreCallValidateBindImageMemory(layer_data *dev_data, VkImage image, IMAGE_STATE *image_state, VkDeviceMemory mem, - VkDeviceSize memoryOffset, const char *api_name) { - bool skip = false; - if (image_state) { - unique_lock_t lock(global_lock); - // Track objects tied to memory - uint64_t image_handle = HandleToUint64(image); - skip = ValidateSetMemBinding(dev_data, mem, image_handle, kVulkanObjectTypeImage, api_name); - if (!image_state->memory_requirements_checked) { - // There's not an explicit requirement in the spec to call vkGetImageMemoryRequirements() prior to calling - // BindImageMemory but it's implied in that memory being bound must conform with VkMemoryRequirements from - // vkGetImageMemoryRequirements() - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - image_handle, DRAWSTATE_INVALID_IMAGE, - "%s: Binding memory to image 0x%" PRIx64 - " but vkGetImageMemoryRequirements() has not been called on that image.", - api_name, HandleToUint64(image_handle)); - // Make the call for them so we can verify the state - lock.unlock(); - dev_data->dispatch_table.GetImageMemoryRequirements(dev_data->device, image, &image_state->requirements); - lock.lock(); - } - - // Validate bound memory range information - auto mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - skip |= ValidateInsertImageMemoryRange(dev_data, image, mem_info, memoryOffset, image_state->requirements, - image_state->createInfo.tiling == VK_IMAGE_TILING_LINEAR, api_name); - skip |= ValidateMemoryTypes(dev_data, mem_info, image_state->requirements.memoryTypeBits, api_name, - VALIDATION_ERROR_1740082e); - } - - // Validate memory requirements alignment - if (SafeModulo(memoryOffset, image_state->requirements.alignment) != 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - image_handle, VALIDATION_ERROR_17400830, - "%s: memoryOffset is 0x%" PRIxLEAST64 - " but must be an integer multiple of the VkMemoryRequirements::alignment value 0x%" PRIxLEAST64 - ", returned from a call to vkGetImageMemoryRequirements with image.", - api_name, memoryOffset, image_state->requirements.alignment); - } - - if (mem_info) { - // Validate memory requirements size - if (image_state->requirements.size > mem_info->alloc_info.allocationSize - memoryOffset) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - image_handle, VALIDATION_ERROR_17400832, - "%s: memory size minus memoryOffset is 0x%" PRIxLEAST64 - " but must be at least as large as VkMemoryRequirements::size value 0x%" PRIxLEAST64 - ", returned from a call to vkGetImageMemoryRequirements with image.", - api_name, mem_info->alloc_info.allocationSize - memoryOffset, image_state->requirements.size); - } - - // Validate dedicated allocation - if (mem_info->is_dedicated && ((mem_info->dedicated_image != image) || (memoryOffset != 0))) { - // TODO: Add vkBindImageMemory2KHR error message when added to spec. - auto validation_error = VALIDATION_ERROR_UNDEFINED; - if (strcmp(api_name, "vkBindImageMemory()") == 0) { - validation_error = VALIDATION_ERROR_17400bca; - } - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - image_handle, validation_error, - "%s: for dedicated memory allocation 0x%" PRIxLEAST64 - ", VkMemoryDedicatedAllocateInfoKHR::image 0x%" PRIXLEAST64 " must be equal to image 0x%" PRIxLEAST64 - " and memoryOffset 0x%" PRIxLEAST64 " must be zero.", - api_name, HandleToUint64(mem), HandleToUint64(mem_info->dedicated_image), image_handle, memoryOffset); - } - } - } - return skip; -} - -static void PostCallRecordBindImageMemory(layer_data *dev_data, VkImage image, IMAGE_STATE *image_state, VkDeviceMemory mem, - VkDeviceSize memoryOffset, const char *api_name) { - if (image_state) { - unique_lock_t lock(global_lock); - // Track bound memory range information - auto mem_info = GetMemObjInfo(dev_data, mem); - if (mem_info) { - InsertImageMemoryRange(dev_data, image, mem_info, memoryOffset, image_state->requirements, - image_state->createInfo.tiling == VK_IMAGE_TILING_LINEAR); - } - - // Track objects tied to memory - uint64_t image_handle = HandleToUint64(image); - SetMemBinding(dev_data, mem, image_state, memoryOffset, image_handle, kVulkanObjectTypeImage, api_name); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - IMAGE_STATE *image_state; - { - unique_lock_t lock(global_lock); - image_state = GetImageState(dev_data, image); - } - bool skip = PreCallValidateBindImageMemory(dev_data, image, image_state, mem, memoryOffset, "vkBindImageMemory()"); - if (!skip) { - result = dev_data->dispatch_table.BindImageMemory(device, image, mem, memoryOffset); - if (result == VK_SUCCESS) { - PostCallRecordBindImageMemory(dev_data, image, image_state, mem, memoryOffset, "vkBindImageMemory()"); - } - } - return result; -} - -static bool PreCallValidateBindImageMemory2(layer_data *dev_data, std::vector *image_state, uint32_t bindInfoCount, - const VkBindImageMemoryInfoKHR *pBindInfos) { - { - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < bindInfoCount; i++) { - (*image_state)[i] = GetImageState(dev_data, pBindInfos[i].image); - } - } - bool skip = false; - char api_name[128]; - for (uint32_t i = 0; i < bindInfoCount; i++) { - sprintf(api_name, "vkBindImageMemory2() pBindInfos[%u]", i); - skip |= PreCallValidateBindImageMemory(dev_data, pBindInfos[i].image, (*image_state)[i], pBindInfos[i].memory, - pBindInfos[i].memoryOffset, api_name); - } - return skip; -} - -static void PostCallRecordBindImageMemory2(layer_data *dev_data, const std::vector &image_state, - uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR *pBindInfos) { - for (uint32_t i = 0; i < bindInfoCount; i++) { - PostCallRecordBindImageMemory(dev_data, pBindInfos[i].image, image_state[i], pBindInfos[i].memory, - pBindInfos[i].memoryOffset, "vkBindImageMemory2()"); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(VkDevice device, uint32_t bindInfoCount, - const VkBindImageMemoryInfoKHR *pBindInfos) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::vector image_state(bindInfoCount); - if (!PreCallValidateBindImageMemory2(dev_data, &image_state, bindInfoCount, pBindInfos)) { - result = dev_data->dispatch_table.BindImageMemory2(device, bindInfoCount, pBindInfos); - if (result == VK_SUCCESS) { - PostCallRecordBindImageMemory2(dev_data, image_state, bindInfoCount, pBindInfos); - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, - const VkBindImageMemoryInfoKHR *pBindInfos) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::vector image_state(bindInfoCount); - if (!PreCallValidateBindImageMemory2(dev_data, &image_state, bindInfoCount, pBindInfos)) { - result = dev_data->dispatch_table.BindImageMemory2KHR(device, bindInfoCount, pBindInfos); - if (result == VK_SUCCESS) { - PostCallRecordBindImageMemory2(dev_data, image_state, bindInfoCount, pBindInfos); - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) { - bool skip = false; - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - auto event_state = GetEventNode(dev_data, event); - if (event_state) { - event_state->needsSignaled = false; - event_state->stageMask = VK_PIPELINE_STAGE_HOST_BIT; - if (event_state->write_in_use) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, - HandleToUint64(event), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "Cannot call vkSetEvent() on event 0x%" PRIx64 " that is already in use by a command buffer.", - HandleToUint64(event)); - } - } - lock.unlock(); - // Host setting event is visible to all queues immediately so update stageMask for any queue that's seen this event - // TODO : For correctness this needs separate fix to verify that app doesn't make incorrect assumptions about the - // ordering of this command in relation to vkCmd[Set|Reset]Events (see GH297) - for (auto queue_data : dev_data->queueMap) { - auto event_entry = queue_data.second.eventToStageMap.find(event); - if (event_entry != queue_data.second.eventToStageMap.end()) { - event_entry->second |= VK_PIPELINE_STAGE_HOST_BIT; - } - } - if (!skip) result = dev_data->dispatch_table.SetEvent(device, event); - return result; -} - -static bool PreCallValidateQueueBindSparse(layer_data *dev_data, VkQueue queue, uint32_t bindInfoCount, - const VkBindSparseInfo *pBindInfo, VkFence fence) { - auto pFence = GetFenceNode(dev_data, fence); - bool skip = ValidateFenceForSubmit(dev_data, pFence); - if (skip) { - return true; - } - - unordered_set signaled_semaphores; - unordered_set unsignaled_semaphores; - unordered_set internal_semaphores; - for (uint32_t bindIdx = 0; bindIdx < bindInfoCount; ++bindIdx) { - const VkBindSparseInfo &bindInfo = pBindInfo[bindIdx]; - - std::vector semaphore_waits; - std::vector semaphore_signals; - for (uint32_t i = 0; i < bindInfo.waitSemaphoreCount; ++i) { - VkSemaphore semaphore = bindInfo.pWaitSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore && (pSemaphore->scope == kSyncScopeInternal || internal_semaphores.count(semaphore))) { - if (unsignaled_semaphores.count(semaphore) || - (!(signaled_semaphores.count(semaphore)) && !(pSemaphore->signaled))) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - HandleToUint64(semaphore), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "Queue 0x%" PRIx64 " is waiting on semaphore 0x%" PRIx64 " that has no way to be signaled.", - HandleToUint64(queue), HandleToUint64(semaphore)); - } else { - signaled_semaphores.erase(semaphore); - unsignaled_semaphores.insert(semaphore); - } - } - if (pSemaphore && pSemaphore->scope == kSyncScopeExternalTemporary) { - internal_semaphores.insert(semaphore); - } - } - for (uint32_t i = 0; i < bindInfo.signalSemaphoreCount; ++i) { - VkSemaphore semaphore = bindInfo.pSignalSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore && pSemaphore->scope == kSyncScopeInternal) { - if (signaled_semaphores.count(semaphore) || (!(unsignaled_semaphores.count(semaphore)) && pSemaphore->signaled)) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - HandleToUint64(semaphore), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "Queue 0x%" PRIx64 " is signaling semaphore 0x%" PRIx64 - " that has already been signaled but not waited on by queue 0x%" PRIx64 ".", - HandleToUint64(queue), HandleToUint64(semaphore), HandleToUint64(pSemaphore->signaler.first)); - } else { - unsignaled_semaphores.erase(semaphore); - signaled_semaphores.insert(semaphore); - } - } - } - // Store sparse binding image_state and after binding is complete make sure that any requiring metadata have it bound - std::unordered_set sparse_images; - // If we're binding sparse image memory make sure reqs were queried and note if metadata is required and bound - for (uint32_t i = 0; i < bindInfo.imageBindCount; ++i) { - const auto &image_bind = bindInfo.pImageBinds[i]; - auto image_state = GetImageState(dev_data, image_bind.image); - sparse_images.insert(image_state); - if (!image_state->get_sparse_reqs_called || image_state->sparse_requirements.empty()) { - // For now just warning if sparse image binding occurs without calling to get reqs first - return log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), MEMTRACK_INVALID_STATE, - "vkQueueBindSparse(): Binding sparse memory to image 0x%" PRIx64 - " without first calling vkGetImageSparseMemoryRequirements[2KHR]() to retrieve requirements.", - HandleToUint64(image_state->image)); - } - for (uint32_t j = 0; j < image_bind.bindCount; ++j) { - if (image_bind.pBinds[j].flags & VK_IMAGE_ASPECT_METADATA_BIT) { - image_state->sparse_metadata_bound = true; - } - } - } - for (uint32_t i = 0; i < bindInfo.imageOpaqueBindCount; ++i) { - auto image_state = GetImageState(dev_data, bindInfo.pImageOpaqueBinds[i].image); - sparse_images.insert(image_state); - if (!image_state->get_sparse_reqs_called || image_state->sparse_requirements.empty()) { - // For now just warning if sparse image binding occurs without calling to get reqs first - return log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(image_state->image), MEMTRACK_INVALID_STATE, - "vkQueueBindSparse(): Binding opaque sparse memory to image 0x%" PRIx64 - " without first calling vkGetImageSparseMemoryRequirements[2KHR]() to retrieve requirements.", - HandleToUint64(image_state->image)); - } - } - for (const auto &sparse_image_state : sparse_images) { - if (sparse_image_state->sparse_metadata_required && !sparse_image_state->sparse_metadata_bound) { - // Warn if sparse image binding metadata required for image with sparse binding, but metadata not bound - return log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(sparse_image_state->image), MEMTRACK_INVALID_STATE, - "vkQueueBindSparse(): Binding sparse memory to image 0x%" PRIx64 - " which requires a metadata aspect but no binding with VK_IMAGE_ASPECT_METADATA_BIT set was made.", - HandleToUint64(sparse_image_state->image)); - } - } - } - - return skip; -} -static void PostCallRecordQueueBindSparse(layer_data *dev_data, VkQueue queue, uint32_t bindInfoCount, - const VkBindSparseInfo *pBindInfo, VkFence fence) { - uint64_t early_retire_seq = 0; - auto pFence = GetFenceNode(dev_data, fence); - auto pQueue = GetQueueState(dev_data, queue); - - if (pFence) { - if (pFence->scope == kSyncScopeInternal) { - SubmitFence(pQueue, pFence, std::max(1u, bindInfoCount)); - if (!bindInfoCount) { - // No work to do, just dropping a fence in the queue by itself. - pQueue->submissions.emplace_back(std::vector(), std::vector(), - std::vector(), std::vector(), fence); - } - } else { - // Retire work up until this fence early, we will not see the wait that corresponds to this signal - early_retire_seq = pQueue->seq + pQueue->submissions.size(); - if (!dev_data->external_sync_warning) { - dev_data->external_sync_warning = true; - log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(fence), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "vkQueueBindSparse(): Signaling external fence 0x%" PRIx64 " on queue 0x%" PRIx64 - " will disable validation of preceding command buffer lifecycle states and the in-use status of associated " - "objects.", - HandleToUint64(fence), HandleToUint64(queue)); - } - } - } - - for (uint32_t bindIdx = 0; bindIdx < bindInfoCount; ++bindIdx) { - const VkBindSparseInfo &bindInfo = pBindInfo[bindIdx]; - // Track objects tied to memory - for (uint32_t j = 0; j < bindInfo.bufferBindCount; j++) { - for (uint32_t k = 0; k < bindInfo.pBufferBinds[j].bindCount; k++) { - auto sparse_binding = bindInfo.pBufferBinds[j].pBinds[k]; - SetSparseMemBinding(dev_data, {sparse_binding.memory, sparse_binding.memoryOffset, sparse_binding.size}, - HandleToUint64(bindInfo.pBufferBinds[j].buffer), kVulkanObjectTypeBuffer); - } - } - for (uint32_t j = 0; j < bindInfo.imageOpaqueBindCount; j++) { - for (uint32_t k = 0; k < bindInfo.pImageOpaqueBinds[j].bindCount; k++) { - auto sparse_binding = bindInfo.pImageOpaqueBinds[j].pBinds[k]; - SetSparseMemBinding(dev_data, {sparse_binding.memory, sparse_binding.memoryOffset, sparse_binding.size}, - HandleToUint64(bindInfo.pImageOpaqueBinds[j].image), kVulkanObjectTypeImage); - } - } - for (uint32_t j = 0; j < bindInfo.imageBindCount; j++) { - for (uint32_t k = 0; k < bindInfo.pImageBinds[j].bindCount; k++) { - auto sparse_binding = bindInfo.pImageBinds[j].pBinds[k]; - // TODO: This size is broken for non-opaque bindings, need to update to comprehend full sparse binding data - VkDeviceSize size = sparse_binding.extent.depth * sparse_binding.extent.height * sparse_binding.extent.width * 4; - SetSparseMemBinding(dev_data, {sparse_binding.memory, sparse_binding.memoryOffset, size}, - HandleToUint64(bindInfo.pImageBinds[j].image), kVulkanObjectTypeImage); - } - } - - std::vector semaphore_waits; - std::vector semaphore_signals; - std::vector semaphore_externals; - for (uint32_t i = 0; i < bindInfo.waitSemaphoreCount; ++i) { - VkSemaphore semaphore = bindInfo.pWaitSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore) { - if (pSemaphore->scope == kSyncScopeInternal) { - if (pSemaphore->signaler.first != VK_NULL_HANDLE) { - semaphore_waits.push_back({semaphore, pSemaphore->signaler.first, pSemaphore->signaler.second}); - pSemaphore->in_use.fetch_add(1); - } - pSemaphore->signaler.first = VK_NULL_HANDLE; - pSemaphore->signaled = false; - } else { - semaphore_externals.push_back(semaphore); - pSemaphore->in_use.fetch_add(1); - if (pSemaphore->scope == kSyncScopeExternalTemporary) { - pSemaphore->scope = kSyncScopeInternal; - } - } - } - } - for (uint32_t i = 0; i < bindInfo.signalSemaphoreCount; ++i) { - VkSemaphore semaphore = bindInfo.pSignalSemaphores[i]; - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore) { - if (pSemaphore->scope == kSyncScopeInternal) { - pSemaphore->signaler.first = queue; - pSemaphore->signaler.second = pQueue->seq + pQueue->submissions.size() + 1; - pSemaphore->signaled = true; - pSemaphore->in_use.fetch_add(1); - semaphore_signals.push_back(semaphore); - } else { - // Retire work up until this submit early, we will not see the wait that corresponds to this signal - early_retire_seq = std::max(early_retire_seq, pQueue->seq + pQueue->submissions.size() + 1); - if (!dev_data->external_sync_warning) { - dev_data->external_sync_warning = true; - log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - HandleToUint64(semaphore), DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "vkQueueBindSparse(): Signaling external semaphore 0x%" PRIx64 " on queue 0x%" PRIx64 - " will disable validation of preceding command buffer lifecycle states and the in-use status of " - "associated objects.", - HandleToUint64(semaphore), HandleToUint64(queue)); - } - } - } - } - - pQueue->submissions.emplace_back(std::vector(), semaphore_waits, semaphore_signals, semaphore_externals, - bindIdx == bindInfoCount - 1 ? fence : VK_NULL_HANDLE); - } - - if (early_retire_seq) { - RetireWorkOnQueue(dev_data, pQueue, early_retire_seq); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, - VkFence fence) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateQueueBindSparse(dev_data, queue, bindInfoCount, pBindInfo, fence); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); - - lock.lock(); - PostCallRecordQueueBindSparse(dev_data, queue, bindInfoCount, pBindInfo, fence); - lock.unlock(); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); - if (result == VK_SUCCESS) { - lock_guard_t lock(global_lock); - SEMAPHORE_NODE *sNode = &dev_data->semaphoreMap[*pSemaphore]; - sNode->signaler.first = VK_NULL_HANDLE; - sNode->signaler.second = 0; - sNode->signaled = false; - sNode->scope = kSyncScopeInternal; - } - return result; -} - -static bool PreCallValidateImportSemaphore(layer_data *dev_data, VkSemaphore semaphore, const char *caller_name) { - SEMAPHORE_NODE *sema_node = GetSemaphoreNode(dev_data, semaphore); - VK_OBJECT obj_struct = {HandleToUint64(semaphore), kVulkanObjectTypeSemaphore}; - bool skip = false; - if (sema_node) { - skip |= ValidateObjectNotInUse(dev_data, sema_node, obj_struct, caller_name, VALIDATION_ERROR_UNDEFINED); - } - return skip; -} - -static void PostCallRecordImportSemaphore(layer_data *dev_data, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHR handle_type, VkSemaphoreImportFlagsKHR flags) { - SEMAPHORE_NODE *sema_node = GetSemaphoreNode(dev_data, semaphore); - if (sema_node && sema_node->scope != kSyncScopeExternalPermanent) { - if ((handle_type == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR || flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR) && - sema_node->scope == kSyncScopeInternal) { - sema_node->scope = kSyncScopeExternalTemporary; - } else { - sema_node->scope = kSyncScopeExternalPermanent; - } - } -} - -#ifdef VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL -ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = - PreCallValidateImportSemaphore(dev_data, pImportSemaphoreWin32HandleInfo->semaphore, "vkImportSemaphoreWin32HandleKHR"); - - if (!skip) { - result = dev_data->dispatch_table.ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); - } - - if (result == VK_SUCCESS) { - PostCallRecordImportSemaphore(dev_data, pImportSemaphoreWin32HandleInfo->semaphore, - pImportSemaphoreWin32HandleInfo->handleType, pImportSemaphoreWin32HandleInfo->flags); - } - return result; -} -#endif - -VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = PreCallValidateImportSemaphore(dev_data, pImportSemaphoreFdInfo->semaphore, "vkImportSemaphoreFdKHR"); - - if (!skip) { - result = dev_data->dispatch_table.ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); - } - - if (result == VK_SUCCESS) { - PostCallRecordImportSemaphore(dev_data, pImportSemaphoreFdInfo->semaphore, pImportSemaphoreFdInfo->handleType, - pImportSemaphoreFdInfo->flags); - } - return result; -} - -static void PostCallRecordGetSemaphore(layer_data *dev_data, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHR handle_type) { - SEMAPHORE_NODE *sema_node = GetSemaphoreNode(dev_data, semaphore); - if (sema_node && handle_type != VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR) { - // Cannot track semaphore state once it is exported, except for Sync FD handle types which have copy transference - sema_node->scope = kSyncScopeExternalPermanent; - } -} - -#ifdef VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, - HANDLE *pHandle) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); - - if (result == VK_SUCCESS) { - PostCallRecordGetSemaphore(dev_data, pGetWin32HandleInfo->semaphore, pGetWin32HandleInfo->handleType); - } - return result; -} -#endif - -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.GetSemaphoreFdKHR(device, pGetFdInfo, pFd); - - if (result == VK_SUCCESS) { - PostCallRecordGetSemaphore(dev_data, pGetFdInfo->semaphore, pGetFdInfo->handleType); - } - return result; -} - -static bool PreCallValidateImportFence(layer_data *dev_data, VkFence fence, const char *caller_name) { - FENCE_NODE *fence_node = GetFenceNode(dev_data, fence); - bool skip = false; - if (fence_node && fence_node->scope == kSyncScopeInternal && fence_node->state == FENCE_INFLIGHT) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - HandleToUint64(fence), VALIDATION_ERROR_UNDEFINED, - "Cannot call %s on fence 0x%" PRIx64 " that is currently in use.", caller_name, HandleToUint64(fence)); - } - return skip; -} - -static void PostCallRecordImportFence(layer_data *dev_data, VkFence fence, VkExternalFenceHandleTypeFlagBitsKHR handle_type, - VkFenceImportFlagsKHR flags) { - FENCE_NODE *fence_node = GetFenceNode(dev_data, fence); - if (fence_node && fence_node->scope != kSyncScopeExternalPermanent) { - if ((handle_type == VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR || flags & VK_FENCE_IMPORT_TEMPORARY_BIT_KHR) && - fence_node->scope == kSyncScopeInternal) { - fence_node->scope = kSyncScopeExternalTemporary; - } else { - fence_node->scope = kSyncScopeExternalPermanent; - } - } -} - -#ifdef VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(VkDevice device, - const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = PreCallValidateImportFence(dev_data, pImportFenceWin32HandleInfo->fence, "vkImportFenceWin32HandleKHR"); - - if (!skip) { - result = dev_data->dispatch_table.ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); - } - - if (result == VK_SUCCESS) { - PostCallRecordImportFence(dev_data, pImportFenceWin32HandleInfo->fence, pImportFenceWin32HandleInfo->handleType, - pImportFenceWin32HandleInfo->flags); - } - return result; -} -#endif - -VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = PreCallValidateImportFence(dev_data, pImportFenceFdInfo->fence, "vkImportFenceFdKHR"); - - if (!skip) { - result = dev_data->dispatch_table.ImportFenceFdKHR(device, pImportFenceFdInfo); - } - - if (result == VK_SUCCESS) { - PostCallRecordImportFence(dev_data, pImportFenceFdInfo->fence, pImportFenceFdInfo->handleType, pImportFenceFdInfo->flags); - } - return result; -} - -static void PostCallRecordGetFence(layer_data *dev_data, VkFence fence, VkExternalFenceHandleTypeFlagBitsKHR handle_type) { - FENCE_NODE *fence_node = GetFenceNode(dev_data, fence); - if (fence_node) { - if (handle_type != VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR) { - // Export with reference transference becomes external - fence_node->scope = kSyncScopeExternalPermanent; - } else if (fence_node->scope == kSyncScopeInternal) { - // Export with copy transference has a side effect of resetting the fence - fence_node->state = FENCE_UNSIGNALED; - } - } -} - -#ifdef VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, - HANDLE *pHandle) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); - - if (result == VK_SUCCESS) { - PostCallRecordGetFence(dev_data, pGetWin32HandleInfo->fence, pGetWin32HandleInfo->handleType); - } - return result; -} -#endif - -VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.GetFenceFdKHR(device, pGetFdInfo, pFd); - - if (result == VK_SUCCESS) { - PostCallRecordGetFence(dev_data, pGetFdInfo->fence, pGetFdInfo->handleType); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent); - if (result == VK_SUCCESS) { - lock_guard_t lock(global_lock); - dev_data->eventMap[*pEvent].needsSignaled = false; - dev_data->eventMap[*pEvent].write_in_use = 0; - dev_data->eventMap[*pEvent].stageMask = VkPipelineStageFlags(0); - } - return result; -} - -static bool PreCallValidateCreateSwapchainKHR(layer_data *dev_data, const char *func_name, - VkSwapchainCreateInfoKHR const *pCreateInfo, SURFACE_STATE *surface_state, - SWAPCHAIN_NODE *old_swapchain_state) { - auto most_recent_swapchain = surface_state->swapchain ? surface_state->swapchain : surface_state->old_swapchain; - - // TODO: revisit this. some of these rules are being relaxed. - - // All physical devices and queue families are required to be able - // to present to any native window on Android; require the - // application to have established support on any other platform. - if (!dev_data->instance_data->extensions.vk_khr_android_surface) { - auto support_predicate = [dev_data](decltype(surface_state->gpu_queue_support)::value_type qs) -> bool { - // TODO: should restrict search only to queue families of VkDeviceQueueCreateInfos, not whole phys. device - return (qs.first.gpu == dev_data->physical_device) && qs.second; - }; - const auto &support = surface_state->gpu_queue_support; - bool is_supported = std::any_of(support.begin(), support.end(), support_predicate); - - if (!is_supported) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009ec, - "%s: pCreateInfo->surface is not known at this time to be supported for presentation by this device. The " - "vkGetPhysicalDeviceSurfaceSupportKHR() must be called beforehand, and it must return VK_TRUE support with " - "this surface for at least one queue family of this device.", - func_name)) - return true; - } - } - - if (most_recent_swapchain != old_swapchain_state || (surface_state->old_swapchain && surface_state->swapchain)) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), DRAWSTATE_SWAPCHAIN_ALREADY_EXISTS, - "%s: surface has an existing swapchain other than oldSwapchain", func_name)) - return true; - } - if (old_swapchain_state && old_swapchain_state->createInfo.surface != pCreateInfo->surface) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(pCreateInfo->oldSwapchain), DRAWSTATE_SWAPCHAIN_WRONG_SURFACE, - "%s: pCreateInfo->oldSwapchain's surface is not pCreateInfo->surface", func_name)) - return true; - } - - if ((pCreateInfo->imageExtent.width == 0) || (pCreateInfo->imageExtent.height == 0)) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_14600d32, - "%s: pCreateInfo->imageExtent = (%d, %d) which is illegal.", func_name, pCreateInfo->imageExtent.width, - pCreateInfo->imageExtent.height)) - return true; - } - - auto physical_device_state = GetPhysicalDeviceState(dev_data->instance_data, dev_data->physical_device); - if (physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState == UNCALLED) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - HandleToUint64(dev_data->physical_device), DRAWSTATE_SWAPCHAIN_CREATE_BEFORE_QUERY, - "%s: surface capabilities not retrieved for this physical device", func_name)) - return true; - } else { // have valid capabilities - auto &capabilities = physical_device_state->surfaceCapabilities; - // Validate pCreateInfo->minImageCount against VkSurfaceCapabilitiesKHR::{min|max}ImageCount: - if (pCreateInfo->minImageCount < capabilities.minImageCount) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009ee, - "%s called with minImageCount = %d, which is outside the bounds returned by " - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR() (i.e. minImageCount = %d, maxImageCount = %d).", - func_name, pCreateInfo->minImageCount, capabilities.minImageCount, capabilities.maxImageCount)) - return true; - } - - if ((capabilities.maxImageCount > 0) && (pCreateInfo->minImageCount > capabilities.maxImageCount)) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009f0, - "%s called with minImageCount = %d, which is outside the bounds returned by " - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR() (i.e. minImageCount = %d, maxImageCount = %d).", - func_name, pCreateInfo->minImageCount, capabilities.minImageCount, capabilities.maxImageCount)) - return true; - } - - // Validate pCreateInfo->imageExtent against VkSurfaceCapabilitiesKHR::{current|min|max}ImageExtent: - if ((pCreateInfo->imageExtent.width < capabilities.minImageExtent.width) || - (pCreateInfo->imageExtent.width > capabilities.maxImageExtent.width) || - (pCreateInfo->imageExtent.height < capabilities.minImageExtent.height) || - (pCreateInfo->imageExtent.height > capabilities.maxImageExtent.height)) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009f4, - "%s called with imageExtent = (%d,%d), which is outside the bounds returned by " - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): currentExtent = (%d,%d), minImageExtent = (%d,%d), " - "maxImageExtent = (%d,%d).", - func_name, pCreateInfo->imageExtent.width, pCreateInfo->imageExtent.height, - capabilities.currentExtent.width, capabilities.currentExtent.height, capabilities.minImageExtent.width, - capabilities.minImageExtent.height, capabilities.maxImageExtent.width, capabilities.maxImageExtent.height)) - return true; - } - // pCreateInfo->preTransform should have exactly one bit set, and that bit must also be set in - // VkSurfaceCapabilitiesKHR::supportedTransforms. - if (!pCreateInfo->preTransform || (pCreateInfo->preTransform & (pCreateInfo->preTransform - 1)) || - !(pCreateInfo->preTransform & capabilities.supportedTransforms)) { - // This is an error situation; one for which we'd like to give the developer a helpful, multi-line error message. Build - // it up a little at a time, and then log it: - std::string errorString = ""; - char str[1024]; - // Here's the first part of the message: - sprintf(str, "%s called with a non-supported pCreateInfo->preTransform (i.e. %s). Supported values are:\n", func_name, - string_VkSurfaceTransformFlagBitsKHR(pCreateInfo->preTransform)); - errorString += str; - for (int i = 0; i < 32; i++) { - // Build up the rest of the message: - if ((1 << i) & capabilities.supportedTransforms) { - const char *newStr = string_VkSurfaceTransformFlagBitsKHR((VkSurfaceTransformFlagBitsKHR)(1 << i)); - sprintf(str, " %s\n", newStr); - errorString += str; - } - } - // Log the message that we've built up: - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009fe, "%s.", errorString.c_str())) - return true; - } - - // pCreateInfo->compositeAlpha should have exactly one bit set, and that bit must also be set in - // VkSurfaceCapabilitiesKHR::supportedCompositeAlpha - if (!pCreateInfo->compositeAlpha || (pCreateInfo->compositeAlpha & (pCreateInfo->compositeAlpha - 1)) || - !((pCreateInfo->compositeAlpha) & capabilities.supportedCompositeAlpha)) { - // This is an error situation; one for which we'd like to give the developer a helpful, multi-line error message. Build - // it up a little at a time, and then log it: - std::string errorString = ""; - char str[1024]; - // Here's the first part of the message: - sprintf(str, "%s called with a non-supported pCreateInfo->compositeAlpha (i.e. %s). Supported values are:\n", - func_name, string_VkCompositeAlphaFlagBitsKHR(pCreateInfo->compositeAlpha)); - errorString += str; - for (int i = 0; i < 32; i++) { - // Build up the rest of the message: - if ((1 << i) & capabilities.supportedCompositeAlpha) { - const char *newStr = string_VkCompositeAlphaFlagBitsKHR((VkCompositeAlphaFlagBitsKHR)(1 << i)); - sprintf(str, " %s\n", newStr); - errorString += str; - } - } - // Log the message that we've built up: - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_14600a00, "%s.", errorString.c_str())) - return true; - } - // Validate pCreateInfo->imageArrayLayers against VkSurfaceCapabilitiesKHR::maxImageArrayLayers: - if (pCreateInfo->imageArrayLayers > capabilities.maxImageArrayLayers) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009f6, - "%s called with a non-supported imageArrayLayers (i.e. %d). Maximum value is %d.", func_name, - pCreateInfo->imageArrayLayers, capabilities.maxImageArrayLayers)) - return true; - } - // Validate pCreateInfo->imageUsage against VkSurfaceCapabilitiesKHR::supportedUsageFlags: - if (pCreateInfo->imageUsage != (pCreateInfo->imageUsage & capabilities.supportedUsageFlags)) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009f8, - "%s called with a non-supported pCreateInfo->imageUsage (i.e. 0x%08x). Supported flag bits are 0x%08x.", - func_name, pCreateInfo->imageUsage, capabilities.supportedUsageFlags)) - return true; - } - } - - // Validate pCreateInfo values with the results of vkGetPhysicalDeviceSurfaceFormatsKHR(): - if (physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState != QUERY_DETAILS) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), DRAWSTATE_SWAPCHAIN_CREATE_BEFORE_QUERY, - "%s called before calling vkGetPhysicalDeviceSurfaceFormatsKHR().", func_name)) - return true; - } else { - // Validate pCreateInfo->imageFormat against VkSurfaceFormatKHR::format: - bool foundFormat = false; - bool foundColorSpace = false; - bool foundMatch = false; - for (auto const &format : physical_device_state->surface_formats) { - if (pCreateInfo->imageFormat == format.format) { - // Validate pCreateInfo->imageColorSpace against VkSurfaceFormatKHR::colorSpace: - foundFormat = true; - if (pCreateInfo->imageColorSpace == format.colorSpace) { - foundMatch = true; - break; - } - } else { - if (pCreateInfo->imageColorSpace == format.colorSpace) { - foundColorSpace = true; - } - } - } - if (!foundMatch) { - if (!foundFormat) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009f2, - "%s called with a non-supported pCreateInfo->imageFormat (i.e. %d).", func_name, - pCreateInfo->imageFormat)) - return true; - } - if (!foundColorSpace) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_146009f2, - "%s called with a non-supported pCreateInfo->imageColorSpace (i.e. %d).", func_name, - pCreateInfo->imageColorSpace)) - return true; - } - } - } - - // Validate pCreateInfo values with the results of vkGetPhysicalDeviceSurfacePresentModesKHR(): - if (physical_device_state->vkGetPhysicalDeviceSurfacePresentModesKHRState != QUERY_DETAILS) { - // FIFO is required to always be supported - if (pCreateInfo->presentMode != VK_PRESENT_MODE_FIFO_KHR) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), DRAWSTATE_SWAPCHAIN_CREATE_BEFORE_QUERY, - "%s called before calling vkGetPhysicalDeviceSurfacePresentModesKHR().", func_name)) - return true; - } - } else { - // Validate pCreateInfo->presentMode against vkGetPhysicalDeviceSurfacePresentModesKHR(): - bool foundMatch = std::find(physical_device_state->present_modes.begin(), physical_device_state->present_modes.end(), - pCreateInfo->presentMode) != physical_device_state->present_modes.end(); - if (!foundMatch) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_14600a02, - "%s called with a non-supported presentMode (i.e. %s).", func_name, - string_VkPresentModeKHR(pCreateInfo->presentMode))) - return true; - } - } - // Validate state for shared presentable case - if (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR == pCreateInfo->presentMode || - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR == pCreateInfo->presentMode) { - if (!dev_data->extensions.vk_khr_shared_presentable_image) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), DRAWSTATE_EXTENSION_NOT_ENABLED, - "%s called with presentMode %s which requires the VK_KHR_shared_presentable_image extension, which has not " - "been enabled.", - func_name, string_VkPresentModeKHR(pCreateInfo->presentMode))) - return true; - } else if (pCreateInfo->minImageCount != 1) { - if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(dev_data->device), VALIDATION_ERROR_14600ace, - "%s called with presentMode %s, but minImageCount value is %d. For shared presentable image, minImageCount " - "must be 1.", - func_name, string_VkPresentModeKHR(pCreateInfo->presentMode), pCreateInfo->minImageCount)) - return true; - } - } - - return false; -} - -static void PostCallRecordCreateSwapchainKHR(layer_data *dev_data, VkResult result, const VkSwapchainCreateInfoKHR *pCreateInfo, - VkSwapchainKHR *pSwapchain, SURFACE_STATE *surface_state, - SWAPCHAIN_NODE *old_swapchain_state) { - if (VK_SUCCESS == result) { - lock_guard_t lock(global_lock); - auto swapchain_state = unique_ptr(new SWAPCHAIN_NODE(pCreateInfo, *pSwapchain)); - if (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR == pCreateInfo->presentMode || - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR == pCreateInfo->presentMode) { - swapchain_state->shared_presentable = true; - } - surface_state->swapchain = swapchain_state.get(); - dev_data->swapchainMap[*pSwapchain] = std::move(swapchain_state); - } else { - surface_state->swapchain = nullptr; - } - // Spec requires that even if CreateSwapchainKHR fails, oldSwapchain behaves as replaced. - if (old_swapchain_state) { - old_swapchain_state->replaced = true; - } - surface_state->old_swapchain = old_swapchain_state; - return; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - auto surface_state = GetSurfaceState(dev_data->instance_data, pCreateInfo->surface); - auto old_swapchain_state = GetSwapchainNode(dev_data, pCreateInfo->oldSwapchain); - - if (PreCallValidateCreateSwapchainKHR(dev_data, "vkCreateSwapChainKHR()", pCreateInfo, surface_state, old_swapchain_state)) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - VkResult result = dev_data->dispatch_table.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); - - PostCallRecordCreateSwapchainKHR(dev_data, result, pCreateInfo, pSwapchain, surface_state, old_swapchain_state); - - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - - unique_lock_t lock(global_lock); - auto swapchain_data = GetSwapchainNode(dev_data, swapchain); - if (swapchain_data) { - // Pre-record to avoid Destroy/Create race - if (swapchain_data->images.size() > 0) { - for (auto swapchain_image : swapchain_data->images) { - auto image_sub = dev_data->imageSubresourceMap.find(swapchain_image); - if (image_sub != dev_data->imageSubresourceMap.end()) { - for (auto imgsubpair : image_sub->second) { - auto image_item = dev_data->imageLayoutMap.find(imgsubpair); - if (image_item != dev_data->imageLayoutMap.end()) { - dev_data->imageLayoutMap.erase(image_item); - } - } - dev_data->imageSubresourceMap.erase(image_sub); - } - skip = ClearMemoryObjectBindings(dev_data, HandleToUint64(swapchain_image), kVulkanObjectTypeSwapchainKHR); - dev_data->imageMap.erase(swapchain_image); - } - } - - auto surface_state = GetSurfaceState(dev_data->instance_data, swapchain_data->createInfo.surface); - if (surface_state) { - if (surface_state->swapchain == swapchain_data) surface_state->swapchain = nullptr; - if (surface_state->old_swapchain == swapchain_data) surface_state->old_swapchain = nullptr; - } - - dev_data->swapchainMap.erase(swapchain); - } - lock.unlock(); - if (!skip) dev_data->dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator); -} - -static bool PreCallValidateGetSwapchainImagesKHR(layer_data *device_data, SWAPCHAIN_NODE *swapchain_state, VkDevice device, - uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { - bool skip = false; - if (swapchain_state && pSwapchainImages) { - lock_guard_t lock(global_lock); - // Compare the preliminary value of *pSwapchainImageCount with the value this time: - if (swapchain_state->vkGetSwapchainImagesKHRState == UNCALLED) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(device), SWAPCHAIN_PRIOR_COUNT, - "vkGetSwapchainImagesKHR() called with non-NULL pSwapchainImageCount; but no prior positive value has " - "been seen for pSwapchainImages."); - } else if (*pSwapchainImageCount > swapchain_state->get_swapchain_image_count) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(device), SWAPCHAIN_INVALID_COUNT, - "vkGetSwapchainImagesKHR() called with non-NULL pSwapchainImageCount, and with pSwapchainImages set to a " - "value (%d) that is greater than the value (%d) that was returned when pSwapchainImageCount was NULL.", - *pSwapchainImageCount, swapchain_state->get_swapchain_image_count); - } - } - return skip; -} - -static void PostCallRecordGetSwapchainImagesKHR(layer_data *device_data, SWAPCHAIN_NODE *swapchain_state, VkDevice device, - uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { - lock_guard_t lock(global_lock); - - if (*pSwapchainImageCount > swapchain_state->images.size()) swapchain_state->images.resize(*pSwapchainImageCount); - - if (pSwapchainImages) { - if (swapchain_state->vkGetSwapchainImagesKHRState < QUERY_DETAILS) { - swapchain_state->vkGetSwapchainImagesKHRState = QUERY_DETAILS; - } - for (uint32_t i = 0; i < *pSwapchainImageCount; ++i) { - if (swapchain_state->images[i] != VK_NULL_HANDLE) continue; // Already retrieved this. - - IMAGE_LAYOUT_NODE image_layout_node; - image_layout_node.layout = VK_IMAGE_LAYOUT_UNDEFINED; - image_layout_node.format = swapchain_state->createInfo.imageFormat; - // Add imageMap entries for each swapchain image - VkImageCreateInfo image_ci = {}; - image_ci.flags = 0; - image_ci.imageType = VK_IMAGE_TYPE_2D; - image_ci.format = swapchain_state->createInfo.imageFormat; - image_ci.extent.width = swapchain_state->createInfo.imageExtent.width; - image_ci.extent.height = swapchain_state->createInfo.imageExtent.height; - image_ci.extent.depth = 1; - image_ci.mipLevels = 1; - image_ci.arrayLayers = swapchain_state->createInfo.imageArrayLayers; - image_ci.samples = VK_SAMPLE_COUNT_1_BIT; - image_ci.tiling = VK_IMAGE_TILING_OPTIMAL; - image_ci.usage = swapchain_state->createInfo.imageUsage; - image_ci.sharingMode = swapchain_state->createInfo.imageSharingMode; - device_data->imageMap[pSwapchainImages[i]] = unique_ptr(new IMAGE_STATE(pSwapchainImages[i], &image_ci)); - auto &image_state = device_data->imageMap[pSwapchainImages[i]]; - image_state->valid = false; - image_state->binding.mem = MEMTRACKER_SWAP_CHAIN_IMAGE_KEY; - swapchain_state->images[i] = pSwapchainImages[i]; - ImageSubresourcePair subpair = {pSwapchainImages[i], false, VkImageSubresource()}; - device_data->imageSubresourceMap[pSwapchainImages[i]].push_back(subpair); - device_data->imageLayoutMap[subpair] = image_layout_node; - } - } - - if (*pSwapchainImageCount) { - if (swapchain_state->vkGetSwapchainImagesKHRState < QUERY_COUNT) { - swapchain_state->vkGetSwapchainImagesKHRState = QUERY_COUNT; - } - swapchain_state->get_swapchain_image_count = *pSwapchainImageCount; - } -} - -VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, - VkImage *pSwapchainImages) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - auto swapchain_state = GetSwapchainNode(device_data, swapchain); - bool skip = PreCallValidateGetSwapchainImagesKHR(device_data, swapchain_state, device, pSwapchainImageCount, pSwapchainImages); - - if (!skip) { - result = device_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); - } - - if ((result == VK_SUCCESS || result == VK_INCOMPLETE)) { - PostCallRecordGetSwapchainImagesKHR(device_data, swapchain_state, device, pSwapchainImageCount, pSwapchainImages); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - bool skip = false; - - lock_guard_t lock(global_lock); - auto queue_state = GetQueueState(dev_data, queue); - - for (uint32_t i = 0; i < pPresentInfo->waitSemaphoreCount; ++i) { - auto pSemaphore = GetSemaphoreNode(dev_data, pPresentInfo->pWaitSemaphores[i]); - if (pSemaphore && !pSemaphore->signaled) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "Queue 0x%" PRIx64 " is waiting on semaphore 0x%" PRIx64 " that has no way to be signaled.", - HandleToUint64(queue), HandleToUint64(pPresentInfo->pWaitSemaphores[i])); - } - } - - for (uint32_t i = 0; i < pPresentInfo->swapchainCount; ++i) { - auto swapchain_data = GetSwapchainNode(dev_data, pPresentInfo->pSwapchains[i]); - if (swapchain_data) { - if (pPresentInfo->pImageIndices[i] >= swapchain_data->images.size()) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(pPresentInfo->pSwapchains[i]), DRAWSTATE_SWAPCHAIN_INVALID_IMAGE, - "vkQueuePresentKHR: Swapchain image index too large (%u). There are only %u images in this swapchain.", - pPresentInfo->pImageIndices[i], (uint32_t)swapchain_data->images.size()); - } else { - auto image = swapchain_data->images[pPresentInfo->pImageIndices[i]]; - auto image_state = GetImageState(dev_data, image); - - if (image_state->shared_presentable) { - image_state->layout_locked = true; - } - - if (!image_state->acquired) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(pPresentInfo->pSwapchains[i]), DRAWSTATE_SWAPCHAIN_IMAGE_NOT_ACQUIRED, - "vkQueuePresentKHR: Swapchain image index %u has not been acquired.", pPresentInfo->pImageIndices[i]); - } - - vector layouts; - if (FindLayouts(dev_data, image, layouts)) { - for (auto layout : layouts) { - if ((layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) && (!dev_data->extensions.vk_khr_shared_presentable_image || - (layout != VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR))) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(queue), VALIDATION_ERROR_11200a20, - "Images passed to present must be in layout VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or " - "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR but is in %s.", - string_VkImageLayout(layout)); - } - } - } - } - - // All physical devices and queue families are required to be able - // to present to any native window on Android; require the - // application to have established support on any other platform. - if (!dev_data->instance_data->extensions.vk_khr_android_surface) { - auto surface_state = GetSurfaceState(dev_data->instance_data, swapchain_data->createInfo.surface); - auto support_it = surface_state->gpu_queue_support.find({dev_data->physical_device, queue_state->queueFamilyIndex}); - - if (support_it == surface_state->gpu_queue_support.end()) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(pPresentInfo->pSwapchains[i]), DRAWSTATE_SWAPCHAIN_UNSUPPORTED_QUEUE, - "vkQueuePresentKHR: Presenting image without calling vkGetPhysicalDeviceSurfaceSupportKHR"); - } else if (!support_it->second) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(pPresentInfo->pSwapchains[i]), VALIDATION_ERROR_31800a18, - "vkQueuePresentKHR: Presenting image on queue that cannot present to this surface."); - } - } - } - } - if (pPresentInfo && pPresentInfo->pNext) { - // Verify ext struct - const auto *present_regions = lvl_find_in_chain(pPresentInfo->pNext); - if (present_regions) { - for (uint32_t i = 0; i < present_regions->swapchainCount; ++i) { - auto swapchain_data = GetSwapchainNode(dev_data, pPresentInfo->pSwapchains[i]); - assert(swapchain_data); - VkPresentRegionKHR region = present_regions->pRegions[i]; - for (uint32_t j = 0; j < region.rectangleCount; ++j) { - VkRectLayerKHR rect = region.pRectangles[j]; - if ((rect.offset.x + rect.extent.width) > swapchain_data->createInfo.imageExtent.width) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, HandleToUint64(pPresentInfo->pSwapchains[i]), - VALIDATION_ERROR_11e009da, - "vkQueuePresentKHR(): For VkPresentRegionKHR down pNext chain, " - "pRegion[%i].pRectangles[%i], the sum of offset.x (%i) and extent.width (%i) is greater " - "than the corresponding swapchain's imageExtent.width (%i).", - i, j, rect.offset.x, rect.extent.width, swapchain_data->createInfo.imageExtent.width); - } - if ((rect.offset.y + rect.extent.height) > swapchain_data->createInfo.imageExtent.height) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, HandleToUint64(pPresentInfo->pSwapchains[i]), - VALIDATION_ERROR_11e009da, - "vkQueuePresentKHR(): For VkPresentRegionKHR down pNext chain, " - "pRegion[%i].pRectangles[%i], the sum of offset.y (%i) and extent.height (%i) is greater " - "than the corresponding swapchain's imageExtent.height (%i).", - i, j, rect.offset.y, rect.extent.height, swapchain_data->createInfo.imageExtent.height); - } - if (rect.layer > swapchain_data->createInfo.imageArrayLayers) { - skip |= log_msg( - dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(pPresentInfo->pSwapchains[i]), VALIDATION_ERROR_11e009dc, - "vkQueuePresentKHR(): For VkPresentRegionKHR down pNext chain, pRegion[%i].pRectangles[%i], the layer " - "(%i) is greater than the corresponding swapchain's imageArrayLayers (%i).", - i, j, rect.layer, swapchain_data->createInfo.imageArrayLayers); - } - } - } - } - - const auto *present_times_info = lvl_find_in_chain(pPresentInfo->pNext); - if (present_times_info) { - if (pPresentInfo->swapchainCount != present_times_info->swapchainCount) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(pPresentInfo->pSwapchains[0]), - - VALIDATION_ERROR_118009be, - "vkQueuePresentKHR(): VkPresentTimesInfoGOOGLE.swapchainCount is %i but pPresentInfo->swapchainCount " - "is %i. For VkPresentTimesInfoGOOGLE down pNext chain of VkPresentInfoKHR, " - "VkPresentTimesInfoGOOGLE.swapchainCount must equal VkPresentInfoKHR.swapchainCount.", - present_times_info->swapchainCount, pPresentInfo->swapchainCount); - } - } - } - - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - VkResult result = dev_data->dispatch_table.QueuePresentKHR(queue, pPresentInfo); - - if (result != VK_ERROR_VALIDATION_FAILED_EXT) { - // Semaphore waits occur before error generation, if the call reached - // the ICD. (Confirm?) - for (uint32_t i = 0; i < pPresentInfo->waitSemaphoreCount; ++i) { - auto pSemaphore = GetSemaphoreNode(dev_data, pPresentInfo->pWaitSemaphores[i]); - if (pSemaphore) { - pSemaphore->signaler.first = VK_NULL_HANDLE; - pSemaphore->signaled = false; - } - } - - for (uint32_t i = 0; i < pPresentInfo->swapchainCount; ++i) { - // Note: this is imperfect, in that we can get confused about what - // did or didn't succeed-- but if the app does that, it's confused - // itself just as much. - auto local_result = pPresentInfo->pResults ? pPresentInfo->pResults[i] : result; - - if (local_result != VK_SUCCESS && local_result != VK_SUBOPTIMAL_KHR) continue; // this present didn't actually happen. - - // Mark the image as having been released to the WSI - auto swapchain_data = GetSwapchainNode(dev_data, pPresentInfo->pSwapchains[i]); - auto image = swapchain_data->images[pPresentInfo->pImageIndices[i]]; - auto image_state = GetImageState(dev_data, image); - image_state->acquired = false; - } - - // Note: even though presentation is directed to a queue, there is no - // direct ordering between QP and subsequent work, so QP (and its - // semaphore waits) /never/ participate in any completion proof. - } - - return result; -} - -static bool PreCallValidateCreateSharedSwapchainsKHR(layer_data *dev_data, uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR *pCreateInfos, VkSwapchainKHR *pSwapchains, - std::vector &surface_state, - std::vector &old_swapchain_state) { - if (pCreateInfos) { - lock_guard_t lock(global_lock); - for (uint32_t i = 0; i < swapchainCount; i++) { - surface_state.push_back(GetSurfaceState(dev_data->instance_data, pCreateInfos[i].surface)); - old_swapchain_state.push_back(GetSwapchainNode(dev_data, pCreateInfos[i].oldSwapchain)); - std::stringstream func_name; - func_name << "vkCreateSharedSwapchainsKHR[" << swapchainCount << "]"; - if (PreCallValidateCreateSwapchainKHR(dev_data, func_name.str().c_str(), &pCreateInfos[i], surface_state[i], - old_swapchain_state[i])) { - return true; - } - } - } - return false; -} - -static void PostCallRecordCreateSharedSwapchainsKHR(layer_data *dev_data, VkResult result, uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR *pCreateInfos, VkSwapchainKHR *pSwapchains, - std::vector &surface_state, - std::vector &old_swapchain_state) { - if (VK_SUCCESS == result) { - for (uint32_t i = 0; i < swapchainCount; i++) { - auto swapchain_state = unique_ptr(new SWAPCHAIN_NODE(&pCreateInfos[i], pSwapchains[i])); - if (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR == pCreateInfos[i].presentMode || - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR == pCreateInfos[i].presentMode) { - swapchain_state->shared_presentable = true; - } - surface_state[i]->swapchain = swapchain_state.get(); - dev_data->swapchainMap[pSwapchains[i]] = std::move(swapchain_state); - } - } else { - for (uint32_t i = 0; i < swapchainCount; i++) { - surface_state[i]->swapchain = nullptr; - } - } - // Spec requires that even if CreateSharedSwapchainKHR fails, oldSwapchain behaves as replaced. - for (uint32_t i = 0; i < swapchainCount; i++) { - if (old_swapchain_state[i]) { - old_swapchain_state[i]->replaced = true; - } - surface_state[i]->old_swapchain = old_swapchain_state[i]; - } - return; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR *pCreateInfos, - const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::vector surface_state; - std::vector old_swapchain_state; - - if (PreCallValidateCreateSharedSwapchainsKHR(dev_data, swapchainCount, pCreateInfos, pSwapchains, surface_state, - old_swapchain_state)) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - VkResult result = - dev_data->dispatch_table.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); - - PostCallRecordCreateSharedSwapchainsKHR(dev_data, result, swapchainCount, pCreateInfos, pSwapchains, surface_state, - old_swapchain_state); - - return result; -} - -static bool PreCallValidateAcquireNextImageKHR(layer_data *dev_data, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, - VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { - bool skip = false; - if (fence == VK_NULL_HANDLE && semaphore == VK_NULL_HANDLE) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(device), DRAWSTATE_SWAPCHAIN_NO_SYNC_FOR_ACQUIRE, - "vkAcquireNextImageKHR: Semaphore and fence cannot both be VK_NULL_HANDLE. There would be no way to " - "determine the completion of this operation."); - } - - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore && pSemaphore->scope == kSyncScopeInternal && pSemaphore->signaled) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - HandleToUint64(semaphore), VALIDATION_ERROR_16400a0c, - "vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state."); - } - - auto pFence = GetFenceNode(dev_data, fence); - if (pFence) { - skip |= ValidateFenceForSubmit(dev_data, pFence); - } - - auto swapchain_data = GetSwapchainNode(dev_data, swapchain); - if (swapchain_data->replaced) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(swapchain), DRAWSTATE_SWAPCHAIN_REPLACED, - "vkAcquireNextImageKHR: This swapchain has been replaced. The application can still present any images it " - "has acquired, but cannot acquire any more."); - } - - auto physical_device_state = GetPhysicalDeviceState(dev_data->instance_data, dev_data->physical_device); - if (physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState != UNCALLED) { - uint64_t acquired_images = std::count_if(swapchain_data->images.begin(), swapchain_data->images.end(), - [=](VkImage image) { return GetImageState(dev_data, image)->acquired; }); - if (acquired_images > swapchain_data->images.size() - physical_device_state->surfaceCapabilities.minImageCount) { - skip |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(swapchain), DRAWSTATE_SWAPCHAIN_TOO_MANY_IMAGES, - "vkAcquireNextImageKHR: Application has already acquired the maximum number of images (0x%" PRIxLEAST64 ")", - acquired_images); - } - } - - if (swapchain_data->images.size() == 0) { - skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - HandleToUint64(swapchain), DRAWSTATE_SWAPCHAIN_IMAGES_NOT_FOUND, - "vkAcquireNextImageKHR: No images found to acquire from. Application probably did not call " - "vkGetSwapchainImagesKHR after swapchain creation."); - } - return skip; -} - -static void PostCallRecordAcquireNextImageKHR(layer_data *dev_data, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, - VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { - auto pFence = GetFenceNode(dev_data, fence); - if (pFence && pFence->scope == kSyncScopeInternal) { - // Treat as inflight since it is valid to wait on this fence, even in cases where it is technically a temporary - // import - pFence->state = FENCE_INFLIGHT; - pFence->signaler.first = VK_NULL_HANDLE; // ANI isn't on a queue, so this can't participate in a completion proof. - } - - auto pSemaphore = GetSemaphoreNode(dev_data, semaphore); - if (pSemaphore && pSemaphore->scope == kSyncScopeInternal) { - // Treat as signaled since it is valid to wait on this semaphore, even in cases where it is technically a - // temporary import - pSemaphore->signaled = true; - pSemaphore->signaler.first = VK_NULL_HANDLE; - } - - // Mark the image as acquired. - auto swapchain_data = GetSwapchainNode(dev_data, swapchain); - auto image = swapchain_data->images[*pImageIndex]; - auto image_state = GetImageState(dev_data, image); - image_state->acquired = true; - image_state->shared_presentable = swapchain_data->shared_presentable; -} - -VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, - VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - unique_lock_t lock(global_lock); - bool skip = PreCallValidateAcquireNextImageKHR(dev_data, device, swapchain, timeout, semaphore, fence, pImageIndex); - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = dev_data->dispatch_table.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); - - lock.lock(); - if (result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR) { - PostCallRecordAcquireNextImageKHR(dev_data, device, swapchain, timeout, semaphore, fence, pImageIndex); - } - lock.unlock(); - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, - VkPhysicalDevice *pPhysicalDevices) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - assert(instance_data); - - // For this instance, flag when vkEnumeratePhysicalDevices goes to QUERY_COUNT and then QUERY_DETAILS - if (NULL == pPhysicalDevices) { - instance_data->vkEnumeratePhysicalDevicesState = QUERY_COUNT; - } else { - if (UNCALLED == instance_data->vkEnumeratePhysicalDevicesState) { - // Flag warning here. You can call this without having queried the count, but it may not be - // robust on platforms with multiple physical devices. - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - 0, DEVLIMITS_MISSING_QUERY_COUNT, - "Call sequence has vkEnumeratePhysicalDevices() w/ non-NULL pPhysicalDevices. You should first call " - "vkEnumeratePhysicalDevices() w/ NULL pPhysicalDevices to query pPhysicalDeviceCount."); - } // TODO : Could also flag a warning if re-calling this function in QUERY_DETAILS state - else if (instance_data->physical_devices_count != *pPhysicalDeviceCount) { - // Having actual count match count from app is not a requirement, so this can be a warning - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, DEVLIMITS_COUNT_MISMATCH, - "Call to vkEnumeratePhysicalDevices() w/ pPhysicalDeviceCount value %u, but actual count supported by " - "this instance is %u.", - *pPhysicalDeviceCount, instance_data->physical_devices_count); - } - instance_data->vkEnumeratePhysicalDevicesState = QUERY_DETAILS; - } - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = instance_data->dispatch_table.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); - if (NULL == pPhysicalDevices) { - instance_data->physical_devices_count = *pPhysicalDeviceCount; - } else if (result == VK_SUCCESS) { // Save physical devices - for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) { - auto &phys_device_state = instance_data->physical_device_map[pPhysicalDevices[i]]; - phys_device_state.phys_device = pPhysicalDevices[i]; - // Init actual features for each physical device - instance_data->dispatch_table.GetPhysicalDeviceFeatures(pPhysicalDevices[i], &phys_device_state.features2.features); - } - } - return result; -} - -// Common function to handle validation for GetPhysicalDeviceQueueFamilyProperties & 2KHR version -static bool ValidateCommonGetPhysicalDeviceQueueFamilyProperties(instance_layer_data *instance_data, - PHYSICAL_DEVICE_STATE *pd_state, - uint32_t requested_queue_family_property_count, bool qfp_null, - const char *caller_name) { - bool skip = false; - if (!qfp_null) { - // Verify that for each physical device, this command is called first with NULL pQueueFamilyProperties in order to get count - if (UNCALLED == pd_state->vkGetPhysicalDeviceQueueFamilyPropertiesState) { - skip |= log_msg( - instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - HandleToUint64(pd_state->phys_device), DEVLIMITS_MISSING_QUERY_COUNT, - "%s is called with non-NULL pQueueFamilyProperties before obtaining pQueueFamilyPropertyCount. It is recommended " - "to first call %s with NULL pQueueFamilyProperties in order to obtain the maximal pQueueFamilyPropertyCount.", - caller_name, caller_name); - // Then verify that pCount that is passed in on second call matches what was returned - } else if (pd_state->queue_family_count != requested_queue_family_property_count) { - skip |= log_msg( - instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - HandleToUint64(pd_state->phys_device), DEVLIMITS_COUNT_MISMATCH, - "%s is called with non-NULL pQueueFamilyProperties and pQueueFamilyPropertyCount value %" PRIu32 - ", but the largest previously returned pQueueFamilyPropertyCount for this physicalDevice is %" PRIu32 - ". It is recommended to instead receive all the properties by calling %s with pQueueFamilyPropertyCount that was " - "previously obtained by calling %s with NULL pQueueFamilyProperties.", - caller_name, requested_queue_family_property_count, pd_state->queue_family_count, caller_name, caller_name); - } - pd_state->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_DETAILS; - } - - return skip; -} - -static bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties(instance_layer_data *instance_data, - PHYSICAL_DEVICE_STATE *pd_state, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties *pQueueFamilyProperties) { - return ValidateCommonGetPhysicalDeviceQueueFamilyProperties(instance_data, pd_state, *pQueueFamilyPropertyCount, - (nullptr == pQueueFamilyProperties), - "vkGetPhysicalDeviceQueueFamilyProperties()"); -} - -static bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(instance_layer_data *instance_data, - PHYSICAL_DEVICE_STATE *pd_state, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - return ValidateCommonGetPhysicalDeviceQueueFamilyProperties(instance_data, pd_state, *pQueueFamilyPropertyCount, - (nullptr == pQueueFamilyProperties), - "vkGetPhysicalDeviceQueueFamilyProperties2[KHR]()"); -} - -// Common function to update state for GetPhysicalDeviceQueueFamilyProperties & 2KHR version -static void StateUpdateCommonGetPhysicalDeviceQueueFamilyProperties(PHYSICAL_DEVICE_STATE *pd_state, uint32_t count, - VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - if (!pQueueFamilyProperties) { - if (UNCALLED == pd_state->vkGetPhysicalDeviceQueueFamilyPropertiesState) - pd_state->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_COUNT; - pd_state->queue_family_count = count; - } else { // Save queue family properties - pd_state->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_DETAILS; - pd_state->queue_family_count = std::max(pd_state->queue_family_count, count); - - pd_state->queue_family_properties.resize(std::max(static_cast(pd_state->queue_family_properties.size()), count)); - for (uint32_t i = 0; i < count; ++i) { - pd_state->queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties; - } - } -} - -static void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(PHYSICAL_DEVICE_STATE *pd_state, uint32_t count, - VkQueueFamilyProperties *pQueueFamilyProperties) { - VkQueueFamilyProperties2KHR *pqfp = nullptr; - std::vector qfp; - qfp.resize(count); - if (pQueueFamilyProperties) { - for (uint32_t i = 0; i < count; ++i) { - qfp[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR; - qfp[i].pNext = nullptr; - qfp[i].queueFamilyProperties = pQueueFamilyProperties[i]; - } - pqfp = qfp.data(); - } - StateUpdateCommonGetPhysicalDeviceQueueFamilyProperties(pd_state, count, pqfp); -} - -static void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(PHYSICAL_DEVICE_STATE *pd_state, uint32_t count, - VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - StateUpdateCommonGetPhysicalDeviceQueueFamilyProperties(pd_state, count, pQueueFamilyProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties *pQueueFamilyProperties) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); - assert(physical_device_state); - unique_lock_t lock(global_lock); - - bool skip = PreCallValidateGetPhysicalDeviceQueueFamilyProperties(instance_data, physical_device_state, - pQueueFamilyPropertyCount, pQueueFamilyProperties); - - lock.unlock(); - - if (skip) return; - - instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, - pQueueFamilyProperties); - - lock.lock(); - PostCallRecordGetPhysicalDeviceQueueFamilyProperties(physical_device_state, *pQueueFamilyPropertyCount, pQueueFamilyProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); - assert(physical_device_state); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(instance_data, physical_device_state, - pQueueFamilyPropertyCount, pQueueFamilyProperties); - lock.unlock(); - if (skip) return; - - instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, - pQueueFamilyProperties); - lock.lock(); - PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(physical_device_state, *pQueueFamilyPropertyCount, - pQueueFamilyProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); - assert(physical_device_state); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(instance_data, physical_device_state, - pQueueFamilyPropertyCount, pQueueFamilyProperties); - lock.unlock(); - if (skip) return; - - instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, - pQueueFamilyProperties); - lock.lock(); - PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(physical_device_state, *pQueueFamilyPropertyCount, - pQueueFamilyProperties); -} - -template -static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInfo, VkAllocationCallbacks const *pAllocator, - VkSurfaceKHR *pSurface, FPtr fptr) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - - // Call down the call chain: - VkResult result = (instance_data->dispatch_table.*fptr)(instance, pCreateInfo, pAllocator, pSurface); - - if (result == VK_SUCCESS) { - unique_lock_t lock(global_lock); - instance_data->surface_map[*pSurface] = SURFACE_STATE(*pSurface); - lock.unlock(); - } - - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - unique_lock_t lock(global_lock); - auto surface_state = GetSurfaceState(instance_data, surface); - - if ((surface_state) && (surface_state->swapchain)) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - HandleToUint64(instance), VALIDATION_ERROR_26c009e4, - "vkDestroySurfaceKHR() called before its associated VkSwapchainKHR was destroyed."); - } - - // Pre-record to avoid Destroy/Create race - instance_data->surface_map.erase(surface); - - lock.unlock(); - if (!skip) { - instance_data->dispatch_table.DestroySurfaceKHR(instance, surface, pAllocator); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateDisplayPlaneSurfaceKHR); -} - -#ifdef VK_USE_PLATFORM_ANDROID_KHR -VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateAndroidSurfaceKHR); -} -#endif // VK_USE_PLATFORM_ANDROID_KHR - -#ifdef VK_USE_PLATFORM_IOS_MVK -VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateIOSSurfaceMVK); -} -#endif // VK_USE_PLATFORM_IOS_MVK - -#ifdef VK_USE_PLATFORM_MACOS_MVK -VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateMacOSSurfaceMVK); -} -#endif // VK_USE_PLATFORM_MACOS_MVK - -#ifdef VK_USE_PLATFORM_MIR_KHR -VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateMirSurfaceKHR); -} - -VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, MirConnection *connection) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - unique_lock_t lock(global_lock); - const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); - - skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2d2009e2, - "vkGetPhysicalDeviceMirPresentationSupportKHR", "queueFamilyIndex"); - - lock.unlock(); - - if (skip) return VK_FALSE; - - // Call down the call chain: - VkBool32 result = - instance_data->dispatch_table.GetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection); - - return result; -} -#endif // VK_USE_PLATFORM_MIR_KHR - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR -VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateWaylandSurfaceKHR); -} - -VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display *display) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - unique_lock_t lock(global_lock); - const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); - - skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f000a34, - "vkGetPhysicalDeviceWaylandPresentationSupportKHR", "queueFamilyIndex"); - - lock.unlock(); - - if (skip) return VK_FALSE; - - // Call down the call chain: - VkBool32 result = - instance_data->dispatch_table.GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); - - return result; -} -#endif // VK_USE_PLATFORM_WAYLAND_KHR - -#ifdef VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateWin32SurfaceKHR); -} - -VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - unique_lock_t lock(global_lock); - const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); - - skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f200a3a, - "vkGetPhysicalDeviceWin32PresentationSupportKHR", "queueFamilyIndex"); - - lock.unlock(); - - if (skip) return VK_FALSE; - - // Call down the call chain: - VkBool32 result = instance_data->dispatch_table.GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); - - return result; -} -#endif // VK_USE_PLATFORM_WIN32_KHR - -#ifdef VK_USE_PLATFORM_XCB_KHR -VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateXcbSurfaceKHR); -} - -VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, xcb_connection_t *connection, - xcb_visualid_t visual_id) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - unique_lock_t lock(global_lock); - const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); - - skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f400a40, - "vkGetPhysicalDeviceXcbPresentationSupportKHR", "queueFamilyIndex"); - - lock.unlock(); - - if (skip) return VK_FALSE; - - // Call down the call chain: - VkBool32 result = instance_data->dispatch_table.GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, - connection, visual_id); - - return result; -} -#endif // VK_USE_PLATFORM_XCB_KHR - -#ifdef VK_USE_PLATFORM_XLIB_KHR -VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateXlibSurfaceKHR); -} - -VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, Display *dpy, - VisualID visualID) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - unique_lock_t lock(global_lock); - const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); - - skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f600a46, - "vkGetPhysicalDeviceXlibPresentationSupportKHR", "queueFamilyIndex"); - - lock.unlock(); - - if (skip) return VK_FALSE; - - // Call down the call chain: - VkBool32 result = - instance_data->dispatch_table.GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); - - return result; -} -#endif // VK_USE_PLATFORM_XLIB_KHR - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { - auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - unique_lock_t lock(global_lock); - auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); - lock.unlock(); - - auto result = - instance_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); - - if (result == VK_SUCCESS) { - physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS; - physical_device_state->surfaceCapabilities = *pSurfaceCapabilities; - } - - return result; -} - -static void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(instance_layer_data *instanceData, - VkPhysicalDevice physicalDevice, - VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { - unique_lock_t lock(global_lock); - auto physicalDeviceState = GetPhysicalDeviceState(instanceData, physicalDevice); - physicalDeviceState->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS; - physicalDeviceState->surfaceCapabilities = pSurfaceCapabilities->surfaceCapabilities; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { - auto instanceData = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - auto result = - instanceData->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); - - if (result == VK_SUCCESS) { - PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(instanceData, physicalDevice, pSurfaceCapabilities); - } - - return result; -} - -static void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(instance_layer_data *instanceData, - VkPhysicalDevice physicalDevice, - VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { - unique_lock_t lock(global_lock); - auto physicalDeviceState = GetPhysicalDeviceState(instanceData, physicalDevice); - physicalDeviceState->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS; - physicalDeviceState->surfaceCapabilities.minImageCount = pSurfaceCapabilities->minImageCount; - physicalDeviceState->surfaceCapabilities.maxImageCount = pSurfaceCapabilities->maxImageCount; - physicalDeviceState->surfaceCapabilities.currentExtent = pSurfaceCapabilities->currentExtent; - physicalDeviceState->surfaceCapabilities.minImageExtent = pSurfaceCapabilities->minImageExtent; - physicalDeviceState->surfaceCapabilities.maxImageExtent = pSurfaceCapabilities->maxImageExtent; - physicalDeviceState->surfaceCapabilities.maxImageArrayLayers = pSurfaceCapabilities->maxImageArrayLayers; - physicalDeviceState->surfaceCapabilities.supportedTransforms = pSurfaceCapabilities->supportedTransforms; - physicalDeviceState->surfaceCapabilities.currentTransform = pSurfaceCapabilities->currentTransform; - physicalDeviceState->surfaceCapabilities.supportedCompositeAlpha = pSurfaceCapabilities->supportedCompositeAlpha; - physicalDeviceState->surfaceCapabilities.supportedUsageFlags = pSurfaceCapabilities->supportedUsageFlags; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { - auto instanceData = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - auto result = - instanceData->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); - - if (result == VK_SUCCESS) { - PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(instanceData, physicalDevice, pSurfaceCapabilities); - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, - VkSurfaceKHR surface, VkBool32 *pSupported) { - bool skip = false; - auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - unique_lock_t lock(global_lock); - const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); - auto surface_state = GetSurfaceState(instance_data, surface); - - skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2ee009ea, - "vkGetPhysicalDeviceSurfaceSupportKHR", "queueFamilyIndex"); - - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - auto result = - instance_data->dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); - - if (result == VK_SUCCESS) { - surface_state->gpu_queue_support[{physicalDevice, queueFamilyIndex}] = (*pSupported == VK_TRUE); - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - uint32_t *pPresentModeCount, - VkPresentModeKHR *pPresentModes) { - bool skip = false; - auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - unique_lock_t lock(global_lock); - // TODO: this isn't quite right. available modes may differ by surface AND physical device. - auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); - auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfacePresentModesKHRState; - - if (pPresentModes) { - // Compare the preliminary value of *pPresentModeCount with the value this time: - auto prev_mode_count = (uint32_t)physical_device_state->present_modes.size(); - switch (call_state) { - case UNCALLED: - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, HandleToUint64(physicalDevice), - DEVLIMITS_MUST_QUERY_COUNT, - "vkGetPhysicalDeviceSurfacePresentModesKHR() called with non-NULL pPresentModeCount; but no prior " - "positive value has been seen for pPresentModeCount."); - break; - default: - // both query count and query details - if (*pPresentModeCount != prev_mode_count) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, HandleToUint64(physicalDevice), - DEVLIMITS_COUNT_MISMATCH, - "vkGetPhysicalDeviceSurfacePresentModesKHR() called with *pPresentModeCount (%u) that differs " - "from the value (%u) that was returned when pPresentModes was NULL.", - *pPresentModeCount, prev_mode_count); - } - break; - } - } - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - auto result = instance_data->dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, - pPresentModes); - - if (result == VK_SUCCESS || result == VK_INCOMPLETE) { - lock.lock(); - - if (*pPresentModeCount) { - if (call_state < QUERY_COUNT) call_state = QUERY_COUNT; - if (*pPresentModeCount > physical_device_state->present_modes.size()) - physical_device_state->present_modes.resize(*pPresentModeCount); - } - if (pPresentModes) { - if (call_state < QUERY_DETAILS) call_state = QUERY_DETAILS; - for (uint32_t i = 0; i < *pPresentModeCount; i++) { - physical_device_state->present_modes[i] = pPresentModes[i]; - } - } - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormatKHR *pSurfaceFormats) { - bool skip = false; - auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - unique_lock_t lock(global_lock); - auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); - auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState; - - if (pSurfaceFormats) { - auto prev_format_count = (uint32_t)physical_device_state->surface_formats.size(); - - switch (call_state) { - case UNCALLED: - // Since we haven't recorded a preliminary value of *pSurfaceFormatCount, that likely means that the application - // didn't - // previously call this function with a NULL value of pSurfaceFormats: - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, HandleToUint64(physicalDevice), - DEVLIMITS_MUST_QUERY_COUNT, - "vkGetPhysicalDeviceSurfaceFormatsKHR() called with non-NULL pSurfaceFormatCount; but no prior " - "positive value has been seen for pSurfaceFormats."); - break; - default: - if (prev_format_count != *pSurfaceFormatCount) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, HandleToUint64(physicalDevice), - DEVLIMITS_COUNT_MISMATCH, - "vkGetPhysicalDeviceSurfaceFormatsKHR() called with non-NULL pSurfaceFormatCount, and with " - "pSurfaceFormats set to a value (%u) that is greater than the value (%u) that was returned " - "when pSurfaceFormatCount was NULL.", - *pSurfaceFormatCount, prev_format_count); - } - break; - } - } - lock.unlock(); - - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - // Call down the call chain: - auto result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, - pSurfaceFormats); - - if (result == VK_SUCCESS || result == VK_INCOMPLETE) { - lock.lock(); - - if (*pSurfaceFormatCount) { - if (call_state < QUERY_COUNT) call_state = QUERY_COUNT; - if (*pSurfaceFormatCount > physical_device_state->surface_formats.size()) - physical_device_state->surface_formats.resize(*pSurfaceFormatCount); - } - if (pSurfaceFormats) { - if (call_state < QUERY_DETAILS) call_state = QUERY_DETAILS; - for (uint32_t i = 0; i < *pSurfaceFormatCount; i++) { - physical_device_state->surface_formats[i] = pSurfaceFormats[i]; - } - } - } - return result; -} - -static void PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(instance_layer_data *instanceData, VkPhysicalDevice physicalDevice, - uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats) { - unique_lock_t lock(global_lock); - auto physicalDeviceState = GetPhysicalDeviceState(instanceData, physicalDevice); - if (*pSurfaceFormatCount) { - if (physicalDeviceState->vkGetPhysicalDeviceSurfaceFormatsKHRState < QUERY_COUNT) { - physicalDeviceState->vkGetPhysicalDeviceSurfaceFormatsKHRState = QUERY_COUNT; - } - if (*pSurfaceFormatCount > physicalDeviceState->surface_formats.size()) - physicalDeviceState->surface_formats.resize(*pSurfaceFormatCount); - } - if (pSurfaceFormats) { - if (physicalDeviceState->vkGetPhysicalDeviceSurfaceFormatsKHRState < QUERY_DETAILS) { - physicalDeviceState->vkGetPhysicalDeviceSurfaceFormatsKHRState = QUERY_DETAILS; - } - for (uint32_t i = 0; i < *pSurfaceFormatCount; i++) { - physicalDeviceState->surface_formats[i] = pSurfaceFormats[i].surfaceFormat; - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormat2KHR *pSurfaceFormats) { - auto instanceData = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - auto result = instanceData->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, - pSurfaceFormatCount, pSurfaceFormats); - if (result == VK_SUCCESS || result == VK_INCOMPLETE) { - PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(instanceData, physicalDevice, pSurfaceFormatCount, pSurfaceFormats); - } - return result; -} - -// VK_EXT_debug_utils commands -VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_SUCCESS; - if (pNameInfo->pObjectName) { - dev_data->report_data->debugUtilsObjectNameMap->insert( - std::make_pair((uint64_t &&) pNameInfo->objectHandle, pNameInfo->pObjectName)); - } else { - dev_data->report_data->debugUtilsObjectNameMap->erase(pNameInfo->objectHandle); - } - if (nullptr != dev_data->dispatch_table.SetDebugUtilsObjectNameEXT) { - result = dev_data->dispatch_table.SetDebugUtilsObjectNameEXT(device, pNameInfo); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = VK_SUCCESS; - if (nullptr != dev_data->dispatch_table.SetDebugUtilsObjectTagEXT) { - result = dev_data->dispatch_table.SetDebugUtilsObjectTagEXT(device, pTagInfo); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - BeginQueueDebugUtilsLabel(dev_data->report_data, queue, pLabelInfo); - if (nullptr != dev_data->dispatch_table.QueueBeginDebugUtilsLabelEXT) { - dev_data->dispatch_table.QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); - } -} - -VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(VkQueue queue) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - if (nullptr != dev_data->dispatch_table.QueueEndDebugUtilsLabelEXT) { - dev_data->dispatch_table.QueueEndDebugUtilsLabelEXT(queue); - } - EndQueueDebugUtilsLabel(dev_data->report_data, queue); -} - -VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - InsertQueueDebugUtilsLabel(dev_data->report_data, queue, pLabelInfo); - if (nullptr != dev_data->dispatch_table.QueueInsertDebugUtilsLabelEXT) { - dev_data->dispatch_table.QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - BeginCmdDebugUtilsLabel(dev_data->report_data, commandBuffer, pLabelInfo); - if (nullptr != dev_data->dispatch_table.CmdBeginDebugUtilsLabelEXT) { - dev_data->dispatch_table.CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - if (nullptr != dev_data->dispatch_table.CmdEndDebugUtilsLabelEXT) { - dev_data->dispatch_table.CmdEndDebugUtilsLabelEXT(commandBuffer); - } - EndCmdDebugUtilsLabel(dev_data->report_data, commandBuffer); -} - -VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - InsertCmdDebugUtilsLabel(dev_data->report_data, commandBuffer, pLabelInfo); - if (nullptr != dev_data->dispatch_table.CmdInsertDebugUtilsLabelEXT) { - dev_data->dispatch_table.CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - VkResult result = instance_data->dispatch_table.CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); - - if (VK_SUCCESS == result) { - result = layer_create_messenger_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pMessenger); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - instance_data->dispatch_table.DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); - layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator); -} - -VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - instance_data->dispatch_table.SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); -} - -// VK_EXT_debug_report commands -VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pMsgCallback) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - VkResult res = instance_data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); - if (VK_SUCCESS == res) { - lock_guard_t lock(global_lock); - res = layer_create_report_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pMsgCallback); - } - return res; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, - const VkAllocationCallbacks *pAllocator) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); - lock_guard_t lock(global_lock); - layer_destroy_report_callback(instance_data->report_data, msgCallback, pAllocator); -} - -VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, - int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - instance_data->dispatch_table.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &global_layer, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &global_layer, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) - return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties); - - return VK_ERROR_LAYER_NOT_PRESENT; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, - uint32_t *pCount, VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) - return util_GetExtensionProperties(1, device_extensions, pCount, pProperties); - - assert(physicalDevice); - - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - return instance_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties); -} - -static bool PreCallValidateEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupPropertiesKHR *pPhysicalDeviceGroupProperties) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - bool skip = false; - - if (instance_data) { - // For this instance, flag when EnumeratePhysicalDeviceGroups goes to QUERY_COUNT and then QUERY_DETAILS. - if (NULL != pPhysicalDeviceGroupProperties) { - if (UNCALLED == instance_data->vkEnumeratePhysicalDeviceGroupsState) { - // Flag warning here. You can call this without having queried the count, but it may not be - // robust on platforms with multiple physical devices. - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, 0, DEVLIMITS_MISSING_QUERY_COUNT, - "Call sequence has vkEnumeratePhysicalDeviceGroups() w/ non-NULL " - "pPhysicalDeviceGroupProperties. You should first call vkEnumeratePhysicalDeviceGroups() w/ " - "NULL pPhysicalDeviceGroupProperties to query pPhysicalDeviceGroupCount."); - } // TODO : Could also flag a warning if re-calling this function in QUERY_DETAILS state - else if (instance_data->physical_device_groups_count != *pPhysicalDeviceGroupCount) { - // Having actual count match count from app is not a requirement, so this can be a warning - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, DEVLIMITS_COUNT_MISMATCH, - "Call to vkEnumeratePhysicalDeviceGroups() w/ pPhysicalDeviceGroupCount value %u, but actual count " - "supported by this instance is %u.", - *pPhysicalDeviceGroupCount, instance_data->physical_device_groups_count); - } - } - } else { - log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, 0, - DEVLIMITS_INVALID_INSTANCE, "Invalid instance (0x%" PRIx64 ") passed into vkEnumeratePhysicalDeviceGroups().", - HandleToUint64(instance)); - } - - return skip; -} - -static void PreCallRecordEnumeratePhysicalDeviceGroups(instance_layer_data *instance_data, - VkPhysicalDeviceGroupPropertiesKHR *pPhysicalDeviceGroupProperties) { - if (instance_data) { - // For this instance, flag when EnumeratePhysicalDeviceGroups goes to QUERY_COUNT and then QUERY_DETAILS. - if (NULL == pPhysicalDeviceGroupProperties) { - instance_data->vkEnumeratePhysicalDeviceGroupsState = QUERY_COUNT; - } else { - instance_data->vkEnumeratePhysicalDeviceGroupsState = QUERY_DETAILS; - } - } -} - -static void PostCallRecordEnumeratePhysicalDeviceGroups(instance_layer_data *instance_data, uint32_t *pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupPropertiesKHR *pPhysicalDeviceGroupProperties) { - if (NULL == pPhysicalDeviceGroupProperties) { - instance_data->physical_device_groups_count = *pPhysicalDeviceGroupCount; - } else { // Save physical devices - for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) { - for (uint32_t j = 0; j < pPhysicalDeviceGroupProperties[i].physicalDeviceCount; j++) { - VkPhysicalDevice cur_phys_dev = pPhysicalDeviceGroupProperties[i].physicalDevices[j]; - auto &phys_device_state = instance_data->physical_device_map[cur_phys_dev]; - phys_device_state.phys_device = cur_phys_dev; - // Init actual features for each physical device - instance_data->dispatch_table.GetPhysicalDeviceFeatures(cur_phys_dev, &phys_device_state.features2.features); - } - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupPropertiesKHR *pPhysicalDeviceGroupProperties) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - - skip = PreCallValidateEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - PreCallRecordEnumeratePhysicalDeviceGroups(instance_data, pPhysicalDeviceGroupProperties); - VkResult result = instance_data->dispatch_table.EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); - if (result == VK_SUCCESS) { - PostCallRecordEnumeratePhysicalDeviceGroups(instance_data, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHR *pPhysicalDeviceGroupProperties) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - - skip = PreCallValidateEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - PreCallRecordEnumeratePhysicalDeviceGroups(instance_data, pPhysicalDeviceGroupProperties); - VkResult result = instance_data->dispatch_table.EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); - if (result == VK_SUCCESS) { - PostCallRecordEnumeratePhysicalDeviceGroups(instance_data, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - } - return result; -} - -static bool PreCallValidateCreateDescriptorUpdateTemplate(const char *func_name, layer_data *device_data, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { - bool skip = false; - const auto layout = GetDescriptorSetLayout(device_data, pCreateInfo->descriptorSetLayout); - if (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET == pCreateInfo->templateType && !layout) { - auto ds_uint = HandleToUint64(pCreateInfo->descriptorSetLayout); - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - ds_uint, VALIDATION_ERROR_052002bc, "%s: Invalid pCreateInfo->descriptorSetLayout (%" PRIx64 ")", func_name, - ds_uint); - } else if (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR == pCreateInfo->templateType) { - auto bind_point = pCreateInfo->pipelineBindPoint; - bool valid_bp = (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) || (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE); - if (!valid_bp) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_052002be, "%s: Invalid pCreateInfo->pipelineBindPoint (%" PRIu32 ").", func_name, - static_cast(bind_point)); - } - const auto pipeline_layout = getPipelineLayout(device_data, pCreateInfo->pipelineLayout); - if (!pipeline_layout) { - uint64_t pl_uint = HandleToUint64(pCreateInfo->pipelineLayout); - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, pl_uint, VALIDATION_ERROR_052002c0, - "%s: Invalid pCreateInfo->pipelineLayout (%" PRIx64 ")", func_name, pl_uint); - } else { - const uint32_t pd_set = pCreateInfo->set; - if ((pd_set >= pipeline_layout->set_layouts.size()) || !pipeline_layout->set_layouts[pd_set] || - !pipeline_layout->set_layouts[pd_set]->IsPushDescriptor()) { - uint64_t pl_uint = HandleToUint64(pCreateInfo->pipelineLayout); - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, pl_uint, VALIDATION_ERROR_052002c2, - "%s: pCreateInfo->set (%" PRIu32 - ") does not refer to the push descriptor set layout for " - "pCreateInfo->pipelineLayout (%" PRIx64 ").", - func_name, pd_set, pl_uint); - } - } - } - return skip; -} - -static void PostCallRecordCreateDescriptorUpdateTemplate(layer_data *device_data, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { - // Shadow template createInfo for later updates - safe_VkDescriptorUpdateTemplateCreateInfo *local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo); - std::unique_ptr template_state(new TEMPLATE_STATE(*pDescriptorUpdateTemplate, local_create_info)); - device_data->desc_template_map[*pDescriptorUpdateTemplate] = std::move(template_state); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(VkDevice device, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCreateDescriptorUpdateTemplate("vkCreateDescriptorUpdateTemplate()", device_data, pCreateInfo, - pAllocator, pDescriptorUpdateTemplate); - - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - if (!skip) { - lock.unlock(); - result = - device_data->dispatch_table.CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordCreateDescriptorUpdateTemplate(device_data, pCreateInfo, pDescriptorUpdateTemplate); - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = PreCallValidateCreateDescriptorUpdateTemplate("vkCreateDescriptorUpdateTemplateKHR()", device_data, pCreateInfo, - pAllocator, pDescriptorUpdateTemplate); - - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - if (!skip) { - lock.unlock(); - result = device_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, - pDescriptorUpdateTemplate); - if (VK_SUCCESS == result) { - lock.lock(); - PostCallRecordCreateDescriptorUpdateTemplate(device_data, pCreateInfo, pDescriptorUpdateTemplate); - } - } - return result; -} - -static void PreCallRecordDestroyDescriptorUpdateTemplate(layer_data *device_data, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate) { - device_data->desc_template_map.erase(descriptorUpdateTemplate); -} - -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const VkAllocationCallbacks *pAllocator) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyDescriptorUpdateTemplate(device_data, descriptorUpdateTemplate); - lock.unlock(); - device_data->dispatch_table.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); -} - -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const VkAllocationCallbacks *pAllocator) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - unique_lock_t lock(global_lock); - // Pre-record to avoid Destroy/Create race - PreCallRecordDestroyDescriptorUpdateTemplate(device_data, descriptorUpdateTemplate); - lock.unlock(); - device_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); -} - -// PostCallRecord* handles recording state updates following call down chain to UpdateDescriptorSetsWithTemplate() -static void PostCallRecordUpdateDescriptorSetWithTemplate(layer_data *device_data, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void *pData) { - auto const template_map_entry = device_data->desc_template_map.find(descriptorUpdateTemplate); - if (template_map_entry == device_data->desc_template_map.end()) { - assert(0); - } - - cvdescriptorset::PerformUpdateDescriptorSetsWithTemplateKHR(device_data, descriptorSet, template_map_entry->second, pData); -} - -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void *pData) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - device_data->dispatch_table.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); - - PostCallRecordUpdateDescriptorSetWithTemplate(device_data, descriptorSet, descriptorUpdateTemplate, pData); -} - -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void *pData) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - device_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); - - PostCallRecordUpdateDescriptorSetWithTemplate(device_data, descriptorSet, descriptorUpdateTemplate, pData); -} - -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - VkPipelineLayout layout, uint32_t set, const void *pData) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = false; - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - // Minimal validation for command buffer state - if (cb_state) { - skip |= ValidateCmd(dev_data, cb_state, CMD_PUSHDESCRIPTORSETWITHTEMPLATEKHR, "vkCmdPushDescriptorSetWithTemplateKHR()"); - } - lock.unlock(); - - if (!skip) { - dev_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); - } -} - -static void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(instance_layer_data *instanceData, - VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, - VkDisplayPlanePropertiesKHR *pProperties) { - unique_lock_t lock(global_lock); - auto physical_device_state = GetPhysicalDeviceState(instanceData, physicalDevice); - - if (*pPropertyCount) { - if (physical_device_state->vkGetPhysicalDeviceDisplayPlanePropertiesKHRState < QUERY_COUNT) { - physical_device_state->vkGetPhysicalDeviceDisplayPlanePropertiesKHRState = QUERY_COUNT; - } - physical_device_state->display_plane_property_count = *pPropertyCount; - } - if (pProperties) { - if (physical_device_state->vkGetPhysicalDeviceDisplayPlanePropertiesKHRState < QUERY_DETAILS) { - physical_device_state->vkGetPhysicalDeviceDisplayPlanePropertiesKHRState = QUERY_DETAILS; - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, - VkDisplayPlanePropertiesKHR *pProperties) { - VkResult result = VK_SUCCESS; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - result = instance_data->dispatch_table.GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); - - if (result == VK_SUCCESS || result == VK_INCOMPLETE) { - PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(instance_data, physicalDevice, pPropertyCount, pProperties); - } - - return result; -} - -static bool ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(instance_layer_data *instance_data, - VkPhysicalDevice physicalDevice, uint32_t planeIndex, - const char *api_name) { - bool skip = false; - auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); - if (physical_device_state->vkGetPhysicalDeviceDisplayPlanePropertiesKHRState == UNCALLED) { - skip |= log_msg( - instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - HandleToUint64(physicalDevice), SWAPCHAIN_GET_SUPPORTED_DISPLAYS_WITHOUT_QUERY, - "Potential problem with calling %s() without first querying vkGetPhysicalDeviceDisplayPlanePropertiesKHR.", api_name); - } else { - if (planeIndex >= physical_device_state->display_plane_property_count) { - skip |= log_msg( - instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - HandleToUint64(physicalDevice), VALIDATION_ERROR_29c009c2, - "%s(): planeIndex must be in the range [0, %d] that was returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR. " - "Do you have the plane index hardcoded?", - api_name, physical_device_state->display_plane_property_count - 1); - } - } - return skip; -} - -static bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(instance_layer_data *instance_data, VkPhysicalDevice physicalDevice, - uint32_t planeIndex) { - bool skip = false; - lock_guard_t lock(global_lock); - skip |= ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(instance_data, physicalDevice, planeIndex, - "vkGetDisplayPlaneSupportedDisplaysKHR"); - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, - uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - bool skip = PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(instance_data, physicalDevice, planeIndex); - if (!skip) { - result = - instance_data->dispatch_table.GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); - } - return result; -} - -static bool PreCallValidateGetDisplayPlaneCapabilitiesKHR(instance_layer_data *instance_data, VkPhysicalDevice physicalDevice, - uint32_t planeIndex) { - bool skip = false; - lock_guard_t lock(global_lock); - skip |= ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(instance_data, physicalDevice, planeIndex, - "vkGetDisplayPlaneCapabilitiesKHR"); - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, - uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - bool skip = PreCallValidateGetDisplayPlaneCapabilitiesKHR(instance_data, physicalDevice, planeIndex); - - if (!skip) { - result = instance_data->dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) { - unique_lock_t lock(global_lock); - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - if (pNameInfo->pObjectName) { - device_data->report_data->debugObjectNameMap->insert( - std::make_pair((uint64_t &&) pNameInfo->object, pNameInfo->pObjectName)); - } else { - device_data->report_data->debugObjectNameMap->erase(pNameInfo->object); - } - lock.unlock(); - VkResult result = device_data->dispatch_table.DebugMarkerSetObjectNameEXT(device, pNameInfo); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = device_data->dispatch_table.DebugMarkerSetObjectTagEXT(device, pTagInfo); - return result; -} - -VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = false; - GLOBAL_CB_NODE *cb_state = GetCBNode(device_data, commandBuffer); - // Minimal validation for command buffer state - if (cb_state) { - skip |= ValidateCmd(device_data, cb_state, CMD_DEBUGMARKERBEGINEXT, "vkCmdDebugMarkerBeginEXT()"); - } - lock.unlock(); - if (!skip) { - device_data->dispatch_table.CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = false; - GLOBAL_CB_NODE *cb_state = GetCBNode(device_data, commandBuffer); - // Minimal validation for command buffer state - if (cb_state) { - skip |= ValidateCmd(device_data, cb_state, CMD_DEBUGMARKERENDEXT, "vkCmdDebugMarkerEndEXT()"); - } - lock.unlock(); - if (!skip) { - device_data->dispatch_table.CmdDebugMarkerEndEXT(commandBuffer); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - device_data->dispatch_table.CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); -} - -VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = false; - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - // Minimal validation for command buffer state - if (cb_state) { - skip |= ValidateCmd(dev_data, cb_state, CMD_SETDISCARDRECTANGLEEXT, "vkCmdSetDiscardRectangleEXT()"); - } - lock.unlock(); - - if (!skip) { - dev_data->dispatch_table.CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, - pDiscardRectangles); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT *pSampleLocationsInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - unique_lock_t lock(global_lock); - bool skip = false; - GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); - // Minimal validation for command buffer state - if (cb_state) { - skip |= ValidateCmd(dev_data, cb_state, CMD_SETSAMPLELOCATIONSEXT, "vkCmdSetSampleLocationsEXT()"); - } - lock.unlock(); - - if (!skip) { - dev_data->dispatch_table.CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); - } -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName); -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName); -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName); - -// Map of all APIs to be intercepted by this layer -static const std::unordered_map name_to_funcptr_map = { - {"vkGetInstanceProcAddr", (void *)GetInstanceProcAddr}, - {"vk_layerGetPhysicalDeviceProcAddr", (void *)GetPhysicalDeviceProcAddr}, - {"vkGetDeviceProcAddr", (void *)GetDeviceProcAddr}, - {"vkCreateInstance", (void *)CreateInstance}, - {"vkCreateDevice", (void *)CreateDevice}, - {"vkEnumeratePhysicalDevices", (void *)EnumeratePhysicalDevices}, - {"vkGetPhysicalDeviceQueueFamilyProperties", (void *)GetPhysicalDeviceQueueFamilyProperties}, - {"vkDestroyInstance", (void *)DestroyInstance}, - {"vkEnumerateInstanceLayerProperties", (void *)EnumerateInstanceLayerProperties}, - {"vkEnumerateDeviceLayerProperties", (void *)EnumerateDeviceLayerProperties}, - {"vkEnumerateInstanceExtensionProperties", (void *)EnumerateInstanceExtensionProperties}, - {"vkEnumerateDeviceExtensionProperties", (void *)EnumerateDeviceExtensionProperties}, - {"vkCreateDescriptorUpdateTemplate", (void *)CreateDescriptorUpdateTemplate}, - {"vkCreateDescriptorUpdateTemplateKHR", (void *)CreateDescriptorUpdateTemplateKHR}, - {"vkDestroyDescriptorUpdateTemplate", (void *)DestroyDescriptorUpdateTemplate}, - {"vkDestroyDescriptorUpdateTemplateKHR", (void *)DestroyDescriptorUpdateTemplateKHR}, - {"vkUpdateDescriptorSetWithTemplate", (void *)UpdateDescriptorSetWithTemplate}, - {"vkUpdateDescriptorSetWithTemplateKHR", (void *)UpdateDescriptorSetWithTemplateKHR}, - {"vkCmdPushDescriptorSetWithTemplateKHR", (void *)CmdPushDescriptorSetWithTemplateKHR}, - {"vkCmdPushDescriptorSetKHR", (void *)CmdPushDescriptorSetKHR}, - {"vkCreateSwapchainKHR", (void *)CreateSwapchainKHR}, - {"vkDestroySwapchainKHR", (void *)DestroySwapchainKHR}, - {"vkGetSwapchainImagesKHR", (void *)GetSwapchainImagesKHR}, - {"vkAcquireNextImageKHR", (void *)AcquireNextImageKHR}, - {"vkQueuePresentKHR", (void *)QueuePresentKHR}, - {"vkQueueSubmit", (void *)QueueSubmit}, - {"vkWaitForFences", (void *)WaitForFences}, - {"vkGetFenceStatus", (void *)GetFenceStatus}, - {"vkQueueWaitIdle", (void *)QueueWaitIdle}, - {"vkDeviceWaitIdle", (void *)DeviceWaitIdle}, - {"vkGetDeviceQueue", (void *)GetDeviceQueue}, - {"vkGetDeviceQueue2", (void *)GetDeviceQueue2}, - {"vkDestroyDevice", (void *)DestroyDevice}, - {"vkDestroyFence", (void *)DestroyFence}, - {"vkResetFences", (void *)ResetFences}, - {"vkDestroySemaphore", (void *)DestroySemaphore}, - {"vkDestroyEvent", (void *)DestroyEvent}, - {"vkDestroyQueryPool", (void *)DestroyQueryPool}, - {"vkDestroyBuffer", (void *)DestroyBuffer}, - {"vkDestroyBufferView", (void *)DestroyBufferView}, - {"vkDestroyImage", (void *)DestroyImage}, - {"vkDestroyImageView", (void *)DestroyImageView}, - {"vkDestroyShaderModule", (void *)DestroyShaderModule}, - {"vkDestroyPipeline", (void *)DestroyPipeline}, - {"vkDestroyPipelineLayout", (void *)DestroyPipelineLayout}, - {"vkDestroySampler", (void *)DestroySampler}, - {"vkDestroyDescriptorSetLayout", (void *)DestroyDescriptorSetLayout}, - {"vkDestroyDescriptorPool", (void *)DestroyDescriptorPool}, - {"vkDestroyFramebuffer", (void *)DestroyFramebuffer}, - {"vkDestroyRenderPass", (void *)DestroyRenderPass}, - {"vkCreateBuffer", (void *)CreateBuffer}, - {"vkCreateBufferView", (void *)CreateBufferView}, - {"vkCreateImage", (void *)CreateImage}, - {"vkCreateImageView", (void *)CreateImageView}, - {"vkCreateFence", (void *)CreateFence}, - {"vkCreatePipelineCache", (void *)CreatePipelineCache}, - {"vkDestroyPipelineCache", (void *)DestroyPipelineCache}, - {"vkGetPipelineCacheData", (void *)GetPipelineCacheData}, - {"vkMergePipelineCaches", (void *)MergePipelineCaches}, - {"vkCreateGraphicsPipelines", (void *)CreateGraphicsPipelines}, - {"vkCreateComputePipelines", (void *)CreateComputePipelines}, - {"vkCreateSampler", (void *)CreateSampler}, - {"vkCreateDescriptorSetLayout", (void *)CreateDescriptorSetLayout}, - {"vkCreatePipelineLayout", (void *)CreatePipelineLayout}, - {"vkCreateDescriptorPool", (void *)CreateDescriptorPool}, - {"vkResetDescriptorPool", (void *)ResetDescriptorPool}, - {"vkAllocateDescriptorSets", (void *)AllocateDescriptorSets}, - {"vkFreeDescriptorSets", (void *)FreeDescriptorSets}, - {"vkUpdateDescriptorSets", (void *)UpdateDescriptorSets}, - {"vkCreateCommandPool", (void *)CreateCommandPool}, - {"vkDestroyCommandPool", (void *)DestroyCommandPool}, - {"vkResetCommandPool", (void *)ResetCommandPool}, - {"vkCreateQueryPool", (void *)CreateQueryPool}, - {"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}, - {"vkCmdBindVertexBuffers", (void *)CmdBindVertexBuffers}, - {"vkCmdBindIndexBuffer", (void *)CmdBindIndexBuffer}, - {"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}, - {"vkGetImageSubresourceLayout", (void *)GetImageSubresourceLayout}, - {"vkCmdSetEvent", (void *)CmdSetEvent}, - {"vkCmdResetEvent", (void *)CmdResetEvent}, - {"vkCmdWaitEvents", (void *)CmdWaitEvents}, - {"vkCmdPipelineBarrier", (void *)CmdPipelineBarrier}, - {"vkCmdBeginQuery", (void *)CmdBeginQuery}, - {"vkCmdEndQuery", (void *)CmdEndQuery}, - {"vkCmdResetQueryPool", (void *)CmdResetQueryPool}, - {"vkCmdCopyQueryPoolResults", (void *)CmdCopyQueryPoolResults}, - {"vkCmdPushConstants", (void *)CmdPushConstants}, - {"vkCmdWriteTimestamp", (void *)CmdWriteTimestamp}, - {"vkCreateFramebuffer", (void *)CreateFramebuffer}, - {"vkCreateShaderModule", (void *)CreateShaderModule}, - {"vkCreateRenderPass", (void *)CreateRenderPass}, - {"vkCmdBeginRenderPass", (void *)CmdBeginRenderPass}, - {"vkCmdNextSubpass", (void *)CmdNextSubpass}, - {"vkCmdEndRenderPass", (void *)CmdEndRenderPass}, - {"vkCmdExecuteCommands", (void *)CmdExecuteCommands}, - {"vkCmdDebugMarkerBeginEXT", (void *)CmdDebugMarkerBeginEXT}, - {"vkCmdDebugMarkerEndEXT", (void *)CmdDebugMarkerEndEXT}, - {"vkCmdDebugMarkerInsertEXT", (void *)CmdDebugMarkerInsertEXT}, - {"vkDebugMarkerSetObjectNameEXT", (void *)DebugMarkerSetObjectNameEXT}, - {"vkDebugMarkerSetObjectTagEXT", (void *)DebugMarkerSetObjectTagEXT}, - {"vkSetEvent", (void *)SetEvent}, - {"vkMapMemory", (void *)MapMemory}, - {"vkUnmapMemory", (void *)UnmapMemory}, - {"vkFlushMappedMemoryRanges", (void *)FlushMappedMemoryRanges}, - {"vkInvalidateMappedMemoryRanges", (void *)InvalidateMappedMemoryRanges}, - {"vkAllocateMemory", (void *)AllocateMemory}, - {"vkFreeMemory", (void *)FreeMemory}, - {"vkBindBufferMemory", (void *)BindBufferMemory}, - {"vkBindBufferMemory2", (void *)BindBufferMemory2}, - {"vkBindBufferMemory2KHR", (void *)BindBufferMemory2KHR}, - {"vkGetBufferMemoryRequirements", (void *)GetBufferMemoryRequirements}, - {"vkGetBufferMemoryRequirements2", (void *)GetBufferMemoryRequirements2}, - {"vkGetBufferMemoryRequirements2KHR", (void *)GetBufferMemoryRequirements2KHR}, - {"vkGetImageMemoryRequirements", (void *)GetImageMemoryRequirements}, - {"vkGetImageMemoryRequirements2", (void *)GetImageMemoryRequirements2}, - {"vkGetImageMemoryRequirements2KHR", (void *)GetImageMemoryRequirements2KHR}, - {"vkGetImageSparseMemoryRequirements", (void *)GetImageSparseMemoryRequirements}, - {"vkGetImageSparseMemoryRequirements2", (void *)GetImageSparseMemoryRequirements2}, - {"vkGetImageSparseMemoryRequirements2KHR", (void *)GetImageSparseMemoryRequirements2KHR}, - {"vkGetPhysicalDeviceSparseImageFormatProperties", (void *)GetPhysicalDeviceSparseImageFormatProperties}, - {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void *)GetPhysicalDeviceSparseImageFormatProperties2}, - {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void *)GetPhysicalDeviceSparseImageFormatProperties2KHR}, - {"vkGetQueryPoolResults", (void *)GetQueryPoolResults}, - {"vkBindImageMemory", (void *)BindImageMemory}, - {"vkBindImageMemory2", (void *)BindImageMemory2}, - {"vkBindImageMemory2KHR", (void *)BindImageMemory2KHR}, - {"vkQueueBindSparse", (void *)QueueBindSparse}, - {"vkCreateSemaphore", (void *)CreateSemaphore}, - {"vkCreateEvent", (void *)CreateEvent}, -#ifdef VK_USE_PLATFORM_ANDROID_KHR - {"vkCreateAndroidSurfaceKHR", (void *)CreateAndroidSurfaceKHR}, -#endif -#ifdef VK_USE_PLATFORM_MIR_KHR - {"vkCreateMirSurfaceKHR", (void *)CreateMirSurfaceKHR}, - {"vkGetPhysicalDeviceMirPresentationSupportKHR", (void *)GetPhysicalDeviceMirPresentationSupportKHR}, -#endif -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - {"vkCreateWaylandSurfaceKHR", (void *)CreateWaylandSurfaceKHR}, - {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void *)GetPhysicalDeviceWaylandPresentationSupportKHR}, -#endif -#ifdef VK_USE_PLATFORM_WIN32_KHR - {"vkCreateWin32SurfaceKHR", (void *)CreateWin32SurfaceKHR}, - {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void *)GetPhysicalDeviceWin32PresentationSupportKHR}, - {"vkImportSemaphoreWin32HandleKHR", (void *)ImportSemaphoreWin32HandleKHR}, - {"vkGetSemaphoreWin32HandleKHR", (void *)GetSemaphoreWin32HandleKHR}, - {"vkImportFenceWin32HandleKHR", (void *)ImportFenceWin32HandleKHR}, - {"vkGetFenceWin32HandleKHR", (void *)GetFenceWin32HandleKHR}, -#endif -#ifdef VK_USE_PLATFORM_XCB_KHR - {"vkCreateXcbSurfaceKHR", (void *)CreateXcbSurfaceKHR}, - {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void *)GetPhysicalDeviceXcbPresentationSupportKHR}, -#endif -#ifdef VK_USE_PLATFORM_XLIB_KHR - {"vkCreateXlibSurfaceKHR", (void *)CreateXlibSurfaceKHR}, - {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void *)GetPhysicalDeviceXlibPresentationSupportKHR}, -#endif -#ifdef VK_USE_PLATFORM_IOS_MVK - {"vkCreateIOSSurfaceMVK", (void *)CreateIOSSurfaceMVK}, -#endif -#ifdef VK_USE_PLATFORM_MACOS_MVK - {"vkCreateMacOSSurfaceMVK", (void *)CreateMacOSSurfaceMVK}, -#endif - {"vkCreateDisplayPlaneSurfaceKHR", (void *)CreateDisplayPlaneSurfaceKHR}, - {"vkDestroySurfaceKHR", (void *)DestroySurfaceKHR}, - {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void *)GetPhysicalDeviceSurfaceCapabilitiesKHR}, - {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void *)GetPhysicalDeviceSurfaceCapabilities2KHR}, - {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void *)GetPhysicalDeviceSurfaceCapabilities2EXT}, - {"vkGetPhysicalDeviceSurfaceSupportKHR", (void *)GetPhysicalDeviceSurfaceSupportKHR}, - {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void *)GetPhysicalDeviceSurfacePresentModesKHR}, - {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void *)GetPhysicalDeviceSurfaceFormatsKHR}, - {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void *)GetPhysicalDeviceSurfaceFormats2KHR}, - {"vkGetPhysicalDeviceQueueFamilyProperties2", (void *)GetPhysicalDeviceQueueFamilyProperties2}, - {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void *)GetPhysicalDeviceQueueFamilyProperties2KHR}, - {"vkEnumeratePhysicalDeviceGroups", (void *)EnumeratePhysicalDeviceGroups}, - {"vkEnumeratePhysicalDeviceGroupsKHR", (void *)EnumeratePhysicalDeviceGroupsKHR}, - {"vkCreateDebugReportCallbackEXT", (void *)CreateDebugReportCallbackEXT}, - {"vkDestroyDebugReportCallbackEXT", (void *)DestroyDebugReportCallbackEXT}, - {"vkDebugReportMessageEXT", (void *)DebugReportMessageEXT}, - {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void *)GetPhysicalDeviceDisplayPlanePropertiesKHR}, - {"vkGetDisplayPlaneSupportedDisplaysKHR", (void *)GetDisplayPlaneSupportedDisplaysKHR}, - {"vkGetDisplayPlaneCapabilitiesKHR", (void *)GetDisplayPlaneCapabilitiesKHR}, - {"vkImportSemaphoreFdKHR", (void *)ImportSemaphoreFdKHR}, - {"vkGetSemaphoreFdKHR", (void *)GetSemaphoreFdKHR}, - {"vkImportFenceFdKHR", (void *)ImportFenceFdKHR}, - {"vkGetFenceFdKHR", (void *)GetFenceFdKHR}, - {"vkCreateValidationCacheEXT", (void *)CreateValidationCacheEXT}, - {"vkDestroyValidationCacheEXT", (void *)DestroyValidationCacheEXT}, - {"vkGetValidationCacheDataEXT", (void *)GetValidationCacheDataEXT}, - {"vkMergeValidationCachesEXT", (void *)MergeValidationCachesEXT}, - {"vkCmdSetDiscardRectangleEXT", (void *)CmdSetDiscardRectangleEXT}, - {"vkCmdSetSampleLocationsEXT", (void *)CmdSetSampleLocationsEXT}, - {"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}, -}; - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) { - assert(device); - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - // Is API to be intercepted by this layer? - const auto &item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - auto &table = device_data->dispatch_table; - if (!table.GetDeviceProcAddr) return nullptr; - return table.GetDeviceProcAddr(device, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { - instance_layer_data *instance_data; - // Is API to be intercepted by this layer? - const auto &item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - auto &table = instance_data->dispatch_table; - if (!table.GetInstanceProcAddr) return nullptr; - return table.GetInstanceProcAddr(instance, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { - assert(instance); - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - - auto &table = instance_data->dispatch_table; - if (!table.GetPhysicalDeviceProcAddr) return nullptr; - return table.GetPhysicalDeviceProcAddr(instance, funcName); -} - -} // namespace core_validation - -// loader-layer interface v0, just wrappers since there is only a layer - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - return core_validation::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, - VkLayerProperties *pProperties) { - return core_validation::EnumerateInstanceLayerProperties(pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - // the layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return core_validation::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - // the layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return core_validation::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { - return core_validation::GetDeviceProcAddr(dev, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { - return core_validation::GetInstanceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, - const char *funcName) { - return core_validation::GetPhysicalDeviceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { - assert(pVersionStruct != NULL); - assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); - - // Fill in the function pointers if our version is at least capable of having the structure contain them. - if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { - pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; - pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; - pVersionStruct->pfnGetPhysicalDeviceProcAddr = vk_layerGetPhysicalDeviceProcAddr; - } - - if (pVersionStruct->loaderLayerInterfaceVersion < CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - core_validation::loader_layer_if_version = pVersionStruct->loaderLayerInterfaceVersion; - } else if (pVersionStruct->loaderLayerInterfaceVersion > CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - pVersionStruct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - } - - return VK_SUCCESS; -} diff --git a/layers/core_validation.h b/layers/core_validation.h deleted file mode 100644 index fbd055c1..00000000 --- a/layers/core_validation.h +++ /dev/null @@ -1,167 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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: Courtney Goeltzenleuchter - * Author: Tobin Ehlis - * Author: Chris Forbes - * Author: Mark Lobodzinski - */ - -#pragma once -#include "core_validation_error_enums.h" -#include "vk_validation_error_messages.h" -#include "core_validation_types.h" -#include "descriptor_sets.h" -#include "vk_layer_logging.h" -#include "vulkan/vk_layer.h" -#include -#include -#include -#include -#include -#include -#include -#include - -/* - * MTMTODO : Update this comment - * Data Structure overview - * There are 4 global STL(' maps - * cbMap -- map of command Buffer (CB) objects to MT_CB_INFO structures - * Each MT_CB_INFO struct has an stl list container with - * memory objects that are referenced by this CB - * memObjMap -- map of Memory Objects to MT_MEM_OBJ_INFO structures - * Each MT_MEM_OBJ_INFO has two stl list containers with: - * -- all CBs referencing this mem obj - * -- all VK Objects that are bound to this memory - * objectMap -- map of objects to MT_OBJ_INFO structures - * - * Algorithm overview - * These are the primary events that should happen related to different objects - * 1. Command buffers - * CREATION - Add object,structure to map - * CMD BIND - If mem associated, add mem reference to list container - * DESTROY - Remove from map, decrement (and report) mem references - * 2. Mem Objects - * CREATION - Add object,structure to map - * OBJ BIND - Add obj structure to list container for that mem node - * CMB BIND - If mem-related add CB structure to list container for that mem node - * DESTROY - Flag as errors any remaining refs and remove from map - * 3. Generic Objects - * MEM BIND - DESTROY any previous binding, Add obj node w/ ref to map, add obj ref to list container for that mem node - * DESTROY - If mem bound, remove reference list container for that memInfo, remove object ref from map - */ -// TODO : Is there a way to track when Cmd Buffer finishes & remove mem references at that point? -// TODO : Could potentially store a list of freed mem allocs to flag when they're incorrectly used - -enum SyncScope { - kSyncScopeInternal, - kSyncScopeExternalTemporary, - kSyncScopeExternalPermanent, -}; - -enum FENCE_STATE { FENCE_UNSIGNALED, FENCE_INFLIGHT, FENCE_RETIRED }; - -class FENCE_NODE { - public: - VkFence fence; - VkFenceCreateInfo createInfo; - std::pair signaler; - FENCE_STATE state; - SyncScope scope; - - // Default constructor - FENCE_NODE() : state(FENCE_UNSIGNALED), scope(kSyncScopeInternal) {} -}; - -class SEMAPHORE_NODE : public BASE_NODE { - public: - std::pair signaler; - bool signaled; - SyncScope scope; -}; - -class EVENT_STATE : public BASE_NODE { - public: - int write_in_use; - bool needsSignaled; - VkPipelineStageFlags stageMask; -}; - -class QUEUE_STATE { - public: - VkQueue queue; - uint32_t queueFamilyIndex; - std::unordered_map eventToStageMap; - std::unordered_map queryToStateMap; // 0 is unavailable, 1 is available - - uint64_t seq; - std::deque submissions; -}; - -class QUERY_POOL_NODE : public BASE_NODE { - public: - VkQueryPoolCreateInfo createInfo; -}; - -struct PHYSICAL_DEVICE_STATE { - // Track the call state and array sizes for various query functions - CALL_STATE vkGetPhysicalDeviceQueueFamilyPropertiesState = UNCALLED; - CALL_STATE vkGetPhysicalDeviceLayerPropertiesState = UNCALLED; - CALL_STATE vkGetPhysicalDeviceExtensionPropertiesState = UNCALLED; - CALL_STATE vkGetPhysicalDeviceFeaturesState = UNCALLED; - CALL_STATE vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = UNCALLED; - CALL_STATE vkGetPhysicalDeviceSurfacePresentModesKHRState = UNCALLED; - CALL_STATE vkGetPhysicalDeviceSurfaceFormatsKHRState = UNCALLED; - CALL_STATE vkGetPhysicalDeviceDisplayPlanePropertiesKHRState = UNCALLED; - safe_VkPhysicalDeviceFeatures2 features2 = {}; - VkPhysicalDevice phys_device = VK_NULL_HANDLE; - uint32_t queue_family_count = 0; - std::vector queue_family_properties; - VkSurfaceCapabilitiesKHR surfaceCapabilities = {}; - std::vector present_modes; - std::vector surface_formats; - uint32_t display_plane_property_count = 0; -}; - -struct GpuQueue { - VkPhysicalDevice gpu; - uint32_t queue_family_index; -}; - -inline bool operator==(GpuQueue const &lhs, GpuQueue const &rhs) { - return (lhs.gpu == rhs.gpu && lhs.queue_family_index == rhs.queue_family_index); -} - -namespace std { -template <> -struct hash { - size_t operator()(GpuQueue gq) const throw() { - return hash()((uint64_t)(gq.gpu)) ^ hash()(gq.queue_family_index); - } -}; -} // namespace std - -struct SURFACE_STATE { - VkSurfaceKHR surface = VK_NULL_HANDLE; - SWAPCHAIN_NODE *swapchain = nullptr; - SWAPCHAIN_NODE *old_swapchain = nullptr; - std::unordered_map gpu_queue_support; - - SURFACE_STATE() {} - SURFACE_STATE(VkSurfaceKHR surface) : surface(surface) {} -}; diff --git a/layers/core_validation_error_enums.h b/layers/core_validation_error_enums.h deleted file mode 100644 index 45d03f65..00000000 --- a/layers/core_validation_error_enums.h +++ /dev/null @@ -1,236 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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: Courtney Goeltzenleuchter - * Author: Tobin Ehlis - * Author: Chris Forbes - * Author: Mark Lobodzinski - */ -#ifndef CORE_VALIDATION_ERROR_ENUMS_H_ -#define CORE_VALIDATION_ERROR_ENUMS_H_ - -// Mem Tracker ERROR codes -enum MEM_TRACK_ERROR { - MEMTRACK_NONE, - MEMTRACK_INVALID_CB, - MEMTRACK_INVALID_MEM_OBJ, - MEMTRACK_INVALID_ALIASING, - MEMTRACK_INTERNAL_ERROR, - MEMTRACK_FREED_MEM_REF, - MEMTRACK_INVALID_OBJECT, - MEMTRACK_MEMORY_LEAK, - MEMTRACK_INVALID_STATE, - MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, - MEMTRACK_INVALID_FENCE_STATE, - MEMTRACK_REBIND_OBJECT, - MEMTRACK_INVALID_USAGE_FLAG, - MEMTRACK_INVALID_MAP, - MEMTRACK_INVALID_MEM_TYPE, - MEMTRACK_INVALID_MEM_REGION, - MEMTRACK_OBJECT_NOT_BOUND, -}; - -// Draw State ERROR codes -enum DRAW_STATE_ERROR { - DRAWSTATE_NONE, - DRAWSTATE_INTERNAL_ERROR, - DRAWSTATE_NO_PIPELINE_BOUND, - DRAWSTATE_INVALID_SET, - DRAWSTATE_INVALID_RENDER_AREA, - DRAWSTATE_INVALID_LAYOUT, - DRAWSTATE_INVALID_IMAGE_LAYOUT, - DRAWSTATE_INVALID_PIPELINE, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, - DRAWSTATE_INVALID_COMMAND_BUFFER, - DRAWSTATE_INVALID_BARRIER, - DRAWSTATE_INVALID_BUFFER, - DRAWSTATE_INVALID_IMAGE, - DRAWSTATE_INVALID_BUFFER_VIEW, - DRAWSTATE_INVALID_IMAGE_VIEW, - DRAWSTATE_INVALID_QUERY, - DRAWSTATE_INVALID_QUERY_POOL, - DRAWSTATE_INVALID_DESCRIPTOR_POOL, - DRAWSTATE_INVALID_COMMAND_POOL, - DRAWSTATE_INVALID_FENCE, - DRAWSTATE_INVALID_EVENT, - DRAWSTATE_INVALID_SAMPLER, - DRAWSTATE_INVALID_FRAMEBUFFER, - DRAWSTATE_INVALID_DEVICE_MEMORY, - DRAWSTATE_INVALID_EXTENTS, - DRAWSTATE_INVALID_FEATURE, - DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, - DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR, - DRAWSTATE_OUT_OF_MEMORY, - DRAWSTATE_INVALID_DESCRIPTOR_SET, - DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, - DRAWSTATE_DESCRIPTOR_STAGEFLAGS_MISMATCH, - DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, - DRAWSTATE_DESCRIPTOR_POOL_EMPTY, - DRAWSTATE_CANT_FREE_FROM_NON_FREE_POOL, - DRAWSTATE_INVALID_WRITE_UPDATE, - DRAWSTATE_INVALID_COPY_UPDATE, - DRAWSTATE_INVALID_UPDATE_STRUCT, - DRAWSTATE_NUM_SAMPLES_MISMATCH, - DRAWSTATE_NO_END_COMMAND_BUFFER, - DRAWSTATE_NO_BEGIN_COMMAND_BUFFER, - DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, - DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, - DRAWSTATE_VIEWPORT_NOT_BOUND, - DRAWSTATE_SCISSOR_NOT_BOUND, - DRAWSTATE_LINE_WIDTH_NOT_BOUND, - DRAWSTATE_DEPTH_BIAS_NOT_BOUND, - DRAWSTATE_BLEND_NOT_BOUND, - DRAWSTATE_DEPTH_BOUNDS_NOT_BOUND, - DRAWSTATE_STENCIL_NOT_BOUND, - DRAWSTATE_INDEX_BUFFER_NOT_BOUND, - DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, - DRAWSTATE_RENDERPASS_INCOMPATIBLE, - DRAWSTATE_RENDERPASS_TOO_MANY_CLEAR_VALUES, - DRAWSTATE_FRAMEBUFFER_INCOMPATIBLE, - DRAWSTATE_INVALID_FRAMEBUFFER_CREATE_INFO, - DRAWSTATE_INVALID_RENDERPASS, - DRAWSTATE_INVALID_RENDERPASS_CMD, - DRAWSTATE_NO_ACTIVE_RENDERPASS, - DRAWSTATE_INVALID_IMAGE_USAGE, - DRAWSTATE_INVALID_ATTACHMENT_INDEX, - DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, - DRAWSTATE_DESCRIPTOR_SET_NOT_BOUND, - DRAWSTATE_INVALID_DYNAMIC_OFFSET_COUNT, - DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, - DRAWSTATE_BEGIN_CB_INVALID_STATE, - DRAWSTATE_INVALID_CB_SIMULTANEOUS_USE, - DRAWSTATE_INVALID_COMMAND_BUFFER_RESET, - DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, - DRAWSTATE_INVALID_IMAGE_ASPECT, - DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, - DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, - DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, - DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, - DRAWSTATE_BUFFERVIEW_DESCRIPTOR_ERROR, - DRAWSTATE_BUFFERINFO_DESCRIPTOR_ERROR, - DRAWSTATE_DYNAMIC_OFFSET_OVERFLOW, - DRAWSTATE_DOUBLE_DESTROY, - DRAWSTATE_OBJECT_INUSE, - DRAWSTATE_QUEUE_FORWARD_PROGRESS, - DRAWSTATE_INVALID_BUFFER_MEMORY_OFFSET, - DRAWSTATE_INVALID_TEXEL_BUFFER_OFFSET, - DRAWSTATE_INVALID_UNIFORM_BUFFER_OFFSET, - DRAWSTATE_INVALID_STORAGE_BUFFER_OFFSET, - DRAWSTATE_INDEPENDENT_BLEND, - DRAWSTATE_DISABLED_LOGIC_OP, - DRAWSTATE_INVALID_QUEUE_INDEX, - DRAWSTATE_INVALID_QUEUE_FAMILY, - DRAWSTATE_IMAGE_TRANSFER_GRANULARITY, - DRAWSTATE_PUSH_CONSTANTS_ERROR, - DRAWSTATE_INVALID_SUBPASS_INDEX, - DRAWSTATE_MISMATCHED_IMAGE_FORMAT, - DRAWSTATE_MISMATCHED_IMAGE_ASPECT, - DRAWSTATE_INVALID_IMAGE_FILTER, - DRAWSTATE_MISMATCHED_IMAGE_TYPE, - DRAWSTATE_SWAPCHAIN_NO_SYNC_FOR_ACQUIRE, - DRAWSTATE_SWAPCHAIN_INVALID_IMAGE, - DRAWSTATE_SWAPCHAIN_IMAGE_NOT_ACQUIRED, - DRAWSTATE_SWAPCHAIN_ALREADY_EXISTS, - DRAWSTATE_SWAPCHAIN_WRONG_SURFACE, - DRAWSTATE_SWAPCHAIN_CREATE_BEFORE_QUERY, - DRAWSTATE_SWAPCHAIN_UNSUPPORTED_QUEUE, - DRAWSTATE_SWAPCHAIN_BAD_IMAGE_COUNT, - DRAWSTATE_SWAPCHAIN_BAD_EXTENTS, - DRAWSTATE_SWAPCHAIN_BAD_PRE_TRANSFORM, - DRAWSTATE_SWAPCHAIN_BAD_COMPOSITE_ALPHA, - DRAWSTATE_SWAPCHAIN_BAD_LAYER_COUNT, - DRAWSTATE_SWAPCHAIN_BAD_USAGE_FLAGS, - DRAWSTATE_SWAPCHAIN_TOO_MANY_IMAGES, - DRAWSTATE_SWAPCHAIN_BAD_PRESENT_MODE, - DRAWSTATE_SWAPCHAIN_BAD_FORMAT, - DRAWSTATE_SWAPCHAIN_REPLACED, - DRAWSTATE_SWAPCHAIN_IMAGES_NOT_FOUND, - DRAWSTATE_EXTENSION_NOT_ENABLED, - DRAWSTATE_INVALID_IMAGE_SUBRANGE, -}; - -// Shader Checker ERROR codes -enum SHADER_CHECKER_ERROR { - SHADER_CHECKER_NONE, - SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, - SHADER_CHECKER_OUTPUT_NOT_CONSUMED, - SHADER_CHECKER_INPUT_NOT_PRODUCED, - SHADER_CHECKER_NON_SPIRV_SHADER, - SHADER_CHECKER_INCONSISTENT_SPIRV, - SHADER_CHECKER_UNKNOWN_STAGE, - SHADER_CHECKER_INCONSISTENT_VI, - SHADER_CHECKER_MISSING_DESCRIPTOR, - SHADER_CHECKER_BAD_SPECIALIZATION, - SHADER_CHECKER_MISSING_ENTRYPOINT, - SHADER_CHECKER_PUSH_CONSTANT_OUT_OF_RANGE, - SHADER_CHECKER_PUSH_CONSTANT_NOT_ACCESSIBLE_FROM_STAGE, - SHADER_CHECKER_DESCRIPTOR_TYPE_MISMATCH, - SHADER_CHECKER_DESCRIPTOR_NOT_ACCESSIBLE_FROM_STAGE, - SHADER_CHECKER_FEATURE_NOT_ENABLED, - SHADER_CHECKER_BAD_CAPABILITY, - SHADER_CHECKER_MISSING_INPUT_ATTACHMENT, - SHADER_CHECKER_INPUT_ATTACHMENT_TYPE_MISMATCH, -}; - -// Device Limits ERROR codes -enum DEV_LIMITS_ERROR { - DEVLIMITS_NONE, - DEVLIMITS_INVALID_INSTANCE, - DEVLIMITS_INVALID_PHYSICAL_DEVICE, - DEVLIMITS_MISSING_QUERY_COUNT, - DEVLIMITS_MUST_QUERY_COUNT, - DEVLIMITS_INVALID_FEATURE_REQUESTED, - DEVLIMITS_COUNT_MISMATCH, -}; - -enum IMAGE_ERROR { - IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, - IMAGE_ZERO_AREA_SUBREGION, -}; - -enum SWAPCHAIN_ERROR { - SWAPCHAIN_INVALID_HANDLE, // Handle used that isn't currently valid - SWAPCHAIN_NULL_POINTER, // Pointer set to NULL, instead of being a valid pointer - SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED, // Did not enable WSI extension, but called WSI function - SWAPCHAIN_DEL_OBJECT_BEFORE_CHILDREN, // Called vkDestroyDevice() before vkDestroySwapchainKHR() - SWAPCHAIN_CREATE_UNSUPPORTED_SURFACE, // Called vkCreateSwapchainKHR() with a pCreateInfo->surface that wasn't supported - SWAPCHAIN_CREATE_SWAP_WITHOUT_QUERY, // Called vkCreateSwapchainKHR() without calling a query - SWAPCHAIN_CREATE_SWAP_OUT_OF_BOUNDS_EXTENTS, // Called vkCreateSwapchainKHR() with out-of-bounds imageExtent - SWAPCHAIN_CREATE_SWAP_EXTENTS_NO_MATCH_WIN, // Called vkCreateSwapchainKHR w/imageExtent that doesn't match window's extent - SWAPCHAIN_CREATE_SWAP_BAD_PRE_TRANSFORM, // Called vkCreateSwapchainKHR() with a non-supported preTransform - SWAPCHAIN_CREATE_SWAP_BAD_COMPOSITE_ALPHA, // Called vkCreateSwapchainKHR() with a non-supported compositeAlpha - SWAPCHAIN_CREATE_SWAP_BAD_IMG_ARRAY_LAYERS, // Called vkCreateSwapchainKHR() with a non-supported imageArrayLayers - SWAPCHAIN_CREATE_SWAP_BAD_IMG_USAGE_FLAGS, // Called vkCreateSwapchainKHR() with a non-supported imageUsageFlags - SWAPCHAIN_CREATE_SWAP_BAD_IMG_COLOR_SPACE, // Called vkCreateSwapchainKHR() with a non-supported imageColorSpace - SWAPCHAIN_CREATE_SWAP_BAD_IMG_FORMAT, // Called vkCreateSwapchainKHR() with a non-supported imageFormat - SWAPCHAIN_CREATE_SWAP_BAD_IMG_FMT_CLR_SP, // Called vkCreateSwapchainKHR() with a non-supported imageColorSpace - SWAPCHAIN_CREATE_SWAP_BAD_PRESENT_MODE, // Called vkCreateSwapchainKHR() with a non-supported presentMode - SWAPCHAIN_CREATE_SWAP_BAD_SHARING_MODE, // Called vkCreateSwapchainKHR() with a non-supported imageSharingMode - SWAPCHAIN_CREATE_SWAP_BAD_SHARING_VALUES, // Called vkCreateSwapchainKHR() with bad values when imageSharingMode is - // VK_SHARING_MODE_CONCURRENT - SWAPCHAIN_BAD_BOOL, // VkBool32 that doesn't have value of VK_TRUE or VK_FALSE (e.g. is a non-zero form of true) - SWAPCHAIN_PRIOR_COUNT, // Query must be called first to get value of pCount, then called second time - SWAPCHAIN_INVALID_COUNT, // Second time a query called, the pCount value didn't match first time - SWAPCHAIN_WRONG_STYPE, // The sType for a struct has the wrong value - SWAPCHAIN_WRONG_NEXT, // The pNext for a struct is not NULL - SWAPCHAIN_ZERO_VALUE, // A value should be non-zero - SWAPCHAIN_GET_SUPPORTED_DISPLAYS_WITHOUT_QUERY, // vkGetDisplayPlaneSupportedDisplaysKHR should be called after querying - // device display plane properties - SWAPCHAIN_PLANE_INDEX_TOO_LARGE, // a planeIndex value is larger than what vkGetDisplayPlaneSupportedDisplaysKHR returns -}; - -#endif // CORE_VALIDATION_ERROR_ENUMS_H_ diff --git a/layers/core_validation_layer.md b/layers/core_validation_layer.md deleted file mode 100644 index 45ef3f7a..00000000 --- a/layers/core_validation_layer.md +++ /dev/null @@ -1,44 +0,0 @@ -# VK\_LAYER\_LUNARG\_core\_validation -The `VK_LAYER_LUNARG_core_validation` layer validates the status of descriptor sets, command buffers, shader modules, pipeline states, renderpass usage, synchronization, dynamic states and is the workhorse layer for many other types of valid usage. - -`VK_LAYER_LUNARG_core_validation` validates that: - - - the descriptor set state and pipeline state at each draw call are consistent - - pipelines are created correctly, known when used and bound at draw time - - descriptor sets are known and consist of valid types, formats, and layout - - descriptor set regions are valid, bound, and updated appropriately - - command buffers referenced are known and valid - - command sequencing for specific state dependencies and renderpass use is correct - - memory is available - - dynamic state is correctly set. - -The `VK_LAYER_LUNARG_core_validation` layer will print errors if validation checks are not correctly met. `VK_LAYER_LUNARG_core_validation` will also display the values of the objects tracked. - -## Memory/Resource related functionality -This layer additionally attempts to ensure that memory objects are managed correctly by the application. These memory objects may be bound to pipelines, objects, and command buffers, and then submitted to the GPU for work. Specifically the layer validates that: - - - the correct memory objects have been bound - - memory objects are specified correctly upon command buffer submittal - - only existing memory objects are referenced - - destroyed memory objects are not referenced - - the application has confirmed any memory objects to be reused or destroyed have been properly unbound - - checks texture formats and render target formats. - -Errors will be printed if validation checks are not correctly met and warnings if improper (but not illegal) use of memory is detected. This validation layer also dumps all memory references and bindings for each operation. - -## Shader validation functionality -Checks performed by this layer apply to the VS->FS and FS->CB interfaces with the pipeline. These checks include: - - - validating that all variables which are part of a shader interface are decorated with either `spv::DecLocation` or `spv::DecBuiltin` (that is, only the SSO rendezvous-by-location model is supported) - - emitting a warning if a location is declared only in the producing stage (useless work is being done) - - emitting an error if a location is declared only in the consuming stage (garbage will be read). - -A special error checking case invoked when the FS stage writes a built-in corresponding to the legacy `gl_FragColor`. In this case, an error is emitted if - - - the FS also writes any user-defined output - - the CB has any attachment with a `UINT` or `SINT` type. - -These extra checks are to ensure that the legacy broadcast of `gl_FragColor` to all bound color attachments is well-defined. - -## Swapchain validation functionality -This area of functionality validates the use of the WSI (Window System Integration) "swapchain" extensions (i.e., `VK_EXT_KHR_swapchain` and `VK_EXT_KHR_device_swapchain`). diff --git a/layers/core_validation_types.h b/layers/core_validation_types.h deleted file mode 100644 index f31cae0d..00000000 --- a/layers/core_validation_types.h +++ /dev/null @@ -1,953 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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: Courtney Goeltzenleuchter - * Author: Tobin Ehlis - * Author: Chris Forbes - * Author: Mark Lobodzinski - */ -#ifndef CORE_VALIDATION_TYPES_H_ -#define CORE_VALIDATION_TYPES_H_ - -#include "hash_vk_types.h" -#include "vk_safe_struct.h" -#include "vulkan/vulkan.h" -#include "vk_validation_error_messages.h" -#include "vk_layer_logging.h" -#include "vk_object_types.h" -#include "vk_extension_helper.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// Fwd declarations -- including descriptor_set.h creates an ugly include loop -namespace cvdescriptorset { -class DescriptorSetLayoutDef; -class DescriptorSetLayout; -class DescriptorSet; -} // namespace cvdescriptorset - -struct GLOBAL_CB_NODE; - -enum CALL_STATE { - UNCALLED, // Function has not been called - QUERY_COUNT, // Function called once to query a count - QUERY_DETAILS, // Function called w/ a count to query details -}; - -class BASE_NODE { - public: - // Track when object is being used by an in-flight command buffer - std::atomic_int in_use; - // Track command buffers that this object is bound to - // binding initialized when cmd referencing object is bound to command buffer - // binding removed when command buffer is reset or destroyed - // When an object is destroyed, any bound cbs are set to INVALID - std::unordered_set cb_bindings; - - BASE_NODE() { in_use.store(0); }; -}; - -// Track command pools and their command buffers -struct COMMAND_POOL_NODE : public BASE_NODE { - VkCommandPoolCreateFlags createFlags; - uint32_t queueFamilyIndex; - // Cmd buffers allocated from this pool - std::unordered_set commandBuffers; -}; - -// Utilities for barriers and the commmand pool -template -static bool IsTransferOp(const Barrier *barrier) { - return barrier->srcQueueFamilyIndex != barrier->dstQueueFamilyIndex; -} - -template -static bool IsReleaseOp(const COMMAND_POOL_NODE *pool, const Barrier *barrier) { - return (assume_transfer || IsTransferOp(barrier)) && (pool->queueFamilyIndex == barrier->srcQueueFamilyIndex); -} - -template -static bool IsAcquireOp(const COMMAND_POOL_NODE *pool, const Barrier *barrier) { - return (assume_transfer || IsTransferOp(barrier)) && (pool->queueFamilyIndex == barrier->dstQueueFamilyIndex); -} - -// Generic wrapper for vulkan objects -struct VK_OBJECT { - uint64_t handle; - VulkanObjectType type; -}; - -inline bool operator==(VK_OBJECT a, VK_OBJECT b) NOEXCEPT { return a.handle == b.handle && a.type == b.type; } - -namespace std { -template <> -struct hash { - size_t operator()(VK_OBJECT obj) const NOEXCEPT { return hash()(obj.handle) ^ hash()(obj.type); } -}; -} // namespace std - -class PHYS_DEV_PROPERTIES_NODE { - public: - VkPhysicalDeviceProperties properties; - std::vector queue_family_properties; -}; - -// Flags describing requirements imposed by the pipeline on a descriptor. These -// can't be checked at pipeline creation time as they depend on the Image or -// ImageView bound. -enum descriptor_req { - DESCRIPTOR_REQ_VIEW_TYPE_1D = 1 << VK_IMAGE_VIEW_TYPE_1D, - DESCRIPTOR_REQ_VIEW_TYPE_1D_ARRAY = 1 << VK_IMAGE_VIEW_TYPE_1D_ARRAY, - DESCRIPTOR_REQ_VIEW_TYPE_2D = 1 << VK_IMAGE_VIEW_TYPE_2D, - DESCRIPTOR_REQ_VIEW_TYPE_2D_ARRAY = 1 << VK_IMAGE_VIEW_TYPE_2D_ARRAY, - DESCRIPTOR_REQ_VIEW_TYPE_3D = 1 << VK_IMAGE_VIEW_TYPE_3D, - DESCRIPTOR_REQ_VIEW_TYPE_CUBE = 1 << VK_IMAGE_VIEW_TYPE_CUBE, - DESCRIPTOR_REQ_VIEW_TYPE_CUBE_ARRAY = 1 << VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, - - DESCRIPTOR_REQ_ALL_VIEW_TYPE_BITS = (1 << (VK_IMAGE_VIEW_TYPE_END_RANGE + 1)) - 1, - - DESCRIPTOR_REQ_SINGLE_SAMPLE = 2 << VK_IMAGE_VIEW_TYPE_END_RANGE, - DESCRIPTOR_REQ_MULTI_SAMPLE = DESCRIPTOR_REQ_SINGLE_SAMPLE << 1, -}; - -struct DESCRIPTOR_POOL_STATE : BASE_NODE { - VkDescriptorPool pool; - uint32_t maxSets; // Max descriptor sets allowed in this pool - uint32_t availableSets; // Available descriptor sets in this pool - - safe_VkDescriptorPoolCreateInfo createInfo; - std::unordered_set sets; // Collection of all sets in this pool - std::vector maxDescriptorTypeCount; // Max # of descriptors of each type in this pool - std::vector availableDescriptorTypeCount; // Available # of descriptors of each type in this pool - - DESCRIPTOR_POOL_STATE(const VkDescriptorPool pool, const VkDescriptorPoolCreateInfo *pCreateInfo) - : pool(pool), - maxSets(pCreateInfo->maxSets), - availableSets(pCreateInfo->maxSets), - createInfo(pCreateInfo), - maxDescriptorTypeCount(VK_DESCRIPTOR_TYPE_RANGE_SIZE, 0), - availableDescriptorTypeCount(VK_DESCRIPTOR_TYPE_RANGE_SIZE, 0) { - // Collect maximums per descriptor type. - for (uint32_t i = 0; i < createInfo.poolSizeCount; ++i) { - uint32_t typeIndex = static_cast(createInfo.pPoolSizes[i].type); - // Same descriptor types can appear several times - maxDescriptorTypeCount[typeIndex] += createInfo.pPoolSizes[i].descriptorCount; - availableDescriptorTypeCount[typeIndex] = maxDescriptorTypeCount[typeIndex]; - } - } -}; - -// Generic memory binding struct to track objects bound to objects -struct MEM_BINDING { - VkDeviceMemory mem; - VkDeviceSize offset; - VkDeviceSize size; -}; - -struct INDEX_BUFFER_BINDING { - VkBuffer buffer; - VkDeviceSize size; - VkDeviceSize offset; - VkIndexType index_type; -}; - -inline bool operator==(MEM_BINDING a, MEM_BINDING b) NOEXCEPT { return a.mem == b.mem && a.offset == b.offset && a.size == b.size; } - -namespace std { -template <> -struct hash { - size_t operator()(MEM_BINDING mb) const NOEXCEPT { - auto intermediate = hash()(reinterpret_cast(mb.mem)) ^ hash()(mb.offset); - return intermediate ^ hash()(mb.size); - } -}; -} // namespace std - -// Superclass for bindable object state (currently images and buffers) -class BINDABLE : public BASE_NODE { - public: - bool sparse; // Is this object being bound with sparse memory or not? - // Non-sparse binding data - MEM_BINDING binding; - // Memory requirements for this BINDABLE - VkMemoryRequirements requirements; - // bool to track if memory requirements were checked - bool memory_requirements_checked; - // Sparse binding data, initially just tracking MEM_BINDING per mem object - // There's more data for sparse bindings so need better long-term solution - // TODO : Need to update solution to track all sparse binding data - std::unordered_set sparse_bindings; - - std::unordered_set bound_memory_set_; - - BINDABLE() - : sparse(false), binding{}, requirements{}, memory_requirements_checked(false), sparse_bindings{}, bound_memory_set_{} {}; - - // Update the cached set of memory bindings. - // Code that changes binding.mem or sparse_bindings must call UpdateBoundMemorySet() - void UpdateBoundMemorySet() { - bound_memory_set_.clear(); - if (!sparse) { - bound_memory_set_.insert(binding.mem); - } else { - for (auto sb : sparse_bindings) { - bound_memory_set_.insert(sb.mem); - } - } - } - - // Return unordered set of memory objects that are bound - // Instead of creating a set from scratch each query, return the cached one - const std::unordered_set &GetBoundMemory() const { return bound_memory_set_; } -}; - -class BUFFER_STATE : public BINDABLE { - public: - VkBuffer buffer; - VkBufferCreateInfo createInfo; - BUFFER_STATE(VkBuffer buff, const VkBufferCreateInfo *pCreateInfo) : buffer(buff), createInfo(*pCreateInfo) { - if ((createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) && (createInfo.queueFamilyIndexCount > 0)) { - uint32_t *pQueueFamilyIndices = new uint32_t[createInfo.queueFamilyIndexCount]; - for (uint32_t i = 0; i < createInfo.queueFamilyIndexCount; i++) { - pQueueFamilyIndices[i] = pCreateInfo->pQueueFamilyIndices[i]; - } - createInfo.pQueueFamilyIndices = pQueueFamilyIndices; - } - - if (createInfo.flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) { - sparse = true; - } - }; - - BUFFER_STATE(BUFFER_STATE const &rh_obj) = delete; - - ~BUFFER_STATE() { - if ((createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) && (createInfo.queueFamilyIndexCount > 0)) { - delete[] createInfo.pQueueFamilyIndices; - createInfo.pQueueFamilyIndices = nullptr; - } - }; -}; - -class BUFFER_VIEW_STATE : public BASE_NODE { - public: - VkBufferView buffer_view; - VkBufferViewCreateInfo create_info; - BUFFER_VIEW_STATE(VkBufferView bv, const VkBufferViewCreateInfo *ci) : buffer_view(bv), create_info(*ci){}; - BUFFER_VIEW_STATE(const BUFFER_VIEW_STATE &rh_obj) = delete; -}; - -struct SAMPLER_STATE : public BASE_NODE { - VkSampler sampler; - VkSamplerCreateInfo createInfo; - - SAMPLER_STATE(const VkSampler *ps, const VkSamplerCreateInfo *pci) : sampler(*ps), createInfo(*pci){}; -}; - -class IMAGE_STATE : public BINDABLE { - public: - VkImage image; - VkImageCreateInfo createInfo; - bool valid; // If this is a swapchain image backing memory track valid here as it doesn't have DEVICE_MEM_INFO - bool acquired; // If this is a swapchain image, has it been acquired by the app. - bool shared_presentable; // True for a front-buffered swapchain image - bool layout_locked; // A front-buffered image that has been presented can never have layout transitioned - bool get_sparse_reqs_called; // Track if GetImageSparseMemoryRequirements() has been called for this image - bool sparse_metadata_required; // Track if sparse metadata aspect is required for this image - bool sparse_metadata_bound; // Track if sparse metadata aspect is bound to this image - std::vector sparse_requirements; - IMAGE_STATE(VkImage img, const VkImageCreateInfo *pCreateInfo) - : image(img), - createInfo(*pCreateInfo), - valid(false), - acquired(false), - shared_presentable(false), - layout_locked(false), - get_sparse_reqs_called(false), - sparse_metadata_required(false), - sparse_metadata_bound(false), - sparse_requirements{} { - if ((createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) && (createInfo.queueFamilyIndexCount > 0)) { - uint32_t *pQueueFamilyIndices = new uint32_t[createInfo.queueFamilyIndexCount]; - for (uint32_t i = 0; i < createInfo.queueFamilyIndexCount; i++) { - pQueueFamilyIndices[i] = pCreateInfo->pQueueFamilyIndices[i]; - } - createInfo.pQueueFamilyIndices = pQueueFamilyIndices; - } - - if (createInfo.flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) { - sparse = true; - } - }; - - IMAGE_STATE(IMAGE_STATE const &rh_obj) = delete; - - ~IMAGE_STATE() { - if ((createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) && (createInfo.queueFamilyIndexCount > 0)) { - delete[] createInfo.pQueueFamilyIndices; - createInfo.pQueueFamilyIndices = nullptr; - } - }; -}; - -class IMAGE_VIEW_STATE : public BASE_NODE { - public: - VkImageView image_view; - VkImageViewCreateInfo create_info; - IMAGE_VIEW_STATE(VkImageView iv, const VkImageViewCreateInfo *ci) : image_view(iv), create_info(*ci){}; - IMAGE_VIEW_STATE(const IMAGE_VIEW_STATE &rh_obj) = delete; -}; - -struct MemRange { - VkDeviceSize offset; - VkDeviceSize size; -}; - -struct MEMORY_RANGE { - uint64_t handle; - bool image; // True for image, false for buffer - bool linear; // True for buffers and linear images - VkDeviceMemory memory; - VkDeviceSize start; - VkDeviceSize size; - VkDeviceSize end; // Store this pre-computed for simplicity - // Set of ptrs to every range aliased with this one - std::unordered_set aliases; -}; - -// Data struct for tracking memory object -struct DEVICE_MEM_INFO : public BASE_NODE { - void *object; // Dispatchable object used to create this memory (device of swapchain) - VkDeviceMemory mem; - VkMemoryAllocateInfo alloc_info; - bool is_dedicated; - VkBuffer dedicated_buffer; - VkImage dedicated_image; - std::unordered_set obj_bindings; // objects bound to this memory - std::unordered_map bound_ranges; // Map of object to its binding range - // Convenience vectors image/buff handles to speed up iterating over images or buffers independently - std::unordered_set bound_images; - std::unordered_set bound_buffers; - - MemRange mem_range; - void *shadow_copy_base; // Base of layer's allocation for guard band, data, and alignment space - void *shadow_copy; // Pointer to start of guard-band data before mapped region - uint64_t shadow_pad_size; // Size of the guard-band data before and after actual data. It MUST be a - // multiple of limits.minMemoryMapAlignment - void *p_driver_data; // Pointer to application's actual memory - - DEVICE_MEM_INFO(void *disp_object, const VkDeviceMemory in_mem, const VkMemoryAllocateInfo *p_alloc_info) - : object(disp_object), - mem(in_mem), - alloc_info(*p_alloc_info), - is_dedicated(false), - dedicated_buffer(VK_NULL_HANDLE), - dedicated_image(VK_NULL_HANDLE), - mem_range{}, - shadow_copy_base(0), - shadow_copy(0), - shadow_pad_size(0), - p_driver_data(0){}; -}; - -class SWAPCHAIN_NODE { - public: - safe_VkSwapchainCreateInfoKHR createInfo; - VkSwapchainKHR swapchain; - std::vector images; - bool replaced = false; - bool shared_presentable = false; - CALL_STATE vkGetSwapchainImagesKHRState = UNCALLED; - uint32_t get_swapchain_image_count = 0; - SWAPCHAIN_NODE(const VkSwapchainCreateInfoKHR *pCreateInfo, VkSwapchainKHR swapchain) - : createInfo(pCreateInfo), swapchain(swapchain) {} -}; - -class IMAGE_CMD_BUF_LAYOUT_NODE { - public: - IMAGE_CMD_BUF_LAYOUT_NODE() = default; - IMAGE_CMD_BUF_LAYOUT_NODE(VkImageLayout initialLayoutInput, VkImageLayout layoutInput) - : initialLayout(initialLayoutInput), layout(layoutInput) {} - - VkImageLayout initialLayout; - VkImageLayout layout; -}; - -// Store the DAG. -struct DAGNode { - uint32_t pass; - std::vector prev; - std::vector next; -}; - -struct RENDER_PASS_STATE : public BASE_NODE { - VkRenderPass renderPass; - safe_VkRenderPassCreateInfo createInfo; - std::vector hasSelfDependency; - std::vector subpassToNode; - std::vector subpass_to_dependency_index; // srcSubpass to dependency index of self dep, or -1 if none - std::unordered_map attachment_first_read; - - RENDER_PASS_STATE(VkRenderPassCreateInfo const *pCreateInfo) : createInfo(pCreateInfo) {} -}; - -// vkCmd tracking -- complete as of header 1.0.68 -// please keep in "none, then sorted" order -// Note: grepping vulkan.h for VKAPI_CALL.*vkCmd will return all functions except vkEndCommandBuffer - -enum CMD_TYPE { - CMD_NONE, - CMD_BEGINQUERY, - CMD_BEGINRENDERPASS, - CMD_BINDDESCRIPTORSETS, - CMD_BINDINDEXBUFFER, - CMD_BINDPIPELINE, - CMD_BINDVERTEXBUFFERS, - CMD_BLITIMAGE, - CMD_CLEARATTACHMENTS, - CMD_CLEARCOLORIMAGE, - CMD_CLEARDEPTHSTENCILIMAGE, - CMD_COPYBUFFER, - CMD_COPYBUFFERTOIMAGE, - CMD_COPYIMAGE, - CMD_COPYIMAGETOBUFFER, - CMD_COPYQUERYPOOLRESULTS, - CMD_DEBUGMARKERBEGINEXT, - CMD_DEBUGMARKERENDEXT, - CMD_DEBUGMARKERINSERTEXT, - CMD_DISPATCH, - CMD_DISPATCHBASEKHX, - CMD_DISPATCHINDIRECT, - CMD_DRAW, - CMD_DRAWINDEXED, - CMD_DRAWINDEXEDINDIRECT, - CMD_DRAWINDEXEDINDIRECTCOUNTAMD, - CMD_DRAWINDIRECT, - CMD_DRAWINDIRECTCOUNTAMD, - CMD_ENDCOMMANDBUFFER, // Should be the last command in any RECORDED cmd buffer - CMD_ENDQUERY, - CMD_ENDRENDERPASS, - CMD_EXECUTECOMMANDS, - CMD_FILLBUFFER, - CMD_NEXTSUBPASS, - CMD_PIPELINEBARRIER, - CMD_PROCESSCOMMANDSNVX, - CMD_PUSHCONSTANTS, - CMD_PUSHDESCRIPTORSETKHR, - CMD_PUSHDESCRIPTORSETWITHTEMPLATEKHR, - CMD_RESERVESPACEFORCOMMANDSNVX, - CMD_RESETEVENT, - CMD_RESETQUERYPOOL, - CMD_RESOLVEIMAGE, - CMD_SETBLENDCONSTANTS, - CMD_SETDEPTHBIAS, - CMD_SETDEPTHBOUNDS, - CMD_SETDEVICEMASKKHX, - CMD_SETDISCARDRECTANGLEEXT, - CMD_SETEVENT, - CMD_SETLINEWIDTH, - CMD_SETSAMPLELOCATIONSEXT, - CMD_SETSCISSOR, - CMD_SETSTENCILCOMPAREMASK, - CMD_SETSTENCILREFERENCE, - CMD_SETSTENCILWRITEMASK, - CMD_SETVIEWPORT, - CMD_SETVIEWPORTWSCALINGNV, - CMD_UPDATEBUFFER, - CMD_WAITEVENTS, - CMD_WRITETIMESTAMP, -}; - -enum CB_STATE { - CB_NEW, // Newly created CB w/o any cmds - CB_RECORDING, // BeginCB has been called on this CB - CB_RECORDED, // EndCB has been called on this CB - CB_INVALID_COMPLETE, // had a complete recording, but was since invalidated - CB_INVALID_INCOMPLETE, // fouled before recording was completed -}; - -// CB Status -- used to track status of various bindings on cmd buffer objects -typedef VkFlags CBStatusFlags; -enum CBStatusFlagBits { - // clang-format off - CBSTATUS_NONE = 0x00000000, // No status is set - CBSTATUS_LINE_WIDTH_SET = 0x00000001, // Line width has been set - CBSTATUS_DEPTH_BIAS_SET = 0x00000002, // Depth bias has been set - CBSTATUS_BLEND_CONSTANTS_SET = 0x00000004, // Blend constants state has been set - CBSTATUS_DEPTH_BOUNDS_SET = 0x00000008, // Depth bounds state object has been set - CBSTATUS_STENCIL_READ_MASK_SET = 0x00000010, // Stencil read mask has been set - CBSTATUS_STENCIL_WRITE_MASK_SET = 0x00000020, // Stencil write mask has been set - CBSTATUS_STENCIL_REFERENCE_SET = 0x00000040, // Stencil reference has been set - CBSTATUS_VIEWPORT_SET = 0x00000080, - CBSTATUS_SCISSOR_SET = 0x00000100, - CBSTATUS_INDEX_BUFFER_BOUND = 0x00000200, // Index buffer has been set - CBSTATUS_ALL_STATE_SET = 0x000001FF, // All state set (intentionally exclude index buffer) - // clang-format on -}; - -struct TEMPLATE_STATE { - VkDescriptorUpdateTemplateKHR desc_update_template; - safe_VkDescriptorUpdateTemplateCreateInfo create_info; - - TEMPLATE_STATE(VkDescriptorUpdateTemplateKHR update_template, safe_VkDescriptorUpdateTemplateCreateInfo *pCreateInfo) - : desc_update_template(update_template), create_info(*pCreateInfo) {} -}; - -struct QueryObject { - VkQueryPool pool; - uint32_t index; -}; - -inline bool operator==(const QueryObject &query1, const QueryObject &query2) { - return (query1.pool == query2.pool && query1.index == query2.index); -} - -namespace std { -template <> -struct hash { - size_t operator()(QueryObject query) const throw() { - return hash()((uint64_t)(query.pool)) ^ hash()(query.index); - } -}; -} // namespace std -struct DRAW_DATA { - std::vector buffers; -}; - -struct ImageSubresourcePair { - VkImage image; - bool hasSubresource; - VkImageSubresource subresource; -}; - -inline bool operator==(const ImageSubresourcePair &img1, const ImageSubresourcePair &img2) { - if (img1.image != img2.image || img1.hasSubresource != img2.hasSubresource) return false; - return !img1.hasSubresource || - (img1.subresource.aspectMask == img2.subresource.aspectMask && img1.subresource.mipLevel == img2.subresource.mipLevel && - img1.subresource.arrayLayer == img2.subresource.arrayLayer); -} - -namespace std { -template <> -struct hash { - size_t operator()(ImageSubresourcePair img) const throw() { - size_t hashVal = hash()(reinterpret_cast(img.image)); - hashVal ^= hash()(img.hasSubresource); - if (img.hasSubresource) { - hashVal ^= hash()(reinterpret_cast(img.subresource.aspectMask)); - hashVal ^= hash()(img.subresource.mipLevel); - hashVal ^= hash()(img.subresource.arrayLayer); - } - return hashVal; - } -}; -} // namespace std - -// Canonical dictionary for PushConstantRanges -using PushConstantRangesDict = hash_util::Dictionary; -using PushConstantRangesId = PushConstantRangesDict::Id; - -// Canonical dictionary for the pipeline layout's layout of descriptorsetlayouts -using DescriptorSetLayoutDef = cvdescriptorset::DescriptorSetLayoutDef; -using DescriptorSetLayoutId = std::shared_ptr; -using PipelineLayoutSetLayoutsDef = std::vector; -using PipelineLayoutSetLayoutsDict = - hash_util::Dictionary>; -using PipelineLayoutSetLayoutsId = PipelineLayoutSetLayoutsDict::Id; - -// Defines/stores a compatibility defintion for set N -// The "layout layout" must store at least set+1 entries, but only the first set+1 are considered for hash and equality testing -// Note: the "cannonical" data are referenced by Id, not including handle or device specific state -// Note: hash and equality only consider layout_id entries [0, set] for determining uniqueness -struct PipelineLayoutCompatDef { - uint32_t set; - PushConstantRangesId push_constant_ranges; - PipelineLayoutSetLayoutsId set_layouts_id; - PipelineLayoutCompatDef(const uint32_t set_index, const PushConstantRangesId pcr_id, const PipelineLayoutSetLayoutsId sl_id) - : set(set_index), push_constant_ranges(pcr_id), set_layouts_id(sl_id) {} - size_t hash() const; - bool operator==(const PipelineLayoutCompatDef &other) const; -}; - -// Canonical dictionary for PipelineLayoutCompat records -using PipelineLayoutCompatDict = hash_util::Dictionary>; -using PipelineLayoutCompatId = PipelineLayoutCompatDict::Id; - -// Store layouts and pushconstants for PipelineLayout -struct PIPELINE_LAYOUT_NODE { - VkPipelineLayout layout; - std::vector> set_layouts; - PushConstantRangesId push_constant_ranges; - std::vector compat_for_set; - - PIPELINE_LAYOUT_NODE() : layout(VK_NULL_HANDLE), set_layouts{}, push_constant_ranges{}, compat_for_set{} {} - - void reset() { - layout = VK_NULL_HANDLE; - set_layouts.clear(); - push_constant_ranges.reset(); - compat_for_set.clear(); - } -}; - -class PIPELINE_STATE : public BASE_NODE { - public: - VkPipeline pipeline; - safe_VkGraphicsPipelineCreateInfo graphicsPipelineCI; - // Hold shared ptr to RP in case RP itself is destroyed - std::shared_ptr rp_state; - safe_VkComputePipelineCreateInfo computePipelineCI; - // Flag of which shader stages are active for this pipeline - uint32_t active_shaders; - uint32_t duplicate_shaders; - // Capture which slots (set#->bindings) are actually used by the shaders of this pipeline - std::unordered_map> active_slots; - // Vtx input info (if any) - std::vector vertexBindingDescriptions; - std::vector attachments; - bool blendConstantsEnabled; // Blend constants enabled for any attachments - PIPELINE_LAYOUT_NODE pipeline_layout; - VkPrimitiveTopology topology_at_rasterizer; - - // Default constructor - PIPELINE_STATE() - : pipeline{}, - graphicsPipelineCI{}, - rp_state(nullptr), - computePipelineCI{}, - active_shaders(0), - duplicate_shaders(0), - active_slots(), - vertexBindingDescriptions(), - attachments(), - blendConstantsEnabled(false), - pipeline_layout(), - topology_at_rasterizer{} {} - - void initGraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateInfo, std::shared_ptr &&rpstate) { - bool uses_color_attachment = false; - bool uses_depthstencil_attachment = false; - if (pCreateInfo->subpass < rpstate->createInfo.subpassCount) { - const auto &subpass = rpstate->createInfo.pSubpasses[pCreateInfo->subpass]; - - for (uint32_t i = 0; i < subpass.colorAttachmentCount; ++i) { - if (subpass.pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED) { - uses_color_attachment = true; - break; - } - } - - if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { - uses_depthstencil_attachment = true; - } - } - graphicsPipelineCI.initialize(pCreateInfo, uses_color_attachment, uses_depthstencil_attachment); - // Make sure compute pipeline is null - VkComputePipelineCreateInfo emptyComputeCI = {}; - computePipelineCI.initialize(&emptyComputeCI); - for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) { - const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i]; - this->duplicate_shaders |= this->active_shaders & pPSSCI->stage; - this->active_shaders |= pPSSCI->stage; - } - if (graphicsPipelineCI.pVertexInputState) { - const auto pVICI = graphicsPipelineCI.pVertexInputState; - if (pVICI->vertexBindingDescriptionCount) { - this->vertexBindingDescriptions = std::vector( - pVICI->pVertexBindingDescriptions, pVICI->pVertexBindingDescriptions + pVICI->vertexBindingDescriptionCount); - } - } - if (graphicsPipelineCI.pColorBlendState) { - const auto pCBCI = graphicsPipelineCI.pColorBlendState; - if (pCBCI->attachmentCount) { - this->attachments = std::vector(pCBCI->pAttachments, - pCBCI->pAttachments + pCBCI->attachmentCount); - } - } - if (graphicsPipelineCI.pInputAssemblyState) { - topology_at_rasterizer = graphicsPipelineCI.pInputAssemblyState->topology; - } - rp_state = rpstate; - } - - void initComputePipeline(const VkComputePipelineCreateInfo *pCreateInfo) { - computePipelineCI.initialize(pCreateInfo); - // Make sure gfx pipeline is null - VkGraphicsPipelineCreateInfo emptyGraphicsCI = {}; - graphicsPipelineCI.initialize(&emptyGraphicsCI, false, false); - switch (computePipelineCI.stage.stage) { - case VK_SHADER_STAGE_COMPUTE_BIT: - this->active_shaders |= VK_SHADER_STAGE_COMPUTE_BIT; - break; - default: - // TODO : Flag error - break; - } - } -}; - -// Track last states that are bound per pipeline bind point (Gfx & Compute) -struct LAST_BOUND_STATE { - PIPELINE_STATE *pipeline_state; - VkPipelineLayout pipeline_layout; - // Track each set that has been bound - // Ordered bound set tracking where index is set# that given set is bound to - std::vector boundDescriptorSets; - std::unique_ptr push_descriptor_set; - // one dynamic offset per dynamic descriptor bound to this CB - std::vector> dynamicOffsets; - std::vector compat_id_for_set; - - void reset() { - pipeline_state = nullptr; - pipeline_layout = VK_NULL_HANDLE; - boundDescriptorSets.clear(); - push_descriptor_set = nullptr; - dynamicOffsets.clear(); - } -}; -// Cmd Buffer Wrapper Struct - TODO : This desperately needs its own class -struct GLOBAL_CB_NODE : public BASE_NODE { - VkCommandBuffer commandBuffer; - VkCommandBufferAllocateInfo createInfo = {}; - VkCommandBufferBeginInfo beginInfo; - VkCommandBufferInheritanceInfo inheritanceInfo; - VkDevice device; // device this CB belongs to - bool hasDrawCmd; - CB_STATE state; // Track cmd buffer update state - uint64_t submitCount; // Number of times CB has been submitted - typedef uint64_t ImageLayoutUpdateCount; - ImageLayoutUpdateCount image_layout_change_count; // The sequence number for changes to image layout (for cached validation) - CBStatusFlags status; // Track status of various bindings on cmd buffer - CBStatusFlags static_status; // All state bits provided by current graphics pipeline - // rather than dynamic state - // Currently storing "lastBound" objects on per-CB basis - // long-term may want to create caches of "lastBound" states and could have - // each individual CMD_NODE referencing its own "lastBound" state - // Store last bound state for Gfx & Compute pipeline bind points - LAST_BOUND_STATE lastBound[VK_PIPELINE_BIND_POINT_RANGE_SIZE]; - - uint32_t viewportMask; - uint32_t scissorMask; - VkRenderPassBeginInfo activeRenderPassBeginInfo; - RENDER_PASS_STATE *activeRenderPass; - VkSubpassContents activeSubpassContents; - uint32_t activeSubpass; - VkFramebuffer activeFramebuffer; - std::unordered_set framebuffers; - // Unified data structs to track objects bound to this command buffer as well as object - // dependencies that have been broken : either destroyed objects, or updated descriptor sets - std::unordered_set object_bindings; - std::vector broken_bindings; - - std::unordered_set waitedEvents; - std::vector writeEventsBeforeWait; - std::vector events; - std::unordered_map> waitedEventsBeforeQueryReset; - std::unordered_map queryToStateMap; // 0 is unavailable, 1 is available - std::unordered_set activeQueries; - std::unordered_set startedQueries; - std::unordered_map imageLayoutMap; - std::unordered_map eventToStageMap; - std::vector drawData; - DRAW_DATA currentDrawData; - bool vertex_buffer_used; // Track for perf warning to make sure any bound vtx buffer used - VkCommandBuffer primaryCommandBuffer; - // Track images and buffers that are updated by this CB at the point of a draw - std::unordered_set updateImages; - std::unordered_set updateBuffers; - // If primary, the secondary command buffers we will call. - // If secondary, the primary command buffers we will be called by. - std::unordered_set linkedCommandBuffers; - // Validation functions run at primary CB queue submit time - std::vector> queue_submit_functions; - // Validation functions run when secondary CB is executed in primary - std::vector> cmd_execute_commands_functions; - std::unordered_set memObjs; - std::vector> eventUpdates; - std::vector> queryUpdates; - std::unordered_set validated_descriptor_sets; - // Contents valid only after an index buffer is bound (CBSTATUS_INDEX_BUFFER_BOUND set) - INDEX_BUFFER_BINDING index_buffer_binding; -}; - -struct SEMAPHORE_WAIT { - VkSemaphore semaphore; - VkQueue queue; - uint64_t seq; -}; - -struct CB_SUBMISSION { - CB_SUBMISSION(std::vector const &cbs, std::vector const &waitSemaphores, - std::vector const &signalSemaphores, std::vector const &externalSemaphores, - VkFence fence) - : cbs(cbs), - waitSemaphores(waitSemaphores), - signalSemaphores(signalSemaphores), - externalSemaphores(externalSemaphores), - fence(fence) {} - - std::vector cbs; - std::vector waitSemaphores; - std::vector signalSemaphores; - std::vector externalSemaphores; - VkFence fence; -}; - -struct IMAGE_LAYOUT_NODE { - VkImageLayout layout; - VkFormat format; -}; - -// CHECK_DISABLED struct is a container for bools that can block validation checks from being performed. -// The end goal is to have all checks guarded by a bool. The bools are all "false" by default meaning that all checks -// are enabled. At CreateInstance time, the user can use the VK_EXT_validation_flags extension to pass in enum values -// of VkValidationCheckEXT that will selectively disable checks. -struct CHECK_DISABLED { - bool command_buffer_state; - bool create_descriptor_set_layout; - bool destroy_buffer_view; // Skip validation at DestroyBufferView time - bool destroy_image_view; // Skip validation at DestroyImageView time - bool destroy_pipeline; // Skip validation at DestroyPipeline time - bool destroy_descriptor_pool; // Skip validation at DestroyDescriptorPool time - bool destroy_framebuffer; // Skip validation at DestroyFramebuffer time - bool destroy_renderpass; // Skip validation at DestroyRenderpass time - bool destroy_image; // Skip validation at DestroyImage time - bool destroy_sampler; // Skip validation at DestroySampler time - bool destroy_command_pool; // Skip validation at DestroyCommandPool time - bool destroy_event; // Skip validation at DestroyEvent time - bool free_memory; // Skip validation at FreeMemory time - bool object_in_use; // Skip all object in_use checking - bool idle_descriptor_set; // Skip check to verify that descriptor set is no in-use - bool push_constant_range; // Skip push constant range checks - bool free_descriptor_sets; // Skip validation prior to vkFreeDescriptorSets() - bool allocate_descriptor_sets; // Skip validation prior to vkAllocateDescriptorSets() - bool update_descriptor_sets; // Skip validation prior to vkUpdateDescriptorSets() - bool wait_for_fences; - bool get_fence_state; - bool queue_wait_idle; - bool device_wait_idle; - bool destroy_fence; - bool destroy_semaphore; - bool destroy_query_pool; - bool get_query_pool_results; - bool destroy_buffer; - bool shader_validation; // Skip validation for shaders - - void SetAll(bool value) { std::fill(&command_buffer_state, &shader_validation + 1, value); } -}; - -struct MT_FB_ATTACHMENT_INFO { - IMAGE_VIEW_STATE *view_state; - VkImage image; -}; - -class FRAMEBUFFER_STATE : public BASE_NODE { - public: - VkFramebuffer framebuffer; - safe_VkFramebufferCreateInfo createInfo; - std::shared_ptr rp_state; - std::vector attachments; - FRAMEBUFFER_STATE(VkFramebuffer fb, const VkFramebufferCreateInfo *pCreateInfo, std::shared_ptr &&rpstate) - : framebuffer(fb), createInfo(pCreateInfo), rp_state(rpstate){}; -}; - -struct shader_module; -struct DeviceExtensions; - -// Fwd declarations of layer_data and helpers to look-up/validate state from layer_data maps -namespace core_validation { -struct layer_data; -cvdescriptorset::DescriptorSet *GetSetNode(const layer_data *, VkDescriptorSet); -std::shared_ptr const GetDescriptorSetLayout(layer_data const *, VkDescriptorSetLayout); -DESCRIPTOR_POOL_STATE *GetDescriptorPoolState(const layer_data *, const VkDescriptorPool); -BUFFER_STATE *GetBufferState(const layer_data *, VkBuffer); -IMAGE_STATE *GetImageState(const layer_data *, VkImage); -DEVICE_MEM_INFO *GetMemObjInfo(const layer_data *, VkDeviceMemory); -BUFFER_VIEW_STATE *GetBufferViewState(const layer_data *, VkBufferView); -SAMPLER_STATE *GetSamplerState(const layer_data *, VkSampler); -IMAGE_VIEW_STATE *GetImageViewState(const layer_data *, VkImageView); -SWAPCHAIN_NODE *GetSwapchainNode(const layer_data *, VkSwapchainKHR); -GLOBAL_CB_NODE *GetCBNode(layer_data const *my_data, const VkCommandBuffer cb); -RENDER_PASS_STATE *GetRenderPassState(layer_data const *dev_data, VkRenderPass renderpass); -std::shared_ptr GetRenderPassStateSharedPtr(layer_data const *dev_data, VkRenderPass renderpass); -FRAMEBUFFER_STATE *GetFramebufferState(const layer_data *my_data, VkFramebuffer framebuffer); -COMMAND_POOL_NODE *GetCommandPoolNode(layer_data *dev_data, VkCommandPool pool); -shader_module const *GetShaderModuleState(layer_data const *dev_data, VkShaderModule module); -const PHYS_DEV_PROPERTIES_NODE *GetPhysDevProperties(const layer_data *device_data); -const VkPhysicalDeviceFeatures *GetEnabledFeatures(const layer_data *device_data); -const DeviceExtensions *GetEnabledExtensions(const layer_data *device_data); -const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *GetEnabledDescriptorIndexingFeatures(const layer_data *device_data); - -void invalidateCommandBuffers(const layer_data *, std::unordered_set const &, VK_OBJECT); -bool ValidateMemoryIsBoundToBuffer(const layer_data *, const BUFFER_STATE *, const char *, UNIQUE_VALIDATION_ERROR_CODE); -bool ValidateMemoryIsBoundToImage(const layer_data *, const IMAGE_STATE *, const char *, UNIQUE_VALIDATION_ERROR_CODE); -void AddCommandBufferBindingSampler(GLOBAL_CB_NODE *, SAMPLER_STATE *); -void AddCommandBufferBindingImage(const layer_data *, GLOBAL_CB_NODE *, IMAGE_STATE *); -void AddCommandBufferBindingImageView(const layer_data *, GLOBAL_CB_NODE *, IMAGE_VIEW_STATE *); -void AddCommandBufferBindingBuffer(const layer_data *, GLOBAL_CB_NODE *, BUFFER_STATE *); -void AddCommandBufferBindingBufferView(const layer_data *, GLOBAL_CB_NODE *, BUFFER_VIEW_STATE *); -bool ValidateObjectNotInUse(const layer_data *dev_data, BASE_NODE *obj_node, VK_OBJECT obj_struct, const char *caller_name, - UNIQUE_VALIDATION_ERROR_CODE error_code); -void invalidateCommandBuffers(const layer_data *dev_data, std::unordered_set const &cb_nodes, VK_OBJECT obj); -void RemoveImageMemoryRange(uint64_t handle, DEVICE_MEM_INFO *mem_info); -void RemoveBufferMemoryRange(uint64_t handle, DEVICE_MEM_INFO *mem_info); -bool ClearMemoryObjectBindings(layer_data *dev_data, uint64_t handle, VulkanObjectType type); -bool ValidateCmdQueueFlags(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const char *caller_name, VkQueueFlags flags, - UNIQUE_VALIDATION_ERROR_CODE error_code); -bool ValidateCmd(layer_data *my_data, const GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd, const char *caller_name); -bool insideRenderPass(const layer_data *my_data, const GLOBAL_CB_NODE *pCB, const char *apiName, - UNIQUE_VALIDATION_ERROR_CODE msgCode); -void SetImageMemoryValid(layer_data *dev_data, IMAGE_STATE *image_state, bool valid); -bool outsideRenderPass(const layer_data *my_data, GLOBAL_CB_NODE *pCB, const char *apiName, UNIQUE_VALIDATION_ERROR_CODE msgCode); -void SetLayout(GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const IMAGE_CMD_BUF_LAYOUT_NODE &node); -void SetLayout(GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const VkImageLayout &layout); -bool ValidateImageMemoryIsValid(layer_data *dev_data, IMAGE_STATE *image_state, const char *functionName); -bool ValidateImageSampleCount(layer_data *dev_data, IMAGE_STATE *image_state, VkSampleCountFlagBits sample_count, - const char *location, UNIQUE_VALIDATION_ERROR_CODE msgCode); -bool rangesIntersect(layer_data const *dev_data, MEMORY_RANGE const *range1, VkDeviceSize offset, VkDeviceSize end); -bool ValidateBufferMemoryIsValid(layer_data *dev_data, BUFFER_STATE *buffer_state, const char *functionName); -void SetBufferMemoryValid(layer_data *dev_data, BUFFER_STATE *buffer_state, bool valid); -bool ValidateCmdSubpassState(const layer_data *dev_data, const GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd_type); -bool ValidateCmd(layer_data *dev_data, const GLOBAL_CB_NODE *cb_state, const CMD_TYPE cmd, const char *caller_name); - -// Prototypes for layer_data accessor functions. These should be in their own header file at some point -VkFormatProperties GetFormatProperties(core_validation::layer_data *device_data, VkFormat format); -VkResult GetImageFormatProperties(core_validation::layer_data *device_data, const VkImageCreateInfo *image_ci, - VkImageFormatProperties *image_format_properties); -const debug_report_data *GetReportData(const layer_data *); -const VkPhysicalDeviceProperties *GetPhysicalDeviceProperties(layer_data *); -const CHECK_DISABLED *GetDisables(layer_data *); -std::unordered_map> *GetImageMap(core_validation::layer_data *); -std::unordered_map> *GetImageSubresourceMap(layer_data *); -std::unordered_map *GetImageLayoutMap(layer_data *); -std::unordered_map const *GetImageLayoutMap(layer_data const *); -std::unordered_map> *GetBufferMap(layer_data *device_data); -std::unordered_map> *GetBufferViewMap(layer_data *device_data); -std::unordered_map> *GetImageViewMap(layer_data *device_data); -const DeviceExtensions *GetDeviceExtensions(const layer_data *); -uint32_t GetApiVersion(const layer_data *); -} // namespace core_validation - -#endif // CORE_VALIDATION_TYPES_H_ diff --git a/layers/descriptor_sets.cpp b/layers/descriptor_sets.cpp deleted file mode 100644 index 37aa6c23..00000000 --- a/layers/descriptor_sets.cpp +++ /dev/null @@ -1,2220 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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 - * John Zulauf - */ - -// Allow use of STL min and max functions in Windows -#define NOMINMAX - -#include "descriptor_sets.h" -#include "hash_vk_types.h" -#include "vk_enum_string_helper.h" -#include "vk_safe_struct.h" -#include "vk_typemap_helper.h" -#include "buffer_validation.h" -#include -#include -#include - -// ExtendedBinding collects a VkDescriptorSetLayoutBinding and any extended -// state that comes from a different array/structure so they can stay together -// while being sorted by binding number. -struct ExtendedBinding { - ExtendedBinding(const VkDescriptorSetLayoutBinding *l, VkDescriptorBindingFlagsEXT f) : layout_binding(l), binding_flags(f) {} - - const VkDescriptorSetLayoutBinding *layout_binding; - VkDescriptorBindingFlagsEXT binding_flags; -}; - -struct BindingNumCmp { - bool operator()(const ExtendedBinding &a, const ExtendedBinding &b) const { - return a.layout_binding->binding < b.layout_binding->binding; - } -}; - -using DescriptorSetLayoutDef = cvdescriptorset::DescriptorSetLayoutDef; -using DescriptorSetLayoutId = cvdescriptorset::DescriptorSetLayoutId; - -// Canonical dictionary of DescriptorSetLayoutDef (without any handle/device specific information) -cvdescriptorset::DescriptorSetLayoutDict descriptor_set_layout_dict; - -DescriptorSetLayoutId get_canonical_id(const VkDescriptorSetLayoutCreateInfo *p_create_info) { - return descriptor_set_layout_dict.look_up(DescriptorSetLayoutDef(p_create_info)); -} - -// Construct DescriptorSetLayout instance from given create info -// Proactively reserve and resize as possible, as the reallocation was visible in profiling -cvdescriptorset::DescriptorSetLayoutDef::DescriptorSetLayoutDef(const VkDescriptorSetLayoutCreateInfo *p_create_info) - : flags_(p_create_info->flags), binding_count_(0), descriptor_count_(0), dynamic_descriptor_count_(0) { - const auto *flags_create_info = lvl_find_in_chain(p_create_info->pNext); - - binding_type_stats_ = {0, 0, 0}; - std::set sorted_bindings; - const uint32_t input_bindings_count = p_create_info->bindingCount; - // Sort the input bindings in binding number order, eliminating duplicates - for (uint32_t i = 0; i < input_bindings_count; i++) { - VkDescriptorBindingFlagsEXT flags = 0; - if (flags_create_info && flags_create_info->bindingCount == p_create_info->bindingCount) { - flags = flags_create_info->pBindingFlags[i]; - } - sorted_bindings.insert(ExtendedBinding(p_create_info->pBindings + i, flags)); - } - - // Store the create info in the sorted order from above - std::map binding_to_dyn_count; - uint32_t index = 0; - binding_count_ = static_cast(sorted_bindings.size()); - bindings_.reserve(binding_count_); - binding_flags_.reserve(binding_count_); - binding_to_index_map_.reserve(binding_count_); - for (auto input_binding : sorted_bindings) { - // Add to binding and map, s.t. it is robust to invalid duplication of binding_num - const auto binding_num = input_binding.layout_binding->binding; - binding_to_index_map_[binding_num] = index++; - bindings_.emplace_back(input_binding.layout_binding); - auto &binding_info = bindings_.back(); - binding_flags_.emplace_back(input_binding.binding_flags); - - descriptor_count_ += binding_info.descriptorCount; - if (binding_info.descriptorCount > 0) { - non_empty_bindings_.insert(binding_num); - } - - if (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || - binding_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) { - binding_to_dyn_count[binding_num] = binding_info.descriptorCount; - dynamic_descriptor_count_ += binding_info.descriptorCount; - binding_type_stats_.dynamic_buffer_count++; - } else if ((binding_info.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || - (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)) { - binding_type_stats_.non_dynamic_buffer_count++; - } else { - binding_type_stats_.image_sampler_count++; - } - } - assert(bindings_.size() == binding_count_); - assert(binding_flags_.size() == binding_count_); - uint32_t global_index = 0; - binding_to_global_index_range_map_.reserve(binding_count_); - // Vector order is finalized so create maps of bindings to descriptors and descriptors to indices - for (uint32_t i = 0; i < binding_count_; ++i) { - auto binding_num = bindings_[i].binding; - auto final_index = global_index + bindings_[i].descriptorCount; - binding_to_global_index_range_map_[binding_num] = IndexRange(global_index, final_index); - if (final_index != global_index) { - global_start_to_index_map_[global_index] = i; - } - global_index = final_index; - } - - // Now create dyn offset array mapping for any dynamic descriptors - uint32_t dyn_array_idx = 0; - binding_to_dynamic_array_idx_map_.reserve(binding_to_dyn_count.size()); - for (const auto &bc_pair : binding_to_dyn_count) { - binding_to_dynamic_array_idx_map_[bc_pair.first] = dyn_array_idx; - dyn_array_idx += bc_pair.second; - } -} - -size_t cvdescriptorset::DescriptorSetLayoutDef::hash() const { - hash_util::HashCombiner hc; - hc << flags_; - hc.Combine(bindings_); - return hc.Value(); -} -// - -// Return valid index or "end" i.e. binding_count_; -// The asserts in "Get" are reduced to the set where no valid answer(like null or 0) could be given -// Common code for all binding lookups. -uint32_t cvdescriptorset::DescriptorSetLayoutDef::GetIndexFromBinding(uint32_t binding) const { - const auto &bi_itr = binding_to_index_map_.find(binding); - if (bi_itr != binding_to_index_map_.cend()) return bi_itr->second; - return GetBindingCount(); -} -VkDescriptorSetLayoutBinding const *cvdescriptorset::DescriptorSetLayoutDef::GetDescriptorSetLayoutBindingPtrFromIndex( - const uint32_t index) const { - if (index >= bindings_.size()) return nullptr; - return bindings_[index].ptr(); -} -// Return descriptorCount for given index, 0 if index is unavailable -uint32_t cvdescriptorset::DescriptorSetLayoutDef::GetDescriptorCountFromIndex(const uint32_t index) const { - if (index >= bindings_.size()) return 0; - return bindings_[index].descriptorCount; -} -// For the given index, return descriptorType -VkDescriptorType cvdescriptorset::DescriptorSetLayoutDef::GetTypeFromIndex(const uint32_t index) const { - assert(index < bindings_.size()); - if (index < bindings_.size()) return bindings_[index].descriptorType; - return VK_DESCRIPTOR_TYPE_MAX_ENUM; -} -// For the given index, return stageFlags -VkShaderStageFlags cvdescriptorset::DescriptorSetLayoutDef::GetStageFlagsFromIndex(const uint32_t index) const { - assert(index < bindings_.size()); - if (index < bindings_.size()) return bindings_[index].stageFlags; - return VkShaderStageFlags(0); -} -// Return binding flags for given index, 0 if index is unavailable -VkDescriptorBindingFlagsEXT cvdescriptorset::DescriptorSetLayoutDef::GetDescriptorBindingFlagsFromIndex( - const uint32_t index) const { - if (index >= binding_flags_.size()) return 0; - return binding_flags_[index]; -} - -// For the given global index, return index -uint32_t cvdescriptorset::DescriptorSetLayoutDef::GetIndexFromGlobalIndex(const uint32_t global_index) const { - auto start_it = global_start_to_index_map_.upper_bound(global_index); - uint32_t index = binding_count_; - assert(start_it != global_start_to_index_map_.cbegin()); - if (start_it != global_start_to_index_map_.cbegin()) { - --start_it; - index = start_it->second; -#ifndef NDEBUG - const auto &range = GetGlobalIndexRangeFromBinding(bindings_[index].binding); - assert(range.start <= global_index && global_index < range.end); -#endif - } - return index; -} - -// For the given binding, return the global index range -// As start and end are often needed in pairs, get both with a single hash lookup. -const cvdescriptorset::IndexRange &cvdescriptorset::DescriptorSetLayoutDef::GetGlobalIndexRangeFromBinding( - const uint32_t binding) const { - assert(binding_to_global_index_range_map_.count(binding)); - // In error case max uint32_t so index is out of bounds to break ASAP - const static IndexRange kInvalidRange = {0xFFFFFFFF, 0xFFFFFFFF}; - const auto &range_it = binding_to_global_index_range_map_.find(binding); - if (range_it != binding_to_global_index_range_map_.end()) { - return range_it->second; - } - return kInvalidRange; -} - -// For given binding, return ptr to ImmutableSampler array -VkSampler const *cvdescriptorset::DescriptorSetLayoutDef::GetImmutableSamplerPtrFromBinding(const uint32_t binding) const { - const auto &bi_itr = binding_to_index_map_.find(binding); - if (bi_itr != binding_to_index_map_.end()) { - return bindings_[bi_itr->second].pImmutableSamplers; - } - return nullptr; -} -// Move to next valid binding having a non-zero binding count -uint32_t cvdescriptorset::DescriptorSetLayoutDef::GetNextValidBinding(const uint32_t binding) const { - auto it = non_empty_bindings_.upper_bound(binding); - assert(it != non_empty_bindings_.cend()); - if (it != non_empty_bindings_.cend()) return *it; - return GetMaxBinding() + 1; -} -// For given index, return ptr to ImmutableSampler array -VkSampler const *cvdescriptorset::DescriptorSetLayoutDef::GetImmutableSamplerPtrFromIndex(const uint32_t index) const { - if (index < bindings_.size()) { - return bindings_[index].pImmutableSamplers; - } - return nullptr; -} -// If our layout is compatible with rh_ds_layout, return true, -// else return false and fill in error_msg will description of what causes incompatibility -bool cvdescriptorset::DescriptorSetLayout::IsCompatible(DescriptorSetLayout const *const rh_ds_layout, - std::string *error_msg) const { - // Trivial case - if (layout_ == rh_ds_layout->GetDescriptorSetLayout()) return true; - if (get_layout_def() == rh_ds_layout->get_layout_def()) return true; - bool detailed_compat_check = - get_layout_def()->IsCompatible(layout_, rh_ds_layout->GetDescriptorSetLayout(), rh_ds_layout->get_layout_def(), error_msg); - // The detailed check should never tell us mismatching DSL are compatible - assert(!detailed_compat_check); - return detailed_compat_check; -} - -// Do a detailed compatibility check of this def (referenced by ds_layout), vs. the rhs (layout and def) -// Should only be called if trivial accept has failed, and in that context should return false. -bool cvdescriptorset::DescriptorSetLayoutDef::IsCompatible(VkDescriptorSetLayout ds_layout, VkDescriptorSetLayout rh_ds_layout, - DescriptorSetLayoutDef const *const rh_ds_layout_def, - std::string *error_msg) const { - if (descriptor_count_ != rh_ds_layout_def->descriptor_count_) { - std::stringstream error_str; - error_str << "DescriptorSetLayout " << ds_layout << " has " << descriptor_count_ << " descriptors, but DescriptorSetLayout " - << rh_ds_layout << ", which comes from pipelineLayout, has " << rh_ds_layout_def->descriptor_count_ - << " descriptors."; - *error_msg = error_str.str(); - return false; // trivial fail case - } - - // Descriptor counts match so need to go through bindings one-by-one - // and verify that type and stageFlags match - for (auto binding : bindings_) { - // TODO : Do we also need to check immutable samplers? - // VkDescriptorSetLayoutBinding *rh_binding; - if (binding.descriptorCount != rh_ds_layout_def->GetDescriptorCountFromBinding(binding.binding)) { - std::stringstream error_str; - error_str << "Binding " << binding.binding << " for DescriptorSetLayout " << ds_layout << " has a descriptorCount of " - << binding.descriptorCount << " but binding " << binding.binding << " for DescriptorSetLayout " - << rh_ds_layout << ", which comes from pipelineLayout, has a descriptorCount of " - << rh_ds_layout_def->GetDescriptorCountFromBinding(binding.binding); - *error_msg = error_str.str(); - return false; - } else if (binding.descriptorType != rh_ds_layout_def->GetTypeFromBinding(binding.binding)) { - std::stringstream error_str; - error_str << "Binding " << binding.binding << " for DescriptorSetLayout " << ds_layout << " is type '" - << string_VkDescriptorType(binding.descriptorType) << "' but binding " << binding.binding - << " for DescriptorSetLayout " << rh_ds_layout << ", which comes from pipelineLayout, is type '" - << string_VkDescriptorType(rh_ds_layout_def->GetTypeFromBinding(binding.binding)) << "'"; - *error_msg = error_str.str(); - return false; - } else if (binding.stageFlags != rh_ds_layout_def->GetStageFlagsFromBinding(binding.binding)) { - std::stringstream error_str; - error_str << "Binding " << binding.binding << " for DescriptorSetLayout " << ds_layout << " has stageFlags " - << binding.stageFlags << " but binding " << binding.binding << " for DescriptorSetLayout " << rh_ds_layout - << ", which comes from pipelineLayout, has stageFlags " - << rh_ds_layout_def->GetStageFlagsFromBinding(binding.binding); - *error_msg = error_str.str(); - return false; - } - } - return true; -} - -bool cvdescriptorset::DescriptorSetLayoutDef::IsNextBindingConsistent(const uint32_t binding) const { - if (!binding_to_index_map_.count(binding + 1)) return false; - auto const &bi_itr = binding_to_index_map_.find(binding); - if (bi_itr != binding_to_index_map_.end()) { - const auto &next_bi_itr = binding_to_index_map_.find(binding + 1); - if (next_bi_itr != binding_to_index_map_.end()) { - auto type = bindings_[bi_itr->second].descriptorType; - auto stage_flags = bindings_[bi_itr->second].stageFlags; - auto immut_samp = bindings_[bi_itr->second].pImmutableSamplers ? true : false; - auto flags = binding_flags_[bi_itr->second]; - if ((type != bindings_[next_bi_itr->second].descriptorType) || - (stage_flags != bindings_[next_bi_itr->second].stageFlags) || - (immut_samp != (bindings_[next_bi_itr->second].pImmutableSamplers ? true : false)) || - (flags != binding_flags_[next_bi_itr->second])) { - return false; - } - return true; - } - } - return false; -} -// Starting at offset descriptor of given binding, parse over update_count -// descriptor updates and verify that for any binding boundaries that are crossed, the next binding(s) are all consistent -// Consistency means that their type, stage flags, and whether or not they use immutable samplers matches -// If so, return true. If not, fill in error_msg and return false -bool cvdescriptorset::DescriptorSetLayoutDef::VerifyUpdateConsistency(uint32_t current_binding, uint32_t offset, - uint32_t update_count, const char *type, - const VkDescriptorSet set, std::string *error_msg) const { - // Verify consecutive bindings match (if needed) - auto orig_binding = current_binding; - // Track count of descriptors in the current_bindings that are remaining to be updated - auto binding_remaining = GetDescriptorCountFromBinding(current_binding); - // First, it's legal to offset beyond your own binding so handle that case - // Really this is just searching for the binding in which the update begins and adjusting offset accordingly - while (offset >= binding_remaining) { - // Advance to next binding, decrement offset by binding size - offset -= binding_remaining; - binding_remaining = GetDescriptorCountFromBinding(++current_binding); - } - binding_remaining -= offset; - while (update_count > binding_remaining) { // While our updates overstep current binding - // Verify next consecutive binding matches type, stage flags & immutable sampler use - if (!IsNextBindingConsistent(current_binding++)) { - std::stringstream error_str; - error_str << "Attempting " << type << " descriptor set " << set << " binding #" << orig_binding << " with #" - << update_count - << " descriptors being updated but this update oversteps the bounds of this binding and the next binding is " - "not consistent with current binding so this update is invalid."; - *error_msg = error_str.str(); - return false; - } - // For sake of this check consider the bindings updated and grab count for next binding - update_count -= binding_remaining; - binding_remaining = GetDescriptorCountFromBinding(current_binding); - } - return true; -} - -// The DescriptorSetLayout stores the per handle data for a descriptor set layout, and references the common defintion for the -// handle invariant portion -cvdescriptorset::DescriptorSetLayout::DescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo *p_create_info, - const VkDescriptorSetLayout layout) - : layout_(layout), layout_destroyed_(false), layout_id_(get_canonical_id(p_create_info)) {} - -// Validate descriptor set layout create info -bool cvdescriptorset::DescriptorSetLayout::ValidateCreateInfo( - const debug_report_data *report_data, const VkDescriptorSetLayoutCreateInfo *create_info, const bool push_descriptor_ext, - const uint32_t max_push_descriptors, const bool descriptor_indexing_ext, - const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing_features) { - bool skip = false; - std::unordered_set bindings; - uint64_t total_descriptors = 0; - - const auto *flags_create_info = lvl_find_in_chain(create_info->pNext); - - const bool push_descriptor_set = !!(create_info->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR); - if (push_descriptor_set && !push_descriptor_ext) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_EXTENSION_NOT_ENABLED, - "Attempted to use %s in %s but its required extension %s has not been enabled.\n", - "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR", "VkDescriptorSetLayoutCreateInfo::flags", - VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME); - } - - const bool update_after_bind_set = !!(create_info->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT); - if (update_after_bind_set && !descriptor_indexing_ext) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DRAWSTATE_EXTENSION_NOT_ENABLED, - "Attemped to use %s in %s but its required extension %s has not been enabled.\n", - "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT", "VkDescriptorSetLayoutCreateInfo::flags", - VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME); - } - - auto valid_type = [push_descriptor_set](const VkDescriptorType type) { - return !push_descriptor_set || - ((type != VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) && (type != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)); - }; - - uint32_t max_binding = 0; - - for (uint32_t i = 0; i < create_info->bindingCount; ++i) { - const auto &binding_info = create_info->pBindings[i]; - max_binding = std::max(max_binding, binding_info.binding); - - if (!bindings.insert(binding_info.binding).second) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0500022e, "duplicated binding number in VkDescriptorSetLayoutBinding."); - } - if (!valid_type(binding_info.descriptorType)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_05000230, - "invalid type %s ,for push descriptors in VkDescriptorSetLayoutBinding entry %" PRIu32 ".", - string_VkDescriptorType(binding_info.descriptorType), i); - } - total_descriptors += binding_info.descriptorCount; - } - - if (flags_create_info) { - if (flags_create_info->bindingCount != 0 && flags_create_info->bindingCount != create_info->bindingCount) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01774, - "VkDescriptorSetLayoutCreateInfo::bindingCount (%d) != " - "VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::bindingCount (%d)", - create_info->bindingCount, flags_create_info->bindingCount); - } - - if (flags_create_info->bindingCount == create_info->bindingCount) { - for (uint32_t i = 0; i < create_info->bindingCount; ++i) { - const auto &binding_info = create_info->pBindings[i]; - - if (flags_create_info->pBindingFlags[i] & VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT) { - if (!update_after_bind_set) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_05001770, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - - if (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER && - !descriptor_indexing_features->descriptorBindingUniformBufferUpdateAfterBind) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a0177a, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - if ((binding_info.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || - binding_info.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER || - binding_info.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) && - !descriptor_indexing_features->descriptorBindingSampledImageUpdateAfterBind) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a0177c, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - if (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE && - !descriptor_indexing_features->descriptorBindingStorageImageUpdateAfterBind) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a0177e, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - if (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER && - !descriptor_indexing_features->descriptorBindingStorageBufferUpdateAfterBind) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01780, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - if (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER && - !descriptor_indexing_features->descriptorBindingUniformTexelBufferUpdateAfterBind) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01782, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - if (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER && - !descriptor_indexing_features->descriptorBindingStorageTexelBufferUpdateAfterBind) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01784, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - if ((binding_info.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || - binding_info.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || - binding_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01786, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - } - - if (flags_create_info->pBindingFlags[i] & VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT) { - if (!descriptor_indexing_features->descriptorBindingUpdateUnusedWhilePending) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01788, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - } - - if (flags_create_info->pBindingFlags[i] & VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT) { - if (!descriptor_indexing_features->descriptorBindingPartiallyBound) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a0178a, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - } - - if (flags_create_info->pBindingFlags[i] & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT) { - if (binding_info.binding != max_binding) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01778, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - - if (!descriptor_indexing_features->descriptorBindingVariableDescriptorCount) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a0178c, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - if ((binding_info.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || - binding_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a0178e, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - } - - if (push_descriptor_set && - (flags_create_info->pBindingFlags[i] & - (VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT | - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_46a01776, "Invalid flags for VkDescriptorSetLayoutBinding entry %" PRIu32, i); - } - } - } - } - - if ((push_descriptor_set) && (total_descriptors > max_push_descriptors)) { - const char *undefined = push_descriptor_ext ? "" : " -- undefined"; - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, VALIDATION_ERROR_05000232, - "for push descriptor, total descriptor count in layout (%" PRIu64 - ") must not be greater than VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors (%" PRIu32 "%s).", - total_descriptors, max_push_descriptors, undefined); - } - - return skip; -} - -cvdescriptorset::AllocateDescriptorSetsData::AllocateDescriptorSetsData(uint32_t count) - : required_descriptors_by_type{}, layout_nodes(count, nullptr) {} - -cvdescriptorset::DescriptorSet::DescriptorSet(const VkDescriptorSet set, const VkDescriptorPool pool, - const std::shared_ptr &layout, uint32_t variable_count, - layer_data *dev_data) - : some_update_(false), - set_(set), - pool_state_(nullptr), - p_layout_(layout), - device_data_(dev_data), - limits_(GetPhysDevProperties(dev_data)->properties.limits), - variable_count_(variable_count) { - pool_state_ = GetDescriptorPoolState(dev_data, pool); - // Foreach binding, create default descriptors of given type - descriptors_.reserve(p_layout_->GetTotalDescriptorCount()); - for (uint32_t i = 0; i < p_layout_->GetBindingCount(); ++i) { - auto type = p_layout_->GetTypeFromIndex(i); - switch (type) { - case VK_DESCRIPTOR_TYPE_SAMPLER: { - auto immut_sampler = p_layout_->GetImmutableSamplerPtrFromIndex(i); - for (uint32_t di = 0; di < p_layout_->GetDescriptorCountFromIndex(i); ++di) { - if (immut_sampler) { - descriptors_.emplace_back(new SamplerDescriptor(immut_sampler + di)); - some_update_ = true; // Immutable samplers are updated at creation - } else - descriptors_.emplace_back(new SamplerDescriptor(nullptr)); - } - break; - } - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: { - auto immut = p_layout_->GetImmutableSamplerPtrFromIndex(i); - for (uint32_t di = 0; di < p_layout_->GetDescriptorCountFromIndex(i); ++di) { - if (immut) { - descriptors_.emplace_back(new ImageSamplerDescriptor(immut + di)); - some_update_ = true; // Immutable samplers are updated at creation - } else - descriptors_.emplace_back(new ImageSamplerDescriptor(nullptr)); - } - break; - } - // ImageDescriptors - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - for (uint32_t di = 0; di < p_layout_->GetDescriptorCountFromIndex(i); ++di) - descriptors_.emplace_back(new ImageDescriptor(type)); - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - for (uint32_t di = 0; di < p_layout_->GetDescriptorCountFromIndex(i); ++di) - descriptors_.emplace_back(new TexelDescriptor(type)); - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - for (uint32_t di = 0; di < p_layout_->GetDescriptorCountFromIndex(i); ++di) - descriptors_.emplace_back(new BufferDescriptor(type)); - break; - default: - assert(0); // Bad descriptor type specified - break; - } - } -} - -cvdescriptorset::DescriptorSet::~DescriptorSet() { InvalidateBoundCmdBuffers(); } - -static std::string string_descriptor_req_view_type(descriptor_req req) { - std::string result(""); - for (unsigned i = 0; i <= VK_IMAGE_VIEW_TYPE_END_RANGE; i++) { - if (req & (1 << i)) { - if (result.size()) result += ", "; - result += string_VkImageViewType(VkImageViewType(i)); - } - } - - if (!result.size()) result = "(none)"; - - return result; -} - -// Is this sets underlying layout compatible with passed in layout according to "Pipeline Layout Compatibility" in spec? -bool cvdescriptorset::DescriptorSet::IsCompatible(DescriptorSetLayout const *const layout, std::string *error) const { - return layout->IsCompatible(p_layout_.get(), error); -} - -// Validate that the state of this set is appropriate for the given bindings and dynamic_offsets at Draw time -// This includes validating that all descriptors in the given bindings are updated, -// that any update buffers are valid, and that any dynamic offsets are within the bounds of their buffers. -// Return true if state is acceptable, or false and write an error message into error string -bool cvdescriptorset::DescriptorSet::ValidateDrawState(const std::map &bindings, - const std::vector &dynamic_offsets, GLOBAL_CB_NODE *cb_node, - const char *caller, std::string *error) const { - for (auto binding_pair : bindings) { - auto binding = binding_pair.first; - if (!p_layout_->HasBinding(binding)) { - std::stringstream error_str; - error_str << "Attempting to validate DrawState for binding #" << binding - << " which is an invalid binding for this descriptor set."; - *error = error_str.str(); - return false; - } - IndexRange index_range = p_layout_->GetGlobalIndexRangeFromBinding(binding); - auto array_idx = 0; // Track array idx if we're dealing with array descriptors - - if (IsVariableDescriptorCount(binding)) { - // Only validate the first N descriptors if it uses variable_count - index_range.end = index_range.start + GetVariableDescriptorCount(); - } - - for (uint32_t i = index_range.start; i < index_range.end; ++i, ++array_idx) { - if (p_layout_->GetDescriptorBindingFlagsFromBinding(binding) & VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT) { - // Can't validate the descriptor because it may not have been updated, - // or the view could have been destroyed - continue; - } else if (!descriptors_[i]->updated) { - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " is being used in draw but has not been updated."; - *error = error_str.str(); - return false; - } else { - auto descriptor_class = descriptors_[i]->GetClass(); - if (descriptor_class == GeneralBuffer) { - // Verify that buffers are valid - auto buffer = static_cast(descriptors_[i].get())->GetBuffer(); - auto buffer_node = GetBufferState(device_data_, buffer); - if (!buffer_node) { - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " references invalid buffer " << buffer << "."; - *error = error_str.str(); - return false; - } else if (!buffer_node->sparse) { - for (auto mem_binding : buffer_node->GetBoundMemory()) { - if (!GetMemObjInfo(device_data_, mem_binding)) { - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " uses buffer " << buffer << " that references invalid memory " << mem_binding << "."; - *error = error_str.str(); - return false; - } - } - } - if (descriptors_[i]->IsDynamic()) { - // Validate that dynamic offsets are within the buffer - auto buffer_size = buffer_node->createInfo.size; - auto range = static_cast(descriptors_[i].get())->GetRange(); - auto desc_offset = static_cast(descriptors_[i].get())->GetOffset(); - auto dyn_offset = dynamic_offsets[GetDynamicOffsetIndexFromBinding(binding) + array_idx]; - if (VK_WHOLE_SIZE == range) { - if ((dyn_offset + desc_offset) > buffer_size) { - std::stringstream error_str; - error_str << "Dynamic descriptor in binding #" << binding << " at global descriptor index " << i - << " uses buffer " << buffer << " with update range of VK_WHOLE_SIZE has dynamic offset " - << dyn_offset << " combined with offset " << desc_offset - << " that oversteps the buffer size of " << buffer_size << "."; - *error = error_str.str(); - return false; - } - } else { - if ((dyn_offset + desc_offset + range) > buffer_size) { - std::stringstream error_str; - error_str << "Dynamic descriptor in binding #" << binding << " at global descriptor index " << i - << " uses buffer " << buffer << " with dynamic offset " << dyn_offset - << " combined with offset " << desc_offset << " and range " << range - << " that oversteps the buffer size of " << buffer_size << "."; - *error = error_str.str(); - return false; - } - } - } - } else if (descriptor_class == ImageSampler || descriptor_class == Image) { - VkImageView image_view; - VkImageLayout image_layout; - if (descriptor_class == ImageSampler) { - image_view = static_cast(descriptors_[i].get())->GetImageView(); - image_layout = static_cast(descriptors_[i].get())->GetImageLayout(); - } else { - image_view = static_cast(descriptors_[i].get())->GetImageView(); - image_layout = static_cast(descriptors_[i].get())->GetImageLayout(); - } - auto reqs = binding_pair.second; - - auto image_view_state = GetImageViewState(device_data_, image_view); - if (nullptr == image_view_state) { - // Image view must have been destroyed since initial update. Could potentially flag the descriptor - // as "invalid" (updated = false) at DestroyImageView() time and detect this error at bind time - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " is using imageView " << image_view << " that has been destroyed."; - *error = error_str.str(); - return false; - } - auto image_view_ci = image_view_state->create_info; - - if ((reqs & DESCRIPTOR_REQ_ALL_VIEW_TYPE_BITS) && (~reqs & (1 << image_view_ci.viewType))) { - // bad view type - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " requires an image view of type " << string_descriptor_req_view_type(reqs) << " but got " - << string_VkImageViewType(image_view_ci.viewType) << "."; - *error = error_str.str(); - return false; - } - - auto image_node = GetImageState(device_data_, image_view_ci.image); - assert(image_node); - // Verify Image Layout - // Copy first mip level into sub_layers and loop over each mip level to verify layout - VkImageSubresourceLayers sub_layers; - sub_layers.aspectMask = image_view_ci.subresourceRange.aspectMask; - sub_layers.baseArrayLayer = image_view_ci.subresourceRange.baseArrayLayer; - sub_layers.layerCount = image_view_ci.subresourceRange.layerCount; - bool hit_error = false; - for (auto cur_level = image_view_ci.subresourceRange.baseMipLevel; - cur_level < image_view_ci.subresourceRange.levelCount; ++cur_level) { - sub_layers.mipLevel = cur_level; - VerifyImageLayout(device_data_, cb_node, image_node, sub_layers, image_layout, VK_IMAGE_LAYOUT_UNDEFINED, - caller, VALIDATION_ERROR_046002b0, &hit_error); - if (hit_error) { - *error = - "Image layout specified at vkUpdateDescriptorSets() time doesn't match actual image layout at time " - "descriptor is used. See previous error callback for specific details."; - return false; - } - } - // Verify Sample counts - if ((reqs & DESCRIPTOR_REQ_SINGLE_SAMPLE) && image_node->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) { - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " requires bound image to have VK_SAMPLE_COUNT_1_BIT but got " - << string_VkSampleCountFlagBits(image_node->createInfo.samples) << "."; - *error = error_str.str(); - return false; - } - if ((reqs & DESCRIPTOR_REQ_MULTI_SAMPLE) && image_node->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) { - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " requires bound image to have multiple samples, but got VK_SAMPLE_COUNT_1_BIT."; - *error = error_str.str(); - return false; - } - } - if (descriptor_class == ImageSampler || descriptor_class == PlainSampler) { - // Verify Sampler still valid - VkSampler sampler; - if (descriptor_class == ImageSampler) { - sampler = static_cast(descriptors_[i].get())->GetSampler(); - } else { - sampler = static_cast(descriptors_[i].get())->GetSampler(); - } - if (!ValidateSampler(sampler, device_data_)) { - std::stringstream error_str; - error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i - << " is using sampler " << sampler << " that has been destroyed."; - *error = error_str.str(); - return false; - } - } - } - } - } - return true; -} - -// For given bindings, place any update buffers or images into the passed-in unordered_sets -uint32_t cvdescriptorset::DescriptorSet::GetStorageUpdates(const std::map &bindings, - std::unordered_set *buffer_set, - std::unordered_set *image_set) const { - auto num_updates = 0; - for (auto binding_pair : bindings) { - auto binding = binding_pair.first; - // If a binding doesn't exist, skip it - if (!p_layout_->HasBinding(binding)) { - continue; - } - uint32_t start_idx = p_layout_->GetGlobalIndexRangeFromBinding(binding).start; - if (descriptors_[start_idx]->IsStorage()) { - if (Image == descriptors_[start_idx]->descriptor_class) { - for (uint32_t i = 0; i < p_layout_->GetDescriptorCountFromBinding(binding); ++i) { - if (descriptors_[start_idx + i]->updated) { - image_set->insert(static_cast(descriptors_[start_idx + i].get())->GetImageView()); - num_updates++; - } - } - } else if (TexelBuffer == descriptors_[start_idx]->descriptor_class) { - for (uint32_t i = 0; i < p_layout_->GetDescriptorCountFromBinding(binding); ++i) { - if (descriptors_[start_idx + i]->updated) { - auto bufferview = static_cast(descriptors_[start_idx + i].get())->GetBufferView(); - auto bv_state = GetBufferViewState(device_data_, bufferview); - if (bv_state) { - buffer_set->insert(bv_state->create_info.buffer); - num_updates++; - } - } - } - } else if (GeneralBuffer == descriptors_[start_idx]->descriptor_class) { - for (uint32_t i = 0; i < p_layout_->GetDescriptorCountFromBinding(binding); ++i) { - if (descriptors_[start_idx + i]->updated) { - buffer_set->insert(static_cast(descriptors_[start_idx + i].get())->GetBuffer()); - num_updates++; - } - } - } - } - } - return num_updates; -} -// Set is being deleted or updates so invalidate all bound cmd buffers -void cvdescriptorset::DescriptorSet::InvalidateBoundCmdBuffers() { - core_validation::invalidateCommandBuffers(device_data_, cb_bindings, {HandleToUint64(set_), kVulkanObjectTypeDescriptorSet}); -} -// Perform write update in given update struct -void cvdescriptorset::DescriptorSet::PerformWriteUpdate(const VkWriteDescriptorSet *update) { - // Perform update on a per-binding basis as consecutive updates roll over to next binding - auto descriptors_remaining = update->descriptorCount; - auto binding_being_updated = update->dstBinding; - auto offset = update->dstArrayElement; - uint32_t update_index = 0; - while (descriptors_remaining) { - uint32_t update_count = std::min(descriptors_remaining, GetDescriptorCountFromBinding(binding_being_updated)); - auto global_idx = p_layout_->GetGlobalIndexRangeFromBinding(binding_being_updated).start + offset; - // Loop over the updates for a single binding at a time - for (uint32_t di = 0; di < update_count; ++di, ++update_index) { - descriptors_[global_idx + di]->WriteUpdate(update, update_index); - } - // Roll over to next binding in case of consecutive update - descriptors_remaining -= update_count; - offset = 0; - binding_being_updated++; - } - if (update->descriptorCount) some_update_ = true; - - if (!(p_layout_->GetDescriptorBindingFlagsFromBinding(update->dstBinding) & - (VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT))) { - InvalidateBoundCmdBuffers(); - } -} -// Validate Copy update -bool cvdescriptorset::DescriptorSet::ValidateCopyUpdate(const debug_report_data *report_data, const VkCopyDescriptorSet *update, - const DescriptorSet *src_set, UNIQUE_VALIDATION_ERROR_CODE *error_code, - std::string *error_msg) { - // Verify dst layout still valid - if (p_layout_->IsDestroyed()) { - *error_code = VALIDATION_ERROR_03207601; - string_sprintf(error_msg, - "Cannot call vkUpdateDescriptorSets() to perform copy update on descriptor set dstSet 0x%" PRIxLEAST64 - " created with destroyed VkDescriptorSetLayout 0x%" PRIxLEAST64, - HandleToUint64(set_), HandleToUint64(p_layout_->GetDescriptorSetLayout())); - return false; - } - - // Verify src layout still valid - if (src_set->p_layout_->IsDestroyed()) { - *error_code = VALIDATION_ERROR_0322d201; - string_sprintf( - error_msg, - "Cannot call vkUpdateDescriptorSets() to perform copy update of dstSet 0x%" PRIxLEAST64 - " from descriptor set srcSet 0x%" PRIxLEAST64 " created with destroyed VkDescriptorSetLayout 0x%" PRIxLEAST64, - HandleToUint64(set_), HandleToUint64(src_set->set_), HandleToUint64(src_set->p_layout_->GetDescriptorSetLayout())); - return false; - } - - if (!p_layout_->HasBinding(update->dstBinding)) { - *error_code = VALIDATION_ERROR_032002b6; - std::stringstream error_str; - error_str << "DescriptorSet " << set_ << " does not have copy update dest binding of " << update->dstBinding; - *error_msg = error_str.str(); - return false; - } - if (!src_set->HasBinding(update->srcBinding)) { - *error_code = VALIDATION_ERROR_032002b2; - std::stringstream error_str; - error_str << "DescriptorSet " << set_ << " does not have copy update src binding of " << update->srcBinding; - *error_msg = error_str.str(); - return false; - } - // Verify idle ds - if (in_use.load() && - !(p_layout_->GetDescriptorBindingFlagsFromBinding(update->dstBinding) & - (VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT))) { - // TODO : Re-using Free Idle error code, need copy update idle error code - *error_code = VALIDATION_ERROR_2860026a; - std::stringstream error_str; - error_str << "Cannot call vkUpdateDescriptorSets() to perform copy update on descriptor set " << set_ - << " that is in use by a command buffer"; - *error_msg = error_str.str(); - return false; - } - // src & dst set bindings are valid - // Check bounds of src & dst - auto src_start_idx = src_set->GetGlobalIndexRangeFromBinding(update->srcBinding).start + update->srcArrayElement; - if ((src_start_idx + update->descriptorCount) > src_set->GetTotalDescriptorCount()) { - // SRC update out of bounds - *error_code = VALIDATION_ERROR_032002b4; - std::stringstream error_str; - error_str << "Attempting copy update from descriptorSet " << update->srcSet << " binding#" << update->srcBinding - << " with offset index of " << src_set->GetGlobalIndexRangeFromBinding(update->srcBinding).start - << " plus update array offset of " << update->srcArrayElement << " and update of " << update->descriptorCount - << " descriptors oversteps total number of descriptors in set: " << src_set->GetTotalDescriptorCount(); - *error_msg = error_str.str(); - return false; - } - auto dst_start_idx = p_layout_->GetGlobalIndexRangeFromBinding(update->dstBinding).start + update->dstArrayElement; - if ((dst_start_idx + update->descriptorCount) > p_layout_->GetTotalDescriptorCount()) { - // DST update out of bounds - *error_code = VALIDATION_ERROR_032002b8; - std::stringstream error_str; - error_str << "Attempting copy update to descriptorSet " << set_ << " binding#" << update->dstBinding - << " with offset index of " << p_layout_->GetGlobalIndexRangeFromBinding(update->dstBinding).start - << " plus update array offset of " << update->dstArrayElement << " and update of " << update->descriptorCount - << " descriptors oversteps total number of descriptors in set: " << p_layout_->GetTotalDescriptorCount(); - *error_msg = error_str.str(); - return false; - } - // Check that types match - // TODO : Base default error case going from here is VALIDATION_ERROR_0002b8012ba which covers all consistency issues, need more - // fine-grained error codes - *error_code = VALIDATION_ERROR_032002ba; - auto src_type = src_set->GetTypeFromBinding(update->srcBinding); - auto dst_type = p_layout_->GetTypeFromBinding(update->dstBinding); - if (src_type != dst_type) { - std::stringstream error_str; - error_str << "Attempting copy update to descriptorSet " << set_ << " binding #" << update->dstBinding << " with type " - << string_VkDescriptorType(dst_type) << " from descriptorSet " << src_set->GetSet() << " binding #" - << update->srcBinding << " with type " << string_VkDescriptorType(src_type) << ". Types do not match"; - *error_msg = error_str.str(); - return false; - } - // Verify consistency of src & dst bindings if update crosses binding boundaries - if ((!src_set->GetLayout()->VerifyUpdateConsistency(update->srcBinding, update->srcArrayElement, update->descriptorCount, - "copy update from", src_set->GetSet(), error_msg)) || - (!p_layout_->VerifyUpdateConsistency(update->dstBinding, update->dstArrayElement, update->descriptorCount, "copy update to", - set_, error_msg))) { - return false; - } - - if ((src_set->GetLayout()->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT) && - !(GetLayout()->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT)) { - *error_code = VALIDATION_ERROR_03200efc; - std::stringstream error_str; - error_str << "If pname:srcSet's (" << update->srcSet - << ") layout was created with the " - "ename:VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag " - "set, then pname:dstSet's (" - << update->dstSet - << ") layout must: also have been created with the " - "ename:VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set"; - *error_msg = error_str.str(); - return false; - } - - if (!(src_set->GetLayout()->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT) && - (GetLayout()->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT)) { - *error_code = VALIDATION_ERROR_03200efe; - std::stringstream error_str; - error_str << "If pname:srcSet's (" << update->srcSet - << ") layout was created without the " - "ename:VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag " - "set, then pname:dstSet's (" - << update->dstSet - << ") layout must: also have been created without the " - "ename:VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set"; - *error_msg = error_str.str(); - return false; - } - - if ((src_set->GetPoolState()->createInfo.flags & VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT) && - !(GetPoolState()->createInfo.flags & VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT)) { - *error_code = VALIDATION_ERROR_03200f00; - std::stringstream error_str; - error_str << "If the descriptor pool from which pname:srcSet (" << update->srcSet - << ") was allocated was created " - "with the ename:VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag " - "set, then the descriptor pool from which pname:dstSet (" - << update->dstSet - << ") was allocated must: " - "also have been created with the ename:VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set"; - *error_msg = error_str.str(); - return false; - } - - if (!(src_set->GetPoolState()->createInfo.flags & VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT) && - (GetPoolState()->createInfo.flags & VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT)) { - *error_code = VALIDATION_ERROR_03200f02; - std::stringstream error_str; - error_str << "If the descriptor pool from which pname:srcSet (" << update->srcSet - << ") was allocated was created " - "without the ename:VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag " - "set, then the descriptor pool from which pname:dstSet (" - << update->dstSet - << ") was allocated must: " - "also have been created without the ename:VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set"; - *error_msg = error_str.str(); - return false; - } - - // Update parameters all look good and descriptor updated so verify update contents - if (!VerifyCopyUpdateContents(update, src_set, src_type, src_start_idx, error_code, error_msg)) return false; - - // All checks passed so update is good - return true; -} -// Perform Copy update -void cvdescriptorset::DescriptorSet::PerformCopyUpdate(const VkCopyDescriptorSet *update, const DescriptorSet *src_set) { - auto src_start_idx = src_set->GetGlobalIndexRangeFromBinding(update->srcBinding).start + update->srcArrayElement; - auto dst_start_idx = p_layout_->GetGlobalIndexRangeFromBinding(update->dstBinding).start + update->dstArrayElement; - // Update parameters all look good so perform update - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - auto src = src_set->descriptors_[src_start_idx + di].get(); - auto dst = descriptors_[dst_start_idx + di].get(); - if (src->updated) { - dst->CopyUpdate(src); - some_update_ = true; - } else { - dst->updated = false; - } - } - - if (!(p_layout_->GetDescriptorBindingFlagsFromBinding(update->dstBinding) & - (VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT))) { - InvalidateBoundCmdBuffers(); - } -} - -// Bind cb_node to this set and this set to cb_node. -// Prereq: This should be called for a set that has been confirmed to be active for the given cb_node, meaning it's going -// to be used in a draw by the given cb_node -void cvdescriptorset::DescriptorSet::BindCommandBuffer(GLOBAL_CB_NODE *cb_node, - const std::map &binding_req_map) { - // bind cb to this descriptor set - cb_bindings.insert(cb_node); - // Add bindings for descriptor set, the set's pool, and individual objects in the set - cb_node->object_bindings.insert({HandleToUint64(set_), kVulkanObjectTypeDescriptorSet}); - pool_state_->cb_bindings.insert(cb_node); - cb_node->object_bindings.insert({HandleToUint64(pool_state_->pool), kVulkanObjectTypeDescriptorPool}); - // For the active slots, use set# to look up descriptorSet from boundDescriptorSets, and bind all of that descriptor set's - // resources - for (auto binding_req_pair : binding_req_map) { - auto binding = binding_req_pair.first; - auto range = p_layout_->GetGlobalIndexRangeFromBinding(binding); - for (uint32_t i = range.start; i < range.end; ++i) { - descriptors_[i]->BindCommandBuffer(device_data_, cb_node); - } - } -} -void cvdescriptorset::DescriptorSet::FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, - const BindingReqMap &in_req, BindingReqMap *out_req, - TrackedBindings *bindings) { - assert(out_req); - assert(bindings); - const auto binding = binding_req_pair.first; - // Use insert and look at the boolean ("was inserted") in the returned pair to see if this is a new set member. - // Saves one hash lookup vs. find ... compare w/ end ... insert. - const auto it_bool_pair = bindings->insert(binding); - if (it_bool_pair.second) { - out_req->emplace(binding_req_pair); - } -} -void cvdescriptorset::DescriptorSet::FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, - const BindingReqMap &in_req, BindingReqMap *out_req, - TrackedBindings *bindings, uint32_t limit) { - if (bindings->size() < limit) FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, bindings); -} - -void cvdescriptorset::DescriptorSet::FilterAndTrackBindingReqs(GLOBAL_CB_NODE *cb_state, const BindingReqMap &in_req, - BindingReqMap *out_req) { - TrackedBindings &bound = cached_validation_[cb_state].command_binding_and_usage; - if (bound.size() == GetBindingCount()) { - return; // All bindings are bound, out req is empty - } - for (const auto &binding_req_pair : in_req) { - const auto binding = binding_req_pair.first; - // If a binding doesn't exist, or has already been bound, skip it - if (p_layout_->HasBinding(binding)) { - FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, &bound); - } - } -} - -void cvdescriptorset::DescriptorSet::FilterAndTrackBindingReqs(GLOBAL_CB_NODE *cb_state, PIPELINE_STATE *pipeline, - const BindingReqMap &in_req, BindingReqMap *out_req) { - auto &validated = cached_validation_[cb_state]; - auto &image_sample_val = validated.image_samplers[pipeline]; - auto *const dynamic_buffers = &validated.dynamic_buffers; - auto *const non_dynamic_buffers = &validated.non_dynamic_buffers; - const auto &stats = p_layout_->GetBindingTypeStats(); - for (const auto &binding_req_pair : in_req) { - auto binding = binding_req_pair.first; - VkDescriptorSetLayoutBinding const *layout_binding = p_layout_->GetDescriptorSetLayoutBindingPtrFromBinding(binding); - if (!layout_binding) { - continue; - } - // Caching criteria differs per type. - // If image_layout have changed , the image descriptors need to be validated against them. - if ((layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || - (layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { - FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, dynamic_buffers, stats.dynamic_buffer_count); - } else if ((layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || - (layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)) { - FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, non_dynamic_buffers, stats.non_dynamic_buffer_count); - } else { - // This is rather crude, as the changed layouts may not impact the bound descriptors, - // but the simple "versioning" is a simple "dirt" test. - auto &version = image_sample_val[binding]; // Take advantage of default construtor zero initialzing new entries - if (version != cb_state->image_layout_change_count) { - version = cb_state->image_layout_change_count; - out_req->emplace(binding_req_pair); - } - } - } -} - -cvdescriptorset::SamplerDescriptor::SamplerDescriptor(const VkSampler *immut) : sampler_(VK_NULL_HANDLE), immutable_(false) { - updated = false; - descriptor_class = PlainSampler; - if (immut) { - sampler_ = *immut; - immutable_ = true; - updated = true; - } -} -// Validate given sampler. Currently this only checks to make sure it exists in the samplerMap -bool cvdescriptorset::ValidateSampler(const VkSampler sampler, const layer_data *dev_data) { - return (GetSamplerState(dev_data, sampler) != nullptr); -} - -bool cvdescriptorset::ValidateImageUpdate(VkImageView image_view, VkImageLayout image_layout, VkDescriptorType type, - const layer_data *dev_data, UNIQUE_VALIDATION_ERROR_CODE *error_code, - std::string *error_msg) { - // TODO : Defaulting to 00943 for all cases here. Need to create new error codes for various cases. - *error_code = VALIDATION_ERROR_15c0028c; - auto iv_state = GetImageViewState(dev_data, image_view); - if (!iv_state) { - std::stringstream error_str; - error_str << "Invalid VkImageView: " << image_view; - *error_msg = error_str.str(); - return false; - } - // Note that when an imageview is created, we validated that memory is bound so no need to re-check here - // Validate that imageLayout is compatible with aspect_mask and image format - // and validate that image usage bits are correct for given usage - VkImageAspectFlags aspect_mask = iv_state->create_info.subresourceRange.aspectMask; - VkImage image = iv_state->create_info.image; - VkFormat format = VK_FORMAT_MAX_ENUM; - VkImageUsageFlags usage = 0; - auto image_node = GetImageState(dev_data, image); - if (image_node) { - format = image_node->createInfo.format; - usage = image_node->createInfo.usage; - // Validate that memory is bound to image - // TODO: This should have its own valid usage id apart from 2524 which is from CreateImageView case. The only - // the error here occurs is if memory bound to a created imageView has been freed. - if (ValidateMemoryIsBoundToImage(dev_data, image_node, "vkUpdateDescriptorSets()", VALIDATION_ERROR_0ac007f8)) { - *error_code = VALIDATION_ERROR_0ac007f8; - *error_msg = "No memory bound to image."; - return false; - } - - // KHR_maintenance1 allows rendering into 2D or 2DArray views which slice a 3D image, - // but not binding them to descriptor sets. - if (image_node->createInfo.imageType == VK_IMAGE_TYPE_3D && - (iv_state->create_info.viewType == VK_IMAGE_VIEW_TYPE_2D || - iv_state->create_info.viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) { - *error_code = VALIDATION_ERROR_046002ae; - *error_msg = "ImageView must not be a 2D or 2DArray view of a 3D image"; - return false; - } - } - // First validate that format and layout are compatible - if (format == VK_FORMAT_MAX_ENUM) { - std::stringstream error_str; - error_str << "Invalid image (" << image << ") in imageView (" << image_view << ")."; - *error_msg = error_str.str(); - return false; - } - // TODO : The various image aspect and format checks here are based on general spec language in 11.5 Image Views section under - // vkCreateImageView(). What's the best way to create unique id for these cases? - bool ds = FormatIsDepthOrStencil(format); - switch (image_layout) { - case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: - // Only Color bit must be set - if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) { - std::stringstream error_str; - error_str - << "ImageView (" << image_view - << ") uses layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL but does not have VK_IMAGE_ASPECT_COLOR_BIT set."; - *error_msg = error_str.str(); - return false; - } - // format must NOT be DS - if (ds) { - std::stringstream error_str; - error_str << "ImageView (" << image_view - << ") uses layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL but the image format is " - << string_VkFormat(format) << " which is not a color format."; - *error_msg = error_str.str(); - return false; - } - break; - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: - // Depth or stencil bit must be set, but both must NOT be set - if (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) { - if (aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) { - // both must NOT be set - std::stringstream error_str; - error_str << "ImageView (" << image_view << ") has both STENCIL and DEPTH aspects set"; - *error_msg = error_str.str(); - return false; - } - } else if (!(aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT)) { - // Neither were set - std::stringstream error_str; - error_str << "ImageView (" << image_view << ") has layout " << string_VkImageLayout(image_layout) - << " but does not have STENCIL or DEPTH aspects set"; - *error_msg = error_str.str(); - return false; - } - // format must be DS - if (!ds) { - std::stringstream error_str; - error_str << "ImageView (" << image_view << ") has layout " << string_VkImageLayout(image_layout) - << " but the image format is " << string_VkFormat(format) << " which is not a depth/stencil format."; - *error_msg = error_str.str(); - return false; - } - break; - default: - // For other layouts if the source is depth/stencil image, both aspect bits must not be set - if (ds) { - if (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) { - if (aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) { - // both must NOT be set - std::stringstream error_str; - error_str << "ImageView (" << image_view << ") has layout " << string_VkImageLayout(image_layout) - << " and is using depth/stencil image of format " << string_VkFormat(format) - << " but it has both STENCIL and DEPTH aspects set, which is illegal. When using a depth/stencil " - "image in a descriptor set, please only set either VK_IMAGE_ASPECT_DEPTH_BIT or " - "VK_IMAGE_ASPECT_STENCIL_BIT depending on whether it will be used for depth reads or stencil " - "reads respectively."; - *error_msg = error_str.str(); - return false; - } - } - } - break; - } - // Now validate that usage flags are correctly set for given type of update - // As we're switching per-type, if any type has specific layout requirements, check those here as well - // TODO : The various image usage bit requirements are in general spec language for VkImageUsageFlags bit block in 11.3 Images - // under vkCreateImage() - // TODO : Need to also validate case VALIDATION_ERROR_15c002a0 where STORAGE_IMAGE & INPUT_ATTACH types must have been created - // with identify swizzle - std::string error_usage_bit; - switch (type) { - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: { - if (!(usage & VK_IMAGE_USAGE_SAMPLED_BIT)) { - error_usage_bit = "VK_IMAGE_USAGE_SAMPLED_BIT"; - } - break; - } - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: { - if (!(usage & VK_IMAGE_USAGE_STORAGE_BIT)) { - error_usage_bit = "VK_IMAGE_USAGE_STORAGE_BIT"; - } else if (VK_IMAGE_LAYOUT_GENERAL != image_layout) { - std::stringstream error_str; - // TODO : Need to create custom enum error codes for these cases - if (image_node->shared_presentable) { - if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR != image_layout) { - error_str << "ImageView (" << image_view - << ") of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE type with a front-buffered image is being updated with " - "layout " - << string_VkImageLayout(image_layout) - << " but according to spec section 13.1 Descriptor Types, 'Front-buffered images that report " - "support for VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT must be in the " - "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout.'"; - *error_msg = error_str.str(); - return false; - } - } else if (VK_IMAGE_LAYOUT_GENERAL != image_layout) { - error_str << "ImageView (" << image_view - << ") of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE type is being updated with layout " - << string_VkImageLayout(image_layout) - << " but according to spec section 13.1 Descriptor Types, 'Load and store operations on storage " - "images can only be done on images in VK_IMAGE_LAYOUT_GENERAL layout.'"; - *error_msg = error_str.str(); - return false; - } - } - break; - } - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: { - if (!(usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) { - error_usage_bit = "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"; - } - break; - } - default: - break; - } - if (!error_usage_bit.empty()) { - std::stringstream error_str; - error_str << "ImageView (" << image_view << ") with usage mask 0x" << usage - << " being used for a descriptor update of type " << string_VkDescriptorType(type) << " does not have " - << error_usage_bit << " set."; - *error_msg = error_str.str(); - return false; - } - return true; -} - -void cvdescriptorset::SamplerDescriptor::WriteUpdate(const VkWriteDescriptorSet *update, const uint32_t index) { - if (!immutable_) { - sampler_ = update->pImageInfo[index].sampler; - } - updated = true; -} - -void cvdescriptorset::SamplerDescriptor::CopyUpdate(const Descriptor *src) { - if (!immutable_) { - auto update_sampler = static_cast(src)->sampler_; - sampler_ = update_sampler; - } - updated = true; -} - -void cvdescriptorset::SamplerDescriptor::BindCommandBuffer(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - if (!immutable_) { - auto sampler_state = GetSamplerState(dev_data, sampler_); - if (sampler_state) core_validation::AddCommandBufferBindingSampler(cb_node, sampler_state); - } -} - -cvdescriptorset::ImageSamplerDescriptor::ImageSamplerDescriptor(const VkSampler *immut) - : sampler_(VK_NULL_HANDLE), immutable_(false), image_view_(VK_NULL_HANDLE), image_layout_(VK_IMAGE_LAYOUT_UNDEFINED) { - updated = false; - descriptor_class = ImageSampler; - if (immut) { - sampler_ = *immut; - immutable_ = true; - } -} - -void cvdescriptorset::ImageSamplerDescriptor::WriteUpdate(const VkWriteDescriptorSet *update, const uint32_t index) { - updated = true; - const auto &image_info = update->pImageInfo[index]; - if (!immutable_) { - sampler_ = image_info.sampler; - } - image_view_ = image_info.imageView; - image_layout_ = image_info.imageLayout; -} - -void cvdescriptorset::ImageSamplerDescriptor::CopyUpdate(const Descriptor *src) { - if (!immutable_) { - auto update_sampler = static_cast(src)->sampler_; - sampler_ = update_sampler; - } - auto image_view = static_cast(src)->image_view_; - auto image_layout = static_cast(src)->image_layout_; - updated = true; - image_view_ = image_view; - image_layout_ = image_layout; -} - -void cvdescriptorset::ImageSamplerDescriptor::BindCommandBuffer(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - // First add binding for any non-immutable sampler - if (!immutable_) { - auto sampler_state = GetSamplerState(dev_data, sampler_); - if (sampler_state) core_validation::AddCommandBufferBindingSampler(cb_node, sampler_state); - } - // Add binding for image - auto iv_state = GetImageViewState(dev_data, image_view_); - if (iv_state) { - core_validation::AddCommandBufferBindingImageView(dev_data, cb_node, iv_state); - } -} - -cvdescriptorset::ImageDescriptor::ImageDescriptor(const VkDescriptorType type) - : storage_(false), image_view_(VK_NULL_HANDLE), image_layout_(VK_IMAGE_LAYOUT_UNDEFINED) { - updated = false; - descriptor_class = Image; - if (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == type) storage_ = true; -} - -void cvdescriptorset::ImageDescriptor::WriteUpdate(const VkWriteDescriptorSet *update, const uint32_t index) { - updated = true; - const auto &image_info = update->pImageInfo[index]; - image_view_ = image_info.imageView; - image_layout_ = image_info.imageLayout; -} - -void cvdescriptorset::ImageDescriptor::CopyUpdate(const Descriptor *src) { - auto image_view = static_cast(src)->image_view_; - auto image_layout = static_cast(src)->image_layout_; - updated = true; - image_view_ = image_view; - image_layout_ = image_layout; -} - -void cvdescriptorset::ImageDescriptor::BindCommandBuffer(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - // Add binding for image - auto iv_state = GetImageViewState(dev_data, image_view_); - if (iv_state) { - core_validation::AddCommandBufferBindingImageView(dev_data, cb_node, iv_state); - } -} - -cvdescriptorset::BufferDescriptor::BufferDescriptor(const VkDescriptorType type) - : storage_(false), dynamic_(false), buffer_(VK_NULL_HANDLE), offset_(0), range_(0) { - updated = false; - descriptor_class = GeneralBuffer; - if (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == type) { - dynamic_ = true; - } else if (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == type) { - storage_ = true; - } else if (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == type) { - dynamic_ = true; - storage_ = true; - } -} -void cvdescriptorset::BufferDescriptor::WriteUpdate(const VkWriteDescriptorSet *update, const uint32_t index) { - updated = true; - const auto &buffer_info = update->pBufferInfo[index]; - buffer_ = buffer_info.buffer; - offset_ = buffer_info.offset; - range_ = buffer_info.range; -} - -void cvdescriptorset::BufferDescriptor::CopyUpdate(const Descriptor *src) { - auto buff_desc = static_cast(src); - updated = true; - buffer_ = buff_desc->buffer_; - offset_ = buff_desc->offset_; - range_ = buff_desc->range_; -} - -void cvdescriptorset::BufferDescriptor::BindCommandBuffer(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - auto buffer_node = GetBufferState(dev_data, buffer_); - if (buffer_node) core_validation::AddCommandBufferBindingBuffer(dev_data, cb_node, buffer_node); -} - -cvdescriptorset::TexelDescriptor::TexelDescriptor(const VkDescriptorType type) : buffer_view_(VK_NULL_HANDLE), storage_(false) { - updated = false; - descriptor_class = TexelBuffer; - if (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == type) storage_ = true; -} - -void cvdescriptorset::TexelDescriptor::WriteUpdate(const VkWriteDescriptorSet *update, const uint32_t index) { - updated = true; - buffer_view_ = update->pTexelBufferView[index]; -} - -void cvdescriptorset::TexelDescriptor::CopyUpdate(const Descriptor *src) { - updated = true; - buffer_view_ = static_cast(src)->buffer_view_; -} - -void cvdescriptorset::TexelDescriptor::BindCommandBuffer(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node) { - auto bv_state = GetBufferViewState(dev_data, buffer_view_); - if (bv_state) { - core_validation::AddCommandBufferBindingBufferView(dev_data, cb_node, bv_state); - } -} - -// This is a helper function that iterates over a set of Write and Copy updates, pulls the DescriptorSet* for updated -// sets, and then calls their respective Validate[Write|Copy]Update functions. -// If the update hits an issue for which the callback returns "true", meaning that the call down the chain should -// be skipped, then true is returned. -// If there is no issue with the update, then false is returned. -bool cvdescriptorset::ValidateUpdateDescriptorSets(const debug_report_data *report_data, const layer_data *dev_data, - uint32_t write_count, const VkWriteDescriptorSet *p_wds, uint32_t copy_count, - const VkCopyDescriptorSet *p_cds) { - bool skip = false; - // Validate Write updates - for (uint32_t i = 0; i < write_count; i++) { - auto dest_set = p_wds[i].dstSet; - auto set_node = core_validation::GetSetNode(dev_data, dest_set); - if (!set_node) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(dest_set), DRAWSTATE_INVALID_DESCRIPTOR_SET, - "Cannot call vkUpdateDescriptorSets() on descriptor set 0x%" PRIxLEAST64 " that has not been allocated.", - HandleToUint64(dest_set)); - } else { - UNIQUE_VALIDATION_ERROR_CODE error_code; - std::string error_str; - if (!set_node->ValidateWriteUpdate(report_data, &p_wds[i], &error_code, &error_str)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(dest_set), error_code, - "vkUpdateDescriptorSets() failed write update validation for Descriptor Set 0x%" PRIx64 - " with error: %s.", - HandleToUint64(dest_set), error_str.c_str()); - } - } - } - // Now validate copy updates - for (uint32_t i = 0; i < copy_count; ++i) { - auto dst_set = p_cds[i].dstSet; - auto src_set = p_cds[i].srcSet; - auto src_node = core_validation::GetSetNode(dev_data, src_set); - auto dst_node = core_validation::GetSetNode(dev_data, dst_set); - // Object_tracker verifies that src & dest descriptor set are valid - assert(src_node); - assert(dst_node); - UNIQUE_VALIDATION_ERROR_CODE error_code; - std::string error_str; - if (!dst_node->ValidateCopyUpdate(report_data, &p_cds[i], src_node, &error_code, &error_str)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(dst_set), error_code, - "vkUpdateDescriptorSets() failed copy update from Descriptor Set 0x%" PRIx64 - " to Descriptor Set 0x%" PRIx64 " with error: %s.", - HandleToUint64(src_set), HandleToUint64(dst_set), error_str.c_str()); - } - } - return skip; -} -// This is a helper function that iterates over a set of Write and Copy updates, pulls the DescriptorSet* for updated -// sets, and then calls their respective Perform[Write|Copy]Update functions. -// Prerequisite : ValidateUpdateDescriptorSets() should be called and return "false" prior to calling PerformUpdateDescriptorSets() -// with the same set of updates. -// This is split from the validate code to allow validation prior to calling down the chain, and then update after -// calling down the chain. -void cvdescriptorset::PerformUpdateDescriptorSets(const layer_data *dev_data, uint32_t write_count, - const VkWriteDescriptorSet *p_wds, uint32_t copy_count, - const VkCopyDescriptorSet *p_cds) { - // Write updates first - uint32_t i = 0; - for (i = 0; i < write_count; ++i) { - auto dest_set = p_wds[i].dstSet; - auto set_node = core_validation::GetSetNode(dev_data, dest_set); - if (set_node) { - set_node->PerformWriteUpdate(&p_wds[i]); - } - } - // Now copy updates - for (i = 0; i < copy_count; ++i) { - auto dst_set = p_cds[i].dstSet; - auto src_set = p_cds[i].srcSet; - auto src_node = core_validation::GetSetNode(dev_data, src_set); - auto dst_node = core_validation::GetSetNode(dev_data, dst_set); - if (src_node && dst_node) { - dst_node->PerformCopyUpdate(&p_cds[i], src_node); - } - } -} -// This helper function carries out the state updates for descriptor updates peformed via update templates. It basically collects -// data and leverages the PerformUpdateDescriptor helper functions to do this. -void cvdescriptorset::PerformUpdateDescriptorSetsWithTemplateKHR(layer_data *device_data, VkDescriptorSet descriptorSet, - std::unique_ptr const &template_state, - const void *pData) { - auto const &create_info = template_state->create_info; - - // Create a vector of write structs - std::vector desc_writes; - auto layout_obj = GetDescriptorSetLayout(device_data, create_info.descriptorSetLayout); - - // Create a WriteDescriptorSet struct for each template update entry - for (uint32_t i = 0; i < create_info.descriptorUpdateEntryCount; i++) { - auto binding_count = layout_obj->GetDescriptorCountFromBinding(create_info.pDescriptorUpdateEntries[i].dstBinding); - auto binding_being_updated = create_info.pDescriptorUpdateEntries[i].dstBinding; - auto dst_array_element = create_info.pDescriptorUpdateEntries[i].dstArrayElement; - - desc_writes.reserve(desc_writes.size() + create_info.pDescriptorUpdateEntries[i].descriptorCount); - for (uint32_t j = 0; j < create_info.pDescriptorUpdateEntries[i].descriptorCount; j++) { - desc_writes.emplace_back(); - auto &write_entry = desc_writes.back(); - - size_t offset = create_info.pDescriptorUpdateEntries[i].offset + j * create_info.pDescriptorUpdateEntries[i].stride; - char *update_entry = (char *)(pData) + offset; - - if (dst_array_element >= binding_count) { - dst_array_element = 0; - binding_being_updated = layout_obj->GetNextValidBinding(binding_being_updated); - } - - write_entry.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - write_entry.pNext = NULL; - write_entry.dstSet = descriptorSet; - write_entry.dstBinding = binding_being_updated; - write_entry.dstArrayElement = dst_array_element; - write_entry.descriptorCount = 1; - write_entry.descriptorType = create_info.pDescriptorUpdateEntries[i].descriptorType; - - switch (create_info.pDescriptorUpdateEntries[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - write_entry.pImageInfo = reinterpret_cast(update_entry); - break; - - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - write_entry.pBufferInfo = reinterpret_cast(update_entry); - break; - - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - write_entry.pTexelBufferView = reinterpret_cast(update_entry); - break; - default: - assert(0); - break; - } - dst_array_element++; - } - } - PerformUpdateDescriptorSets(device_data, static_cast(desc_writes.size()), desc_writes.data(), 0, NULL); -} -// Validate the state for a given write update but don't actually perform the update -// If an error would occur for this update, return false and fill in details in error_msg string -bool cvdescriptorset::DescriptorSet::ValidateWriteUpdate(const debug_report_data *report_data, const VkWriteDescriptorSet *update, - UNIQUE_VALIDATION_ERROR_CODE *error_code, std::string *error_msg) { - // Verify dst layout still valid - if (p_layout_->IsDestroyed()) { - *error_code = VALIDATION_ERROR_15c00280; - string_sprintf(error_msg, - "Cannot call vkUpdateDescriptorSets() to perform write update on descriptor set 0x%" PRIxLEAST64 - " created with destroyed VkDescriptorSetLayout 0x%" PRIxLEAST64, - HandleToUint64(set_), HandleToUint64(p_layout_->GetDescriptorSetLayout())); - return false; - } - // Verify dst binding exists - if (!p_layout_->HasBinding(update->dstBinding)) { - *error_code = VALIDATION_ERROR_15c00276; - std::stringstream error_str; - error_str << "DescriptorSet " << set_ << " does not have binding " << update->dstBinding; - *error_msg = error_str.str(); - return false; - } else { - // Make sure binding isn't empty - if (0 == p_layout_->GetDescriptorCountFromBinding(update->dstBinding)) { - *error_code = VALIDATION_ERROR_15c00278; - std::stringstream error_str; - error_str << "DescriptorSet " << set_ << " cannot updated binding " << update->dstBinding << " that has 0 descriptors"; - *error_msg = error_str.str(); - return false; - } - } - // Verify idle ds - if (in_use.load() && - !(p_layout_->GetDescriptorBindingFlagsFromBinding(update->dstBinding) & - (VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT))) { - // TODO : Re-using Free Idle error code, need write update idle error code - *error_code = VALIDATION_ERROR_2860026a; - std::stringstream error_str; - error_str << "Cannot call vkUpdateDescriptorSets() to perform write update on descriptor set " << set_ - << " that is in use by a command buffer"; - *error_msg = error_str.str(); - return false; - } - // We know that binding is valid, verify update and do update on each descriptor - auto start_idx = p_layout_->GetGlobalIndexRangeFromBinding(update->dstBinding).start + update->dstArrayElement; - auto type = p_layout_->GetTypeFromBinding(update->dstBinding); - if (type != update->descriptorType) { - *error_code = VALIDATION_ERROR_15c0027e; - std::stringstream error_str; - error_str << "Attempting write update to descriptor set " << set_ << " binding #" << update->dstBinding << " with type " - << string_VkDescriptorType(type) << " but update type is " << string_VkDescriptorType(update->descriptorType); - *error_msg = error_str.str(); - return false; - } - if (update->descriptorCount > (descriptors_.size() - start_idx)) { - *error_code = VALIDATION_ERROR_15c00282; - std::stringstream error_str; - error_str << "Attempting write update to descriptor set " << set_ << " binding #" << update->dstBinding << " with " - << descriptors_.size() - start_idx - << " descriptors in that binding and all successive bindings of the set, but update of " - << update->descriptorCount << " descriptors combined with update array element offset of " - << update->dstArrayElement << " oversteps the available number of consecutive descriptors"; - *error_msg = error_str.str(); - return false; - } - // Verify consecutive bindings match (if needed) - if (!p_layout_->VerifyUpdateConsistency(update->dstBinding, update->dstArrayElement, update->descriptorCount, "write update to", - set_, error_msg)) { - // TODO : Should break out "consecutive binding updates" language into valid usage statements - *error_code = VALIDATION_ERROR_15c00282; - return false; - } - // Update is within bounds and consistent so last step is to validate update contents - if (!VerifyWriteUpdateContents(update, start_idx, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Write update to descriptor in set " << set_ << " binding #" << update->dstBinding - << " failed with error message: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - // All checks passed, update is clean - return true; -} -// For the given buffer, verify that its creation parameters are appropriate for the given type -// If there's an error, update the error_msg string with details and return false, else return true -bool cvdescriptorset::DescriptorSet::ValidateBufferUsage(BUFFER_STATE const *buffer_node, VkDescriptorType type, - UNIQUE_VALIDATION_ERROR_CODE *error_code, std::string *error_msg) const { - // Verify that usage bits set correctly for given type - auto usage = buffer_node->createInfo.usage; - std::string error_usage_bit; - switch (type) { - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - if (!(usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)) { - *error_code = VALIDATION_ERROR_15c0029c; - error_usage_bit = "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"; - } - break; - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - if (!(usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) { - *error_code = VALIDATION_ERROR_15c0029e; - error_usage_bit = "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"; - } - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - if (!(usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)) { - *error_code = VALIDATION_ERROR_15c00292; - error_usage_bit = "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"; - } - break; - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - if (!(usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)) { - *error_code = VALIDATION_ERROR_15c00296; - error_usage_bit = "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"; - } - break; - default: - break; - } - if (!error_usage_bit.empty()) { - std::stringstream error_str; - error_str << "Buffer (" << buffer_node->buffer << ") with usage mask 0x" << usage - << " being used for a descriptor update of type " << string_VkDescriptorType(type) << " does not have " - << error_usage_bit << " set."; - *error_msg = error_str.str(); - return false; - } - return true; -} -// For buffer descriptor updates, verify the buffer usage and VkDescriptorBufferInfo struct which includes: -// 1. buffer is valid -// 2. buffer was created with correct usage flags -// 3. offset is less than buffer size -// 4. range is either VK_WHOLE_SIZE or falls in (0, (buffer size - offset)] -// 5. range and offset are within the device's limits -// If there's an error, update the error_msg string with details and return false, else return true -bool cvdescriptorset::DescriptorSet::ValidateBufferUpdate(VkDescriptorBufferInfo const *buffer_info, VkDescriptorType type, - UNIQUE_VALIDATION_ERROR_CODE *error_code, std::string *error_msg) const { - // First make sure that buffer is valid - auto buffer_node = GetBufferState(device_data_, buffer_info->buffer); - // Any invalid buffer should already be caught by object_tracker - assert(buffer_node); - if (ValidateMemoryIsBoundToBuffer(device_data_, buffer_node, "vkUpdateDescriptorSets()", VALIDATION_ERROR_15c00294)) { - *error_code = VALIDATION_ERROR_15c00294; - *error_msg = "No memory bound to buffer."; - return false; - } - // Verify usage bits - if (!ValidateBufferUsage(buffer_node, type, error_code, error_msg)) { - // error_msg will have been updated by ValidateBufferUsage() - return false; - } - // offset must be less than buffer size - if (buffer_info->offset >= buffer_node->createInfo.size) { - *error_code = VALIDATION_ERROR_044002a8; - std::stringstream error_str; - error_str << "VkDescriptorBufferInfo offset of " << buffer_info->offset << " is greater than or equal to buffer " - << buffer_node->buffer << " size of " << buffer_node->createInfo.size; - *error_msg = error_str.str(); - return false; - } - if (buffer_info->range != VK_WHOLE_SIZE) { - // Range must be VK_WHOLE_SIZE or > 0 - if (!buffer_info->range) { - *error_code = VALIDATION_ERROR_044002aa; - std::stringstream error_str; - error_str << "VkDescriptorBufferInfo range is not VK_WHOLE_SIZE and is zero, which is not allowed."; - *error_msg = error_str.str(); - return false; - } - // Range must be VK_WHOLE_SIZE or <= (buffer size - offset) - if (buffer_info->range > (buffer_node->createInfo.size - buffer_info->offset)) { - *error_code = VALIDATION_ERROR_044002ac; - std::stringstream error_str; - error_str << "VkDescriptorBufferInfo range is " << buffer_info->range << " which is greater than buffer size (" - << buffer_node->createInfo.size << ") minus requested offset of " << buffer_info->offset; - *error_msg = error_str.str(); - return false; - } - } - // Check buffer update sizes against device limits - if (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == type || VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == type) { - auto max_ub_range = limits_.maxUniformBufferRange; - // TODO : If range is WHOLE_SIZE, need to make sure underlying buffer size doesn't exceed device max - if (buffer_info->range != VK_WHOLE_SIZE && buffer_info->range > max_ub_range) { - *error_code = VALIDATION_ERROR_15c00298; - std::stringstream error_str; - error_str << "VkDescriptorBufferInfo range is " << buffer_info->range - << " which is greater than this device's maxUniformBufferRange (" << max_ub_range << ")"; - *error_msg = error_str.str(); - return false; - } - } else if (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == type || VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == type) { - auto max_sb_range = limits_.maxStorageBufferRange; - // TODO : If range is WHOLE_SIZE, need to make sure underlying buffer size doesn't exceed device max - if (buffer_info->range != VK_WHOLE_SIZE && buffer_info->range > max_sb_range) { - *error_code = VALIDATION_ERROR_15c0029a; - std::stringstream error_str; - error_str << "VkDescriptorBufferInfo range is " << buffer_info->range - << " which is greater than this device's maxStorageBufferRange (" << max_sb_range << ")"; - *error_msg = error_str.str(); - return false; - } - } - return true; -} - -// Verify that the contents of the update are ok, but don't perform actual update -bool cvdescriptorset::DescriptorSet::VerifyWriteUpdateContents(const VkWriteDescriptorSet *update, const uint32_t index, - UNIQUE_VALIDATION_ERROR_CODE *error_code, - std::string *error_msg) const { - switch (update->descriptorType) { - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - // Validate image - auto image_view = update->pImageInfo[di].imageView; - auto image_layout = update->pImageInfo[di].imageLayout; - if (!ValidateImageUpdate(image_view, image_layout, update->descriptorType, device_data_, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted write update to combined image sampler descriptor failed due to: " - << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - } - // fall through - case VK_DESCRIPTOR_TYPE_SAMPLER: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - if (!descriptors_[index + di].get()->IsImmutableSampler()) { - if (!ValidateSampler(update->pImageInfo[di].sampler, device_data_)) { - *error_code = VALIDATION_ERROR_15c0028a; - std::stringstream error_str; - error_str << "Attempted write update to sampler descriptor with invalid sampler: " - << update->pImageInfo[di].sampler << "."; - *error_msg = error_str.str(); - return false; - } - } else { - // TODO : Warn here - } - } - break; - } - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - auto image_view = update->pImageInfo[di].imageView; - auto image_layout = update->pImageInfo[di].imageLayout; - if (!ValidateImageUpdate(image_view, image_layout, update->descriptorType, device_data_, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted write update to image descriptor failed due to: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - break; - } - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - auto buffer_view = update->pTexelBufferView[di]; - auto bv_state = GetBufferViewState(device_data_, buffer_view); - if (!bv_state) { - *error_code = VALIDATION_ERROR_15c00286; - std::stringstream error_str; - error_str << "Attempted write update to texel buffer descriptor with invalid buffer view: " << buffer_view; - *error_msg = error_str.str(); - return false; - } - auto buffer = bv_state->create_info.buffer; - auto buffer_state = GetBufferState(device_data_, buffer); - // Verify that buffer underlying the view hasn't been destroyed prematurely - if (!buffer_state) { - *error_code = VALIDATION_ERROR_15c00286; - std::stringstream error_str; - error_str << "Attempted write update to texel buffer descriptor failed because underlying buffer (" << buffer - << ") has been destroyed: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } else if (!ValidateBufferUsage(buffer_state, update->descriptorType, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted write update to texel buffer descriptor failed due to: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - break; - } - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - if (!ValidateBufferUpdate(update->pBufferInfo + di, update->descriptorType, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted write update to buffer descriptor failed due to: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - break; - } - default: - assert(0); // We've already verified update type so should never get here - break; - } - // All checks passed so update contents are good - return true; -} -// Verify that the contents of the update are ok, but don't perform actual update -bool cvdescriptorset::DescriptorSet::VerifyCopyUpdateContents(const VkCopyDescriptorSet *update, const DescriptorSet *src_set, - VkDescriptorType type, uint32_t index, - UNIQUE_VALIDATION_ERROR_CODE *error_code, - std::string *error_msg) const { - // Note : Repurposing some Write update error codes here as specific details aren't called out for copy updates like they are - // for write updates - switch (src_set->descriptors_[index]->descriptor_class) { - case PlainSampler: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - const auto src_desc = src_set->descriptors_[index + di].get(); - if (!src_desc->updated) continue; - if (!src_desc->IsImmutableSampler()) { - auto update_sampler = static_cast(src_desc)->GetSampler(); - if (!ValidateSampler(update_sampler, device_data_)) { - *error_code = VALIDATION_ERROR_15c0028a; - std::stringstream error_str; - error_str << "Attempted copy update to sampler descriptor with invalid sampler: " << update_sampler << "."; - *error_msg = error_str.str(); - return false; - } - } else { - // TODO : Warn here - } - } - break; - } - case ImageSampler: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - const auto src_desc = src_set->descriptors_[index + di].get(); - if (!src_desc->updated) continue; - auto img_samp_desc = static_cast(src_desc); - // First validate sampler - if (!img_samp_desc->IsImmutableSampler()) { - auto update_sampler = img_samp_desc->GetSampler(); - if (!ValidateSampler(update_sampler, device_data_)) { - *error_code = VALIDATION_ERROR_15c0028a; - std::stringstream error_str; - error_str << "Attempted copy update to sampler descriptor with invalid sampler: " << update_sampler << "."; - *error_msg = error_str.str(); - return false; - } - } else { - // TODO : Warn here - } - // Validate image - auto image_view = img_samp_desc->GetImageView(); - auto image_layout = img_samp_desc->GetImageLayout(); - if (!ValidateImageUpdate(image_view, image_layout, type, device_data_, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted copy update to combined image sampler descriptor failed due to: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - break; - } - case Image: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - const auto src_desc = src_set->descriptors_[index + di].get(); - if (!src_desc->updated) continue; - auto img_desc = static_cast(src_desc); - auto image_view = img_desc->GetImageView(); - auto image_layout = img_desc->GetImageLayout(); - if (!ValidateImageUpdate(image_view, image_layout, type, device_data_, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted copy update to image descriptor failed due to: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - break; - } - case TexelBuffer: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - const auto src_desc = src_set->descriptors_[index + di].get(); - if (!src_desc->updated) continue; - auto buffer_view = static_cast(src_desc)->GetBufferView(); - auto bv_state = GetBufferViewState(device_data_, buffer_view); - if (!bv_state) { - *error_code = VALIDATION_ERROR_15c00286; - std::stringstream error_str; - error_str << "Attempted copy update to texel buffer descriptor with invalid buffer view: " << buffer_view; - *error_msg = error_str.str(); - return false; - } - auto buffer = bv_state->create_info.buffer; - if (!ValidateBufferUsage(GetBufferState(device_data_, buffer), type, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted copy update to texel buffer descriptor failed due to: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - break; - } - case GeneralBuffer: { - for (uint32_t di = 0; di < update->descriptorCount; ++di) { - const auto src_desc = src_set->descriptors_[index + di].get(); - if (!src_desc->updated) continue; - auto buffer = static_cast(src_desc)->GetBuffer(); - if (!ValidateBufferUsage(GetBufferState(device_data_, buffer), type, error_code, error_msg)) { - std::stringstream error_str; - error_str << "Attempted copy update to buffer descriptor failed due to: " << error_msg->c_str(); - *error_msg = error_str.str(); - return false; - } - } - break; - } - default: - assert(0); // We've already verified update type so should never get here - break; - } - // All checks passed so update contents are good - return true; -} -// Update the common AllocateDescriptorSetsData -void cvdescriptorset::UpdateAllocateDescriptorSetsData(const layer_data *dev_data, const VkDescriptorSetAllocateInfo *p_alloc_info, - AllocateDescriptorSetsData *ds_data) { - for (uint32_t i = 0; i < p_alloc_info->descriptorSetCount; i++) { - auto layout = GetDescriptorSetLayout(dev_data, p_alloc_info->pSetLayouts[i]); - if (layout) { - ds_data->layout_nodes[i] = layout; - // Count total descriptors required per type - for (uint32_t j = 0; j < layout->GetBindingCount(); ++j) { - const auto &binding_layout = layout->GetDescriptorSetLayoutBindingPtrFromIndex(j); - uint32_t typeIndex = static_cast(binding_layout->descriptorType); - ds_data->required_descriptors_by_type[typeIndex] += binding_layout->descriptorCount; - } - } - // Any unknown layouts will be flagged as errors during ValidateAllocateDescriptorSets() call - } -} -// Verify that the state at allocate time is correct, but don't actually allocate the sets yet -bool cvdescriptorset::ValidateAllocateDescriptorSets(const core_validation::layer_data *dev_data, - const VkDescriptorSetAllocateInfo *p_alloc_info, - const AllocateDescriptorSetsData *ds_data) { - bool skip = false; - auto report_data = core_validation::GetReportData(dev_data); - auto pool_state = GetDescriptorPoolState(dev_data, p_alloc_info->descriptorPool); - - for (uint32_t i = 0; i < p_alloc_info->descriptorSetCount; i++) { - auto layout = GetDescriptorSetLayout(dev_data, p_alloc_info->pSetLayouts[i]); - if (layout) { // nullptr layout indicates no valid layout handle for this device, validated/logged in object_tracker - if (layout->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, - HandleToUint64(p_alloc_info->pSetLayouts[i]), VALIDATION_ERROR_04c00268, - "Layout 0x%" PRIxLEAST64 " specified at pSetLayouts[%" PRIu32 - "] in vkAllocateDescriptorSets() was created with invalid flag %s set.", - HandleToUint64(p_alloc_info->pSetLayouts[i]), i, - "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"); - } - if (layout->GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT && - !(pool_state->createInfo.flags & VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, - 0, VALIDATION_ERROR_04c017c8, - "Descriptor set layout create flags and pool create flags mismatch for index (%d)", i); - } - } - } - if (!GetDeviceExtensions(dev_data)->vk_khr_maintenance1) { - // Track number of descriptorSets allowable in this pool - if (pool_state->availableSets < p_alloc_info->descriptorSetCount) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - HandleToUint64(pool_state->pool), VALIDATION_ERROR_04c00264, - "Unable to allocate %u descriptorSets from pool 0x%" PRIxLEAST64 - ". This pool only has %d descriptorSets remaining.", - p_alloc_info->descriptorSetCount, HandleToUint64(pool_state->pool), pool_state->availableSets); - } - // Determine whether descriptor counts are satisfiable - for (uint32_t i = 0; i < VK_DESCRIPTOR_TYPE_RANGE_SIZE; i++) { - if (ds_data->required_descriptors_by_type[i] > pool_state->availableDescriptorTypeCount[i]) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - HandleToUint64(pool_state->pool), VALIDATION_ERROR_04c00266, - "Unable to allocate %u descriptors of type %s from pool 0x%" PRIxLEAST64 - ". This pool only has %d descriptors of this type remaining.", - ds_data->required_descriptors_by_type[i], string_VkDescriptorType(VkDescriptorType(i)), - HandleToUint64(pool_state->pool), pool_state->availableDescriptorTypeCount[i]); - } - } - } - - const auto *count_allocate_info = lvl_find_in_chain(p_alloc_info->pNext); - - if (count_allocate_info) { - if (count_allocate_info->descriptorSetCount != 0 && - count_allocate_info->descriptorSetCount != p_alloc_info->descriptorSetCount) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, 0, - VALIDATION_ERROR_46c017ca, - "VkDescriptorSetAllocateInfo::descriptorSetCount (%d) != " - "VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::descriptorSetCount (%d)", - p_alloc_info->descriptorSetCount, count_allocate_info->descriptorSetCount); - } - if (count_allocate_info->descriptorSetCount == p_alloc_info->descriptorSetCount) { - for (uint32_t i = 0; i < p_alloc_info->descriptorSetCount; i++) { - auto layout = GetDescriptorSetLayout(dev_data, p_alloc_info->pSetLayouts[i]); - if (count_allocate_info->pDescriptorCounts[i] > layout->GetDescriptorCountFromBinding(layout->GetMaxBinding())) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, 0, - VALIDATION_ERROR_46c017cc, "pDescriptorCounts[%d] = (%d), binding's descriptorCount = (%d)", i, - count_allocate_info->pDescriptorCounts[i], layout->GetDescriptorCountFromBinding(layout->GetMaxBinding())); - } - } - } - } - - return skip; -} -// Decrement allocated sets from the pool and insert new sets into set_map -void cvdescriptorset::PerformAllocateDescriptorSets(const VkDescriptorSetAllocateInfo *p_alloc_info, - const VkDescriptorSet *descriptor_sets, - const AllocateDescriptorSetsData *ds_data, - std::unordered_map *pool_map, - std::unordered_map *set_map, - layer_data *dev_data) { - auto pool_state = (*pool_map)[p_alloc_info->descriptorPool]; - // Account for sets and individual descriptors allocated from pool - pool_state->availableSets -= p_alloc_info->descriptorSetCount; - for (uint32_t i = 0; i < VK_DESCRIPTOR_TYPE_RANGE_SIZE; i++) { - pool_state->availableDescriptorTypeCount[i] -= ds_data->required_descriptors_by_type[i]; - } - - const auto *variable_count_info = lvl_find_in_chain(p_alloc_info->pNext); - bool variable_count_valid = variable_count_info && variable_count_info->descriptorSetCount == p_alloc_info->descriptorSetCount; - - // Create tracking object for each descriptor set; insert into global map and the pool's set. - for (uint32_t i = 0; i < p_alloc_info->descriptorSetCount; i++) { - uint32_t variable_count = variable_count_valid ? variable_count_info->pDescriptorCounts[i] : 0; - - auto new_ds = new cvdescriptorset::DescriptorSet(descriptor_sets[i], p_alloc_info->descriptorPool, ds_data->layout_nodes[i], - variable_count, dev_data); - - pool_state->sets.insert(new_ds); - new_ds->in_use.store(0); - (*set_map)[descriptor_sets[i]] = new_ds; - } -} - -cvdescriptorset::PrefilterBindRequestMap::PrefilterBindRequestMap(cvdescriptorset::DescriptorSet &ds, const BindingReqMap &in_map, - GLOBAL_CB_NODE *cb_state) - : filtered_map_(), orig_map_(in_map) { - if (ds.GetTotalDescriptorCount() > kManyDescriptors_) { - filtered_map_.reset(new std::map()); - ds.FilterAndTrackBindingReqs(cb_state, orig_map_, filtered_map_.get()); - } -} -cvdescriptorset::PrefilterBindRequestMap::PrefilterBindRequestMap(cvdescriptorset::DescriptorSet &ds, const BindingReqMap &in_map, - GLOBAL_CB_NODE *cb_state, PIPELINE_STATE *pipeline) - : filtered_map_(), orig_map_(in_map) { - if (ds.GetTotalDescriptorCount() > kManyDescriptors_) { - filtered_map_.reset(new std::map()); - ds.FilterAndTrackBindingReqs(cb_state, pipeline, orig_map_, filtered_map_.get()); - } -} diff --git a/layers/descriptor_sets.h b/layers/descriptor_sets.h deleted file mode 100644 index 8e90b0d2..00000000 --- a/layers/descriptor_sets.h +++ /dev/null @@ -1,581 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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 - * John Zulauf - */ -#ifndef CORE_VALIDATION_DESCRIPTOR_SETS_H_ -#define CORE_VALIDATION_DESCRIPTOR_SETS_H_ - -#include "core_validation_error_enums.h" -#include "vk_validation_error_messages.h" -#include "core_validation_types.h" -#include "hash_vk_types.h" -#include "vk_layer_logging.h" -#include "vk_layer_utils.h" -#include "vk_safe_struct.h" -#include "vulkan/vk_layer.h" -#include "vk_object_types.h" -#include -#include -#include -#include -#include -#include - -using core_validation::layer_data; - -// Descriptor Data structures -namespace cvdescriptorset { - -// Utility structs/classes/types -// Index range for global indices below, end is exclusive, i.e. [start,end) -struct IndexRange { - IndexRange(uint32_t start_in, uint32_t end_in) : start(start_in), end(end_in) {} - IndexRange() = default; - uint32_t start; - uint32_t end; -}; -typedef std::map BindingReqMap; - -/* - * DescriptorSetLayoutDef/DescriptorSetLayout classes - * - * Overview - These two classes encapsulate the Vulkan VkDescriptorSetLayout data (layout). - * A layout consists of some number of bindings, each of which has a binding#, a - * type, descriptor count, stage flags, and pImmutableSamplers. - - * The DescriptorSetLayoutDef represents a canonicalization of the input data and contains - * neither per handle or per device state. It is possible for different handles on - * different devices to share a common def. This is used and useful for quick compatibiltiy - * validation. The DescriptorSetLayout refers to a DescriptorSetLayoutDef and contains - * all per handle state. - * - * Index vs Binding - A layout is created with an array of VkDescriptorSetLayoutBinding - * where each array index will have a corresponding binding# that is defined in that struct. - * The binding#, then, is decoupled from VkDescriptorSetLayoutBinding index, which allows - * bindings to be defined out-of-order. This DescriptorSetLayout class, however, stores - * the bindings internally in-order. This is useful for operations which may "roll over" - * from a single binding to the next consecutive binding. - * - * Note that although the bindings are stored in-order, there still may be "gaps" in the - * binding#. For example, if the binding creation order is 8, 7, 10, 3, 4, then the - * internal binding array will have five entries stored in binding order 3, 4, 7, 8, 10. - * To process all of the bindings in a layout you can iterate from 0 to GetBindingCount() - * and use the Get*FromIndex() functions for each index. To just process a single binding, - * use the Get*FromBinding() functions. - * - * Global Index - The binding vector index has as many indices as there are bindings. - * This class also has the concept of a Global Index. For the global index functions, - * there are as many global indices as there are descriptors in the layout. - * For the global index, consider all of the bindings to be a flat array where - * descriptor 0 of of the lowest binding# is index 0 and each descriptor in the layout - * increments from there. So if the lowest binding# in this example had descriptorCount of - * 10, then the GlobalStartIndex of the 2nd lowest binding# will be 10 where 0-9 are the - * global indices for the lowest binding#. - */ -class DescriptorSetLayoutDef { - public: - // Constructors and destructor - DescriptorSetLayoutDef(const VkDescriptorSetLayoutCreateInfo *p_create_info); - size_t hash() const; - - uint32_t GetTotalDescriptorCount() const { return descriptor_count_; }; - uint32_t GetDynamicDescriptorCount() const { return dynamic_descriptor_count_; }; - VkDescriptorSetLayoutCreateFlags GetCreateFlags() const { return flags_; } - // For a given binding, return the number of descriptors in that binding and all successive bindings - uint32_t GetBindingCount() const { return binding_count_; }; - // Non-empty binding numbers in order - const std::set &GetSortedBindingSet() const { return non_empty_bindings_; } - // Return true if given binding is present in this layout - bool HasBinding(const uint32_t binding) const { return binding_to_index_map_.count(binding) > 0; }; - // Return true if this DSL Def (referenced by the 1st layout) is compatible with another DSL Def (ref'd from the 2nd layout) - // else return false and update error_msg with description of incompatibility - bool IsCompatible(VkDescriptorSetLayout, VkDescriptorSetLayout, DescriptorSetLayoutDef const *const, std::string *) const; - // Return true if binding 1 beyond given exists and has same type, stageFlags & immutable sampler use - bool IsNextBindingConsistent(const uint32_t) const; - uint32_t GetIndexFromBinding(uint32_t binding) const; - // Various Get functions that can either be passed a binding#, which will - // be automatically translated into the appropriate index, or the index# can be passed in directly - uint32_t GetMaxBinding() const { return bindings_[bindings_.size() - 1].binding; } - VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromIndex(const uint32_t) const; - VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromBinding(uint32_t binding) const { - return GetDescriptorSetLayoutBindingPtrFromIndex(GetIndexFromBinding(binding)); - } - const std::vector &GetBindings() const { return bindings_; } - uint32_t GetDescriptorCountFromIndex(const uint32_t) const; - uint32_t GetDescriptorCountFromBinding(const uint32_t binding) const { - return GetDescriptorCountFromIndex(GetIndexFromBinding(binding)); - } - VkDescriptorType GetTypeFromIndex(const uint32_t) const; - VkDescriptorType GetTypeFromBinding(const uint32_t binding) const { return GetTypeFromIndex(GetIndexFromBinding(binding)); } - VkShaderStageFlags GetStageFlagsFromIndex(const uint32_t) const; - VkShaderStageFlags GetStageFlagsFromBinding(const uint32_t binding) const { - return GetStageFlagsFromIndex(GetIndexFromBinding(binding)); - } - VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromIndex(const uint32_t) const; - VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromBinding(const uint32_t binding) const { - return GetDescriptorBindingFlagsFromIndex(GetIndexFromBinding(binding)); - } - uint32_t GetIndexFromGlobalIndex(const uint32_t global_index) const; - VkDescriptorType GetTypeFromGlobalIndex(const uint32_t global_index) const { - return GetTypeFromIndex(GetIndexFromGlobalIndex(global_index)); - } - VkSampler const *GetImmutableSamplerPtrFromBinding(const uint32_t) const; - VkSampler const *GetImmutableSamplerPtrFromIndex(const uint32_t) const; - // For a given binding and array index, return the corresponding index into the dynamic offset array - int32_t GetDynamicOffsetIndexFromBinding(uint32_t binding) const { - auto dyn_off = binding_to_dynamic_array_idx_map_.find(binding); - if (dyn_off == binding_to_dynamic_array_idx_map_.end()) { - assert(0); // Requesting dyn offset for invalid binding/array idx pair - return -1; - } - return dyn_off->second; - } - // For a particular binding, get the global index range - // This call should be guarded by a call to "HasBinding(binding)" to verify that the given binding exists - const IndexRange &GetGlobalIndexRangeFromBinding(const uint32_t) const; - - // Helper function to get the next valid binding for a descriptor - uint32_t GetNextValidBinding(const uint32_t) const; - // For a particular binding starting at offset and having update_count descriptors - // updated, verify that for any binding boundaries crossed, the update is consistent - bool VerifyUpdateConsistency(uint32_t, uint32_t, uint32_t, const char *, const VkDescriptorSet, std::string *) const; - bool IsPushDescriptor() const { return GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; }; - - struct BindingTypeStats { - uint32_t dynamic_buffer_count; - uint32_t non_dynamic_buffer_count; - uint32_t image_sampler_count; - }; - const BindingTypeStats &GetBindingTypeStats() const { return binding_type_stats_; } - - private: - // Only the first two data members are used for hash and equality checks, the other members are derived from them, and are used - // to speed up the various lookups/queries/validations - VkDescriptorSetLayoutCreateFlags flags_; - std::vector bindings_; - std::vector binding_flags_; - - // Convenience data structures for rapid lookup of various descriptor set layout properties - std::set non_empty_bindings_; // Containing non-emtpy bindings in numerical order - std::unordered_map binding_to_index_map_; - // The following map allows an non-iterative lookup of a binding from a global index... - std::map global_start_to_index_map_; // The index corresponding for a starting global (descriptor) index - std::unordered_map binding_to_global_index_range_map_; // range is exclusive of .end - // For a given binding map to associated index in the dynamic offset array - std::unordered_map binding_to_dynamic_array_idx_map_; - - uint32_t binding_count_; // # of bindings in this layout - uint32_t descriptor_count_; // total # descriptors in this layout - uint32_t dynamic_descriptor_count_; - BindingTypeStats binding_type_stats_; -}; - -static bool operator==(const DescriptorSetLayoutDef &lhs, const DescriptorSetLayoutDef &rhs) { - return (lhs.GetCreateFlags() == rhs.GetCreateFlags()) && (lhs.GetBindings() == rhs.GetBindings()); -} - -// Canonical dictionary of DSL definitions -- independent of device or handle -using DescriptorSetLayoutDict = hash_util::Dictionary>; -using DescriptorSetLayoutId = DescriptorSetLayoutDict::Id; - -class DescriptorSetLayout { - public: - // Constructors and destructor - DescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo *p_create_info, const VkDescriptorSetLayout layout); - // Validate create info - should be called prior to creation - static bool ValidateCreateInfo(const debug_report_data *, const VkDescriptorSetLayoutCreateInfo *, const bool, const uint32_t, - const bool, const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing_features); - bool HasBinding(const uint32_t binding) const { return layout_id_->HasBinding(binding); } - // Return true if this layout is compatible with passed in layout from a pipelineLayout, - // else return false and update error_msg with description of incompatibility - bool IsCompatible(DescriptorSetLayout const *const, std::string *) const; - // Straightforward Get functions - VkDescriptorSetLayout GetDescriptorSetLayout() const { return layout_; }; - bool IsDestroyed() const { return layout_destroyed_; } - void MarkDestroyed() { layout_destroyed_ = true; } - const DescriptorSetLayoutDef *get_layout_def() const { return layout_id_.get(); } - DescriptorSetLayoutId get_layout_id() const { return layout_id_; } - uint32_t GetTotalDescriptorCount() const { return layout_id_->GetTotalDescriptorCount(); }; - uint32_t GetDynamicDescriptorCount() const { return layout_id_->GetDynamicDescriptorCount(); }; - uint32_t GetBindingCount() const { return layout_id_->GetBindingCount(); }; - VkDescriptorSetLayoutCreateFlags GetCreateFlags() const { return layout_id_->GetCreateFlags(); } - bool IsNextBindingConsistent(const uint32_t) const; - uint32_t GetIndexFromBinding(uint32_t binding) const { return layout_id_->GetIndexFromBinding(binding); } - // Various Get functions that can either be passed a binding#, which will - // be automatically translated into the appropriate index, or the index# can be passed in directly - uint32_t GetMaxBinding() const { return layout_id_->GetMaxBinding(); } - VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromIndex(const uint32_t index) const { - return layout_id_->GetDescriptorSetLayoutBindingPtrFromIndex(index); - } - VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromBinding(uint32_t binding) const { - return layout_id_->GetDescriptorSetLayoutBindingPtrFromBinding(binding); - } - const std::vector &GetBindings() const { return layout_id_->GetBindings(); } - uint32_t GetDescriptorCountFromIndex(const uint32_t index) const { return layout_id_->GetDescriptorCountFromIndex(index); } - uint32_t GetDescriptorCountFromBinding(const uint32_t binding) const { - return layout_id_->GetDescriptorCountFromBinding(binding); - } - VkDescriptorType GetTypeFromIndex(const uint32_t index) const { return layout_id_->GetTypeFromIndex(index); } - VkDescriptorType GetTypeFromBinding(const uint32_t binding) const { return layout_id_->GetTypeFromBinding(binding); } - VkShaderStageFlags GetStageFlagsFromIndex(const uint32_t index) const { return layout_id_->GetStageFlagsFromIndex(index); } - VkShaderStageFlags GetStageFlagsFromBinding(const uint32_t binding) const { - return layout_id_->GetStageFlagsFromBinding(binding); - } - VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromIndex(const uint32_t index) const { - return layout_id_->GetDescriptorBindingFlagsFromIndex(index); - } - VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromBinding(const uint32_t binding) const { - return layout_id_->GetDescriptorBindingFlagsFromBinding(binding); - } - uint32_t GetIndexFromGlobalIndex(const uint32_t global_index) const { - return layout_id_->GetIndexFromGlobalIndex(global_index); - } - VkDescriptorType GetTypeFromGlobalIndex(const uint32_t global_index) const { - return GetTypeFromIndex(GetIndexFromGlobalIndex(global_index)); - } - VkSampler const *GetImmutableSamplerPtrFromBinding(const uint32_t binding) const { - return layout_id_->GetImmutableSamplerPtrFromBinding(binding); - } - VkSampler const *GetImmutableSamplerPtrFromIndex(const uint32_t index) const { - return layout_id_->GetImmutableSamplerPtrFromIndex(index); - } - // For a given binding and array index, return the corresponding index into the dynamic offset array - int32_t GetDynamicOffsetIndexFromBinding(uint32_t binding) const { - return layout_id_->GetDynamicOffsetIndexFromBinding(binding); - } - // For a particular binding, get the global index range - // This call should be guarded by a call to "HasBinding(binding)" to verify that the given binding exists - const IndexRange &GetGlobalIndexRangeFromBinding(const uint32_t binding) const { - return layout_id_->GetGlobalIndexRangeFromBinding(binding); - } - // Helper function to get the next valid binding for a descriptor - uint32_t GetNextValidBinding(const uint32_t binding) const { return layout_id_->GetNextValidBinding(binding); } - // For a particular binding starting at offset and having update_count descriptors - // updated, verify that for any binding boundaries crossed, the update is consistent - bool VerifyUpdateConsistency(uint32_t current_binding, uint32_t offset, uint32_t update_count, const char *type, - const VkDescriptorSet set, std::string *error_msg) const { - return layout_id_->VerifyUpdateConsistency(current_binding, offset, update_count, type, set, error_msg); - } - bool IsPushDescriptor() const { return layout_id_->IsPushDescriptor(); } - - using BindingTypeStats = DescriptorSetLayoutDef::BindingTypeStats; - const BindingTypeStats &GetBindingTypeStats() const { return layout_id_->GetBindingTypeStats(); } - - private: - VkDescriptorSetLayout layout_; - bool layout_destroyed_; - DescriptorSetLayoutId layout_id_; -}; - -/* - * Descriptor classes - * Descriptor is an abstract base class from which 5 separate descriptor types are derived. - * This allows the WriteUpdate() and CopyUpdate() operations to be specialized per - * descriptor type, but all descriptors in a set can be accessed via the common Descriptor*. - */ - -// Slightly broader than type, each c++ "class" will has a corresponding "DescriptorClass" -enum DescriptorClass { PlainSampler, ImageSampler, Image, TexelBuffer, GeneralBuffer }; - -class Descriptor { - public: - virtual ~Descriptor(){}; - virtual void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) = 0; - virtual void CopyUpdate(const Descriptor *) = 0; - // Create binding between resources of this descriptor and given cb_node - virtual void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) = 0; - virtual DescriptorClass GetClass() const { return descriptor_class; }; - // Special fast-path check for SamplerDescriptors that are immutable - virtual bool IsImmutableSampler() const { return false; }; - // Check for dynamic descriptor type - virtual bool IsDynamic() const { return false; }; - // Check for storage descriptor type - virtual bool IsStorage() const { return false; }; - bool updated; // Has descriptor been updated? - DescriptorClass descriptor_class; -}; -// Shared helper functions - These are useful because the shared sampler image descriptor type -// performs common functions with both sampler and image descriptors so they can share their common functions -bool ValidateSampler(const VkSampler, const core_validation::layer_data *); -bool ValidateImageUpdate(VkImageView, VkImageLayout, VkDescriptorType, const core_validation::layer_data *, - UNIQUE_VALIDATION_ERROR_CODE *, std::string *); - -class SamplerDescriptor : public Descriptor { - public: - SamplerDescriptor(const VkSampler *); - void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override; - void CopyUpdate(const Descriptor *) override; - void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override; - virtual bool IsImmutableSampler() const override { return immutable_; }; - VkSampler GetSampler() const { return sampler_; } - - private: - // bool ValidateSampler(const VkSampler) const; - VkSampler sampler_; - bool immutable_; -}; - -class ImageSamplerDescriptor : public Descriptor { - public: - ImageSamplerDescriptor(const VkSampler *); - void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override; - void CopyUpdate(const Descriptor *) override; - void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override; - virtual bool IsImmutableSampler() const override { return immutable_; }; - VkSampler GetSampler() const { return sampler_; } - VkImageView GetImageView() const { return image_view_; } - VkImageLayout GetImageLayout() const { return image_layout_; } - - private: - VkSampler sampler_; - bool immutable_; - VkImageView image_view_; - VkImageLayout image_layout_; -}; - -class ImageDescriptor : public Descriptor { - public: - ImageDescriptor(const VkDescriptorType); - void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override; - void CopyUpdate(const Descriptor *) override; - void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override; - virtual bool IsStorage() const override { return storage_; } - VkImageView GetImageView() const { return image_view_; } - VkImageLayout GetImageLayout() const { return image_layout_; } - - private: - bool storage_; - VkImageView image_view_; - VkImageLayout image_layout_; -}; - -class TexelDescriptor : public Descriptor { - public: - TexelDescriptor(const VkDescriptorType); - void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override; - void CopyUpdate(const Descriptor *) override; - void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override; - virtual bool IsStorage() const override { return storage_; } - VkBufferView GetBufferView() const { return buffer_view_; } - - private: - VkBufferView buffer_view_; - bool storage_; -}; - -class BufferDescriptor : public Descriptor { - public: - BufferDescriptor(const VkDescriptorType); - void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override; - void CopyUpdate(const Descriptor *) override; - void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override; - virtual bool IsDynamic() const override { return dynamic_; } - virtual bool IsStorage() const override { return storage_; } - VkBuffer GetBuffer() const { return buffer_; } - VkDeviceSize GetOffset() const { return offset_; } - VkDeviceSize GetRange() const { return range_; } - - private: - bool storage_; - bool dynamic_; - VkBuffer buffer_; - VkDeviceSize offset_; - VkDeviceSize range_; -}; -// Structs to contain common elements that need to be shared between Validate* and Perform* calls below -struct AllocateDescriptorSetsData { - uint32_t required_descriptors_by_type[VK_DESCRIPTOR_TYPE_RANGE_SIZE]; - std::vector> layout_nodes; - AllocateDescriptorSetsData(uint32_t); -}; -// Helper functions for descriptor set functions that cross multiple sets -// "Validate" will make sure an update is ok without actually performing it -bool ValidateUpdateDescriptorSets(const debug_report_data *, const core_validation::layer_data *, uint32_t, - const VkWriteDescriptorSet *, uint32_t, const VkCopyDescriptorSet *); -// "Perform" does the update with the assumption that ValidateUpdateDescriptorSets() has passed for the given update -void PerformUpdateDescriptorSets(const core_validation::layer_data *, uint32_t, const VkWriteDescriptorSet *, uint32_t, - const VkCopyDescriptorSet *); -// Similar to PerformUpdateDescriptorSets, this function will do the same for updating via templates -void PerformUpdateDescriptorSetsWithTemplateKHR(layer_data *, VkDescriptorSet, std::unique_ptr const &, - const void *); -// Update the common AllocateDescriptorSetsData struct which can then be shared between Validate* and Perform* funcs below -void UpdateAllocateDescriptorSetsData(const layer_data *dev_data, const VkDescriptorSetAllocateInfo *, - AllocateDescriptorSetsData *); -// Validate that Allocation state is ok -bool ValidateAllocateDescriptorSets(const core_validation::layer_data *, const VkDescriptorSetAllocateInfo *, - const AllocateDescriptorSetsData *); -// Update state based on allocating new descriptorsets -void PerformAllocateDescriptorSets(const VkDescriptorSetAllocateInfo *, const VkDescriptorSet *, const AllocateDescriptorSetsData *, - std::unordered_map *, - std::unordered_map *, - core_validation::layer_data *); - -/* - * DescriptorSet class - * - * Overview - This class encapsulates the Vulkan VkDescriptorSet data (set). - * A set has an underlying layout which defines the bindings in the set and the - * types and numbers of descriptors in each descriptor slot. Most of the layout - * interfaces are exposed through identically-named functions in the set class. - * Please refer to the DescriptorSetLayout comment above for a description of - * index, binding, and global index. - * - * At construction a vector of Descriptor* is created with types corresponding to the - * layout. The primary operation performed on the descriptors is to update them - * via write or copy updates, and validate that the update contents are correct. - * In order to validate update contents, the DescriptorSet stores a bunch of ptrs - * to data maps where various Vulkan objects can be looked up. The management of - * those maps is performed externally. The set class relies on their contents to - * be correct at the time of update. - */ -class DescriptorSet : public BASE_NODE { - public: - DescriptorSet(const VkDescriptorSet, const VkDescriptorPool, const std::shared_ptr &, - uint32_t variable_count, core_validation::layer_data *); - ~DescriptorSet(); - // A number of common Get* functions that return data based on layout from which this set was created - uint32_t GetTotalDescriptorCount() const { return p_layout_->GetTotalDescriptorCount(); }; - uint32_t GetDynamicDescriptorCount() const { return p_layout_->GetDynamicDescriptorCount(); }; - uint32_t GetBindingCount() const { return p_layout_->GetBindingCount(); }; - VkDescriptorType GetTypeFromIndex(const uint32_t index) const { return p_layout_->GetTypeFromIndex(index); }; - VkDescriptorType GetTypeFromGlobalIndex(const uint32_t index) const { return p_layout_->GetTypeFromGlobalIndex(index); }; - VkDescriptorType GetTypeFromBinding(const uint32_t binding) const { return p_layout_->GetTypeFromBinding(binding); }; - uint32_t GetDescriptorCountFromIndex(const uint32_t index) const { return p_layout_->GetDescriptorCountFromIndex(index); }; - uint32_t GetDescriptorCountFromBinding(const uint32_t binding) const { - return p_layout_->GetDescriptorCountFromBinding(binding); - }; - // Return index into dynamic offset array for given binding - int32_t GetDynamicOffsetIndexFromBinding(uint32_t binding) const { - return p_layout_->GetDynamicOffsetIndexFromBinding(binding); - } - // Return true if given binding is present in this set - bool HasBinding(const uint32_t binding) const { return p_layout_->HasBinding(binding); }; - // Is this set compatible with the given layout? - bool IsCompatible(DescriptorSetLayout const *const, std::string *) const; - // For given bindings validate state at time of draw is correct, returning false on error and writing error details into string* - bool ValidateDrawState(const std::map &, const std::vector &, GLOBAL_CB_NODE *, - const char *caller, std::string *) const; - // For given set of bindings, add any buffers and images that will be updated to their respective unordered_sets & return number - // of objects inserted - uint32_t GetStorageUpdates(const std::map &, std::unordered_set *, - std::unordered_set *) const; - - // Descriptor Update functions. These functions validate state and perform update separately - // Validate contents of a WriteUpdate - bool ValidateWriteUpdate(const debug_report_data *, const VkWriteDescriptorSet *, UNIQUE_VALIDATION_ERROR_CODE *, - std::string *); - // Perform a WriteUpdate whose contents were just validated using ValidateWriteUpdate - void PerformWriteUpdate(const VkWriteDescriptorSet *); - // Validate contents of a CopyUpdate - bool ValidateCopyUpdate(const debug_report_data *, const VkCopyDescriptorSet *, const DescriptorSet *, - UNIQUE_VALIDATION_ERROR_CODE *, std::string *); - // Perform a CopyUpdate whose contents were just validated using ValidateCopyUpdate - void PerformCopyUpdate(const VkCopyDescriptorSet *, const DescriptorSet *); - - const std::shared_ptr GetLayout() const { return p_layout_; }; - VkDescriptorSet GetSet() const { return set_; }; - // Return unordered_set of all command buffers that this set is bound to - std::unordered_set GetBoundCmdBuffers() const { return cb_bindings; } - // Bind given cmd_buffer to this descriptor set - void BindCommandBuffer(GLOBAL_CB_NODE *, const std::map &); - - // Track work that has been bound or validated to avoid duplicate work, important when large descriptor arrays - // are present - typedef std::unordered_set TrackedBindings; - static void FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, const BindingReqMap &in_req, - BindingReqMap *out_req, TrackedBindings *set); - static void FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, const BindingReqMap &in_req, - BindingReqMap *out_req, TrackedBindings *set, uint32_t limit); - void FilterAndTrackBindingReqs(GLOBAL_CB_NODE *, const BindingReqMap &in_req, BindingReqMap *out_req); - void FilterAndTrackBindingReqs(GLOBAL_CB_NODE *, PIPELINE_STATE *, const BindingReqMap &in_req, BindingReqMap *out_req); - void ClearCachedDynamicDescriptorValidation(GLOBAL_CB_NODE *cb_state) { cached_validation_[cb_state].dynamic_buffers.clear(); } - void ClearCachedValidation(GLOBAL_CB_NODE *cb_state) { cached_validation_.erase(cb_state); } - // If given cmd_buffer is in the cb_bindings set, remove it - void RemoveBoundCommandBuffer(GLOBAL_CB_NODE *cb_node) { - cb_bindings.erase(cb_node); - ClearCachedValidation(cb_node); - } - VkSampler const *GetImmutableSamplerPtrFromBinding(const uint32_t index) const { - return p_layout_->GetImmutableSamplerPtrFromBinding(index); - }; - // For a particular binding, get the global index - const IndexRange &GetGlobalIndexRangeFromBinding(const uint32_t binding) const { - return p_layout_->GetGlobalIndexRangeFromBinding(binding); - }; - // Return true if any part of set has ever been updated - bool IsUpdated() const { return some_update_; }; - bool IsPushDescriptor() const { return p_layout_->IsPushDescriptor(); }; - bool IsVariableDescriptorCount(uint32_t binding) const { - return !!(p_layout_->GetDescriptorBindingFlagsFromBinding(binding) & - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT); - } - uint32_t GetVariableDescriptorCount() const { return variable_count_; } - DESCRIPTOR_POOL_STATE *GetPoolState() const { return pool_state_; } - - private: - bool VerifyWriteUpdateContents(const VkWriteDescriptorSet *, const uint32_t, UNIQUE_VALIDATION_ERROR_CODE *, - std::string *) const; - bool VerifyCopyUpdateContents(const VkCopyDescriptorSet *, const DescriptorSet *, VkDescriptorType, uint32_t, - UNIQUE_VALIDATION_ERROR_CODE *, std::string *) const; - bool ValidateBufferUsage(BUFFER_STATE const *, VkDescriptorType, UNIQUE_VALIDATION_ERROR_CODE *, std::string *) const; - bool ValidateBufferUpdate(VkDescriptorBufferInfo const *, VkDescriptorType, UNIQUE_VALIDATION_ERROR_CODE *, - std::string *) const; - // Private helper to set all bound cmd buffers to INVALID state - void InvalidateBoundCmdBuffers(); - bool some_update_; // has any part of the set ever been updated? - VkDescriptorSet set_; - DESCRIPTOR_POOL_STATE *pool_state_; - const std::shared_ptr p_layout_; - std::vector> descriptors_; - // Ptr to device data used for various data look-ups - core_validation::layer_data *const device_data_; - const VkPhysicalDeviceLimits limits_; - uint32_t variable_count_; - - // Cached binding and validation support: - // - // For the lifespan of a given command buffer recording, do lazy evaluation, caching, and dirtying of - // expensive validation operation (typically per-draw) - typedef std::unordered_map TrackedBindingMap; - typedef std::unordered_map ValidatedBindings; - // Track the validation caching of bindings vs. the command buffer and draw state - typedef std::unordered_map VersionedBindings; - struct CachedValidation { - TrackedBindings command_binding_and_usage; // Persistent for the life of the recording - TrackedBindings non_dynamic_buffers; // Persistent for the life of the recording - TrackedBindings dynamic_buffers; // Dirtied (flushed) each BindDescriptorSet - std::unordered_map image_samplers; // Tested vs. changes to CB's ImageLayout - }; - typedef std::unordered_map CachedValidationMap; - // Image and ImageView bindings are validated per pipeline and not invalidate by repeated binding - CachedValidationMap cached_validation_; -}; -// For the "bindless" style resource usage with many descriptors, need to optimize binding and validation -class PrefilterBindRequestMap { - public: - static const uint32_t kManyDescriptors_ = 64; // TODO base this number on measured data - std::unique_ptr filtered_map_; - const BindingReqMap &orig_map_; - - PrefilterBindRequestMap(DescriptorSet &ds, const BindingReqMap &in_map, GLOBAL_CB_NODE *cb_state); - PrefilterBindRequestMap(DescriptorSet &ds, const BindingReqMap &in_map, GLOBAL_CB_NODE *cb_state, PIPELINE_STATE *); - const BindingReqMap &Map() const { return (filtered_map_) ? *filtered_map_ : orig_map_; } -}; -} // namespace cvdescriptorset -#endif // CORE_VALIDATION_DESCRIPTOR_SETS_H_ diff --git a/layers/hash_util.h b/layers/hash_util.h deleted file mode 100644 index ea31231f..00000000 --- a/layers/hash_util.h +++ /dev/null @@ -1,164 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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: John Zulauf - */ -#ifndef HASH_UTIL_H_ -#define HASH_UTIL_H_ - -#define NOMINMAX -#include -#include -#include -#include -#include -#include -#include -#include - -// Hash and equality utilities for supporting hashing containers (e.g. unordered_set, unordered_map) -namespace hash_util { - -// True iff both pointers are null or both are non-null -template -bool similar_for_nullity(const T *const lhs, const T *const rhs) { - return ((lhs != nullptr) && (rhs != nullptr)) || ((lhs == nullptr) && (rhs == nullptr)); -} - -// Wrap std hash to avoid manual casts for the holes in std::hash (in C++11) -template -size_t HashWithUnderlying(Value value, typename std::enable_if::value, void *>::type = nullptr) { - return std::hash()(value); -} - -template -size_t HashWithUnderlying(Value value, typename std::enable_if::value, void *>::type = nullptr) { - using Underlying = typename std::underlying_type::type; - return std::hash()(static_cast(value)); -} - -class HashCombiner { - public: - using Key = size_t; - - template - struct WrappedHash { - size_t operator()(const Value &value) const { return HashWithUnderlying(value); } - }; - - HashCombiner(Key combined = 0) : combined_(combined) {} - // magic and combination algorithm based on boost::hash_combine - // http://www.boost.org/doc/libs/1_43_0/doc/html/hash/reference.html#boost.hash_combine - // Magic value is 2^size / ((1-sqrt(5)/2) - static const uint64_t kMagic = sizeof(Key) > 4 ? Key(0x9e3779b97f4a7c16UL) : Key(0x9e3779b9U); - - // If you need to override the default hash - template > - HashCombiner &Combine(const Value &value) { - combined_ ^= Hasher()(value) + kMagic + (combined_ << 6) + (combined_ >> 2); - return *this; - } - - template ::value_type>> - HashCombiner &Combine(Iterator first, Iterator end) { - using Value = typename std::iterator_traits::value_type; - auto current = first; - for (; current != end; ++current) { - Combine(*current); - } - return *this; - } - - template > - HashCombiner &Combine(const std::vector &vector) { - return Combine(vector.cbegin(), vector.cend()); - } - - template - HashCombiner &operator<<(const Value &value) { - return Combine(value); - } - - Key Value() const { return combined_; } - void Reset(Key combined = 0) { combined_ = combined; } - - private: - Key combined_; -}; - -// A template to inherit std::hash overloads from when T::hash() is defined -template -struct HasHashMember { - size_t operator()(const T &value) const { return value.hash(); } -}; - -// A template to inherit std::hash overloads from when is an *ordered* constainer -template -struct IsOrderedContainer { - size_t operator()(const T &value) const { return HashCombiner().Combine(value.cbegin(), value.cend()).Value(); } -}; - -// The dictionary provides a way of referencing canonical/reference -// data by id, such that the id's are invariant with dictionary -// resize/insert and that no entries point to identical data. This -// approach uses the address of the unique data and as the unique -// ID for a give value of T. -// -// Note: This ID is unique for a given application execution, neither -// globally unique, invariant, nor repeatable from execution to -// execution. -// -// The entries of the dictionary are shared_pointers (the contents of -// which are invariant with resize/insert), with the hash and equality -// template arguments wrapped in a shared pointer dereferencing -// function object -template , typename KeyEqual = std::equal_to> -class Dictionary { - public: - using Def = T; - using Id = std::shared_ptr; - - // Find the unique entry match the provided value, adding if needed - // TODO: segregate lookup from insert, using reader/write locks to reduce contention -- if needed - template - Id look_up(U &&value) { - // We create an Id from the value, which will either be retained by dict (if new) or deleted on return (if extant) - Id from_input = std::make_shared(std::forward(value)); - - // Insert takes care of the "unique" id part by rejecting the insert if a key matching by_value exists, but returning us - // the Id of the extant shared_pointer(id->def) instead. - // return the value of the Iterator from the pair returned by insert - Guard g(lock); // Dict isn't thread safe, and use is presumed to be multi-threaded - return *dict.insert(from_input).first; - } - - private: - struct HashKeyValue { - size_t operator()(const Id &value) const { return Hasher()(*value); } - }; - struct KeyValueEqual { - bool operator()(const Id &lhs, const Id &rhs) const { return KeyEqual()(*lhs, *rhs); } - }; - using Dict = std::unordered_set; - using Lock = std::mutex; - using Guard = std::lock_guard; - Lock lock; - Dict dict; -}; -} // namespace hash_util - -#endif // HASH_UTILS_H_ diff --git a/layers/hash_vk_types.h b/layers/hash_vk_types.h deleted file mode 100644 index b6d67136..00000000 --- a/layers/hash_vk_types.h +++ /dev/null @@ -1,86 +0,0 @@ -/* Copyright (c) 2018 The Khronos Group Inc. - * Copyright (c) 2018 Valve Corporation - * Copyright (c) 2018 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: John Zulauf - */ -#ifndef HASH_VK_TYPES_H_ -#define HASH_VK_TYPES_H_ - -// Includes everything needed for overloading std::hash -#include "hash_util.h" - -#include -#include "vk_safe_struct.h" -#include - -// Hash and equality and/or compare functions for selected Vk types (and useful collections thereof) - -// VkDescriptorSetLayoutBinding -static bool operator==(const safe_VkDescriptorSetLayoutBinding &lhs, const safe_VkDescriptorSetLayoutBinding &rhs) { - if ((lhs.binding != rhs.binding) || (lhs.descriptorType != rhs.descriptorType) || - (lhs.descriptorCount != rhs.descriptorCount) || (lhs.stageFlags != rhs.stageFlags) || - !hash_util::similar_for_nullity(lhs.pImmutableSamplers, rhs.pImmutableSamplers)) { - return false; - } - if (lhs.pImmutableSamplers) { // either one will do as they *are* similar for nullity (i.e. either both null or both non-null) - for (uint32_t samp = 0; samp < lhs.descriptorCount; samp++) { - if (lhs.pImmutableSamplers[samp] != rhs.pImmutableSamplers[samp]) { - return false; - } - } - } - return true; -} - -namespace std { -template <> -struct hash { - size_t operator()(const safe_VkDescriptorSetLayoutBinding &value) const { - hash_util::HashCombiner hc; - hc << value.binding << value.descriptorType << value.descriptorCount << value.stageFlags; - if (value.pImmutableSamplers) { - for (uint32_t samp = 0; samp < value.descriptorCount; samp++) { - hc << value.pImmutableSamplers[samp]; - } - } - return hc.Value(); - } -}; -} // namespace std - -// VkPushConstantRange -static bool operator==(const VkPushConstantRange &lhs, const VkPushConstantRange &rhs) { - return (lhs.stageFlags == rhs.stageFlags) && (lhs.offset == rhs.offset) && (lhs.size == rhs.size); -} - -namespace std { -template <> -struct hash { - size_t operator()(const VkPushConstantRange &value) const { - hash_util::HashCombiner hc; - return (hc << value.stageFlags << value.offset << value.size).Value(); - } -}; -} // namespace std - -using PushConstantRanges = std::vector; - -namespace std { -template <> -struct hash : public hash_util::IsOrderedContainer {}; -} // namespace std - -#endif // HASH_VK_TYPES_H_ diff --git a/layers/linux/VkLayer_core_validation.json b/layers/linux/VkLayer_core_validation.json deleted file mode 100644 index 19ed3d5f..00000000 --- a/layers/linux/VkLayer_core_validation.json +++ /dev/null @@ -1,43 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_core_validation", - "type": "GLOBAL", - "library_path": "./libVkLayer_core_validation.so", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - }, - { - "name": "VK_EXT_validation_cache", - "spec_version": "1", - "entrypoints": ["vkCreateValidationCacheEXT", - "vkDestroyValidationCacheEXT", - "vkGetValidationCacheDataEXT", - "vkMergeValidationCachesEXT" - ] - } - ] - } -} - - - - - diff --git a/layers/linux/VkLayer_object_tracker.json b/layers/linux/VkLayer_object_tracker.json deleted file mode 100644 index c09b3e0e..00000000 --- a/layers/linux/VkLayer_object_tracker.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_object_tracker", - "type": "GLOBAL", - "library_path": "./libVkLayer_object_tracker.so", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - } - ] - } -} diff --git a/layers/linux/VkLayer_parameter_validation.json b/layers/linux/VkLayer_parameter_validation.json deleted file mode 100644 index f4b6bc60..00000000 --- a/layers/linux/VkLayer_parameter_validation.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_parameter_validation", - "type": "GLOBAL", - "library_path": "./libVkLayer_parameter_validation.so", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - } - ] - } -} diff --git a/layers/linux/VkLayer_standard_validation.json b/layers/linux/VkLayer_standard_validation.json deleted file mode 100644 index 6b752730..00000000 --- a/layers/linux/VkLayer_standard_validation.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "file_format_version": "1.1.1", - "layer": { - "name": "VK_LAYER_LUNARG_standard_validation", - "type": "GLOBAL", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Standard Validation", - "component_layers": [ - "VK_LAYER_GOOGLE_threading", - "VK_LAYER_LUNARG_parameter_validation", - "VK_LAYER_LUNARG_object_tracker", - "VK_LAYER_LUNARG_core_validation", - "VK_LAYER_GOOGLE_unique_objects" - ] - } -} diff --git a/layers/linux/VkLayer_threading.json b/layers/linux/VkLayer_threading.json deleted file mode 100644 index de22b236..00000000 --- a/layers/linux/VkLayer_threading.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_GOOGLE_threading", - "type": "GLOBAL", - "library_path": "./libVkLayer_threading.so", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "Google Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ] - } -} diff --git a/layers/linux/VkLayer_unique_objects.json b/layers/linux/VkLayer_unique_objects.json deleted file mode 100644 index 330a08e4..00000000 --- a/layers/linux/VkLayer_unique_objects.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_GOOGLE_unique_objects", - "type": "GLOBAL", - "library_path": "./libVkLayer_unique_objects.so", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "Google Validation Layer" - } -} diff --git a/layers/macos/VkLayer_core_validation.json b/layers/macos/VkLayer_core_validation.json deleted file mode 100644 index 8c3d81bd..00000000 --- a/layers/macos/VkLayer_core_validation.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_core_validation", - "type": "GLOBAL", - "library_path": "./libVkLayer_core_validation.dylib", - "api_version": "1.0.69", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - } - ] - } -} diff --git a/layers/macos/VkLayer_device_simulation.json b/layers/macos/VkLayer_device_simulation.json deleted file mode 100644 index b2eada69..00000000 --- a/layers/macos/VkLayer_device_simulation.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_device_simulation", - "type": "GLOBAL", - "library_path": "./libVkLayer_device_simulation.dylib", - "api_version": "1.0.69", - "implementation_version": "1.2.0", - "description": "LunarG device simulation layer" - } -} diff --git a/layers/macos/VkLayer_object_tracker.json b/layers/macos/VkLayer_object_tracker.json deleted file mode 100644 index ba846036..00000000 --- a/layers/macos/VkLayer_object_tracker.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_object_tracker", - "type": "GLOBAL", - "library_path": "./libVkLayer_object_tracker.dylib", - "api_version": "1.0.69", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - } - ] - } -} diff --git a/layers/macos/VkLayer_parameter_validation.json b/layers/macos/VkLayer_parameter_validation.json deleted file mode 100644 index 579324af..00000000 --- a/layers/macos/VkLayer_parameter_validation.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_parameter_validation", - "type": "GLOBAL", - "library_path": "./libVkLayer_parameter_validation.dylib", - "api_version": "1.0.69", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - } - ] - } -} diff --git a/layers/macos/VkLayer_standard_validation.json b/layers/macos/VkLayer_standard_validation.json deleted file mode 100644 index 1be9feed..00000000 --- a/layers/macos/VkLayer_standard_validation.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "file_format_version": "1.1.1", - "layer": { - "name": "VK_LAYER_LUNARG_standard_validation", - "type": "GLOBAL", - "api_version": "1.0.69", - "implementation_version": "1", - "description": "LunarG Standard Validation", - "component_layers": [ - "VK_LAYER_GOOGLE_threading", - "VK_LAYER_LUNARG_parameter_validation", - "VK_LAYER_LUNARG_object_tracker", - "VK_LAYER_LUNARG_core_validation", - "VK_LAYER_GOOGLE_unique_objects" - ] - } -} diff --git a/layers/macos/VkLayer_threading.json b/layers/macos/VkLayer_threading.json deleted file mode 100644 index d6af6c04..00000000 --- a/layers/macos/VkLayer_threading.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_GOOGLE_threading", - "type": "GLOBAL", - "library_path": "./libVkLayer_threading.dylib", - "api_version": "1.0.69", - "implementation_version": "1", - "description": "Google Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ] - } -} diff --git a/layers/macos/VkLayer_unique_objects.json b/layers/macos/VkLayer_unique_objects.json deleted file mode 100644 index 63c53064..00000000 --- a/layers/macos/VkLayer_unique_objects.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_GOOGLE_unique_objects", - "type": "GLOBAL", - "library_path": "./libVkLayer_unique_objects.dylib", - "api_version": "1.0.69", - "implementation_version": "1", - "description": "Google Validation Layer" - } -} diff --git a/layers/object_tracker.h b/layers/object_tracker.h deleted file mode 100644 index 48ac9fae..00000000 --- a/layers/object_tracker.h +++ /dev/null @@ -1,296 +0,0 @@ -/* 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: Jon Ashburn - * Author: Tobin Ehlis - */ - -#include -#include -#include -#include -#include -#include - -#include "vk_loader_platform.h" -#include "vulkan/vulkan.h" -#include "vk_layer_config.h" -#include "vk_layer_data.h" -#include "vk_layer_logging.h" -#include "vk_layer_table.h" -#include "vk_object_types.h" -#include "vulkan/vk_layer.h" -#include "vk_enum_string_helper.h" -#include "vk_layer_extension_utils.h" -#include "vk_layer_table.h" -#include "vk_layer_utils.h" -#include "vulkan/vk_layer.h" -#include "vk_dispatch_table_helper.h" -#include "vk_validation_error_messages.h" - -namespace object_tracker { - -// Object Tracker ERROR codes -enum ObjectTrackerError { - OBJTRACK_NONE, // Used for INFO & other non-error messages - OBJTRACK_UNKNOWN_OBJECT, // Updating uses of object that's not in global object list - OBJTRACK_INTERNAL_ERROR, // Bug with data tracking within the layer - OBJTRACK_OBJECT_LEAK, // OBJECT was not correctly freed/destroyed -}; - -// Object Status -- used to track state of individual objects -typedef VkFlags ObjectStatusFlags; -enum ObjectStatusFlagBits { - OBJSTATUS_NONE = 0x00000000, // No status is set - OBJSTATUS_FENCE_IS_SUBMITTED = 0x00000001, // Fence has been submitted - OBJSTATUS_VIEWPORT_BOUND = 0x00000002, // Viewport state object has been bound - OBJSTATUS_RASTER_BOUND = 0x00000004, // Viewport state object has been bound - OBJSTATUS_COLOR_BLEND_BOUND = 0x00000008, // Viewport state object has been bound - OBJSTATUS_DEPTH_STENCIL_BOUND = 0x00000010, // Viewport state object has been bound - OBJSTATUS_GPU_MEM_MAPPED = 0x00000020, // Memory object is currently mapped - OBJSTATUS_COMMAND_BUFFER_SECONDARY = 0x00000040, // Command Buffer is of type SECONDARY - OBJSTATUS_CUSTOM_ALLOCATOR = 0x00000080, // Allocated with custom allocator -}; - -// Object and state information structure -struct ObjTrackState { - uint64_t handle; // Object handle (new) - VulkanObjectType object_type; // Object type identifier - ObjectStatusFlags status; // Object state - uint64_t parent_object; // Parent object -}; - -// Track Queue information -struct ObjTrackQueueInfo { - uint32_t queue_node_index; - VkQueue queue; -}; - -typedef std::unordered_map object_map_type; - -struct layer_data { - VkInstance instance; - VkPhysicalDevice physical_device; - - uint64_t num_objects[kVulkanObjectTypeMax + 1]; - uint64_t num_total_objects; - - debug_report_data *report_data; - std::vector logging_callback; - std::vector logging_messenger; - // The following are for keeping track of the temporary callbacks that can - // be used in vkCreateInstance and vkDestroyInstance: - uint32_t num_tmp_report_callbacks; - VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos; - VkDebugReportCallbackEXT *tmp_report_callbacks; - uint32_t num_tmp_debug_messengers; - VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos; - VkDebugUtilsMessengerEXT *tmp_debug_messengers; - - std::vector queue_family_properties; - - // Vector of unordered_maps per object type to hold ObjTrackState info - std::vector object_map; - // Special-case map for swapchain images - std::unordered_map swapchainImageMap; - // Map of queue information structures, one per queue - std::unordered_map queue_info_map; - - VkLayerDispatchTable dispatch_table; - // Default constructor - layer_data() - : instance(nullptr), - physical_device(nullptr), - num_objects{}, - num_total_objects(0), - report_data(nullptr), - num_tmp_report_callbacks(0), - tmp_report_create_infos(nullptr), - tmp_report_callbacks(nullptr), - num_tmp_debug_messengers(0), - tmp_messenger_create_infos(nullptr), - tmp_debug_messengers(nullptr), - object_map{}, - dispatch_table{} { - object_map.resize(kVulkanObjectTypeMax + 1); - } -}; - -extern std::unordered_map layer_data_map; -extern device_table_map ot_device_table_map; -extern instance_table_map ot_instance_table_map; -extern std::mutex global_lock; -extern uint64_t object_track_index; -extern uint32_t loader_layer_if_version; -extern const std::unordered_map name_to_funcptr_map; - -void DeviceReportUndestroyedObjects(VkDevice device, VulkanObjectType object_type, enum UNIQUE_VALIDATION_ERROR_CODE error_code); -void DeviceDestroyUndestroyedObjects(VkDevice device, VulkanObjectType object_type); -void CreateQueue(VkDevice device, VkQueue vkObj); -void AddQueueInfo(VkDevice device, uint32_t queue_node_index, VkQueue queue); -void ValidateQueueFlags(VkQueue queue, const char *function); -void AllocateCommandBuffer(VkDevice device, const VkCommandPool command_pool, const VkCommandBuffer command_buffer, - VkCommandBufferLevel level); -void AllocateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set); -void CreateSwapchainImageObject(VkDevice dispatchable_object, VkImage swapchain_image, VkSwapchainKHR swapchain); -void ReportUndestroyedObjects(VkDevice device, UNIQUE_VALIDATION_ERROR_CODE error_code); -void DestroyUndestroyedObjects(VkDevice device); -bool ValidateDeviceObject(uint64_t device_handle, enum UNIQUE_VALIDATION_ERROR_CODE invalid_handle_code, - enum UNIQUE_VALIDATION_ERROR_CODE wrong_device_code); - -template -bool ValidateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, bool null_allowed, - enum UNIQUE_VALIDATION_ERROR_CODE invalid_handle_code, enum UNIQUE_VALIDATION_ERROR_CODE wrong_device_code) { - if (null_allowed && (object == VK_NULL_HANDLE)) { - return false; - } - auto object_handle = HandleToUint64(object); - - if (object_type == kVulkanObjectTypeDevice) { - return ValidateDeviceObject(object_handle, invalid_handle_code, wrong_device_code); - } - - VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type]; - - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map); - // Look for object in device object map - if (device_data->object_map[object_type].find(object_handle) == device_data->object_map[object_type].end()) { - // If object is an image, also look for it in the swapchain image map - if ((object_type != kVulkanObjectTypeImage) || - (device_data->swapchainImageMap.find(object_handle) == device_data->swapchainImageMap.end())) { - // Object not found, look for it in other device object maps - for (auto other_device_data : layer_data_map) { - if (other_device_data.second != device_data) { - if (other_device_data.second->object_map[object_type].find(object_handle) != - other_device_data.second->object_map[object_type].end() || - (object_type == kVulkanObjectTypeImage && other_device_data.second->swapchainImageMap.find(object_handle) != - other_device_data.second->swapchainImageMap.end())) { - // Object found on other device, report an error if object has a device parent error code - if ((wrong_device_code != VALIDATION_ERROR_UNDEFINED) && (object_type != kVulkanObjectTypeSurfaceKHR)) { - return log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, - object_handle, wrong_device_code, - "Object 0x%" PRIxLEAST64 - " was not created, allocated or retrieved from the correct device.", - object_handle); - } else { - return false; - } - } - } - } - // Report an error if object was not found anywhere - return log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle, - invalid_handle_code, "Invalid %s Object 0x%" PRIxLEAST64 ".", object_string[object_type], object_handle); - } - } - return false; -} - -template -void CreateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator) { - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map); - - auto object_handle = HandleToUint64(object); - bool custom_allocator = pAllocator != nullptr; - - if (!instance_data->object_map[object_type].count(object_handle)) { - VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type]; - log_msg(instance_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, debug_object_type, object_handle, OBJTRACK_NONE, - "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++, object_string[object_type], - object_handle); - - ObjTrackState *pNewObjNode = new ObjTrackState; - pNewObjNode->object_type = object_type; - pNewObjNode->status = custom_allocator ? OBJSTATUS_CUSTOM_ALLOCATOR : OBJSTATUS_NONE; - pNewObjNode->handle = object_handle; - - instance_data->object_map[object_type][object_handle] = pNewObjNode; - instance_data->num_objects[object_type]++; - instance_data->num_total_objects++; - } -} - -template -void DestroyObjectSilently(T1 dispatchable_object, T2 object, VulkanObjectType object_type) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map); - - auto object_handle = HandleToUint64(object); - assert(object_handle != VK_NULL_HANDLE); - - auto item = device_data->object_map[object_type].find(object_handle); - assert(item != device_data->object_map[object_type].end()); - - ObjTrackState *pNode = item->second; - assert(device_data->num_total_objects > 0); - - device_data->num_total_objects--; - assert(device_data->num_objects[pNode->object_type] > 0); - - device_data->num_objects[pNode->object_type]--; - - delete pNode; - device_data->object_map[object_type].erase(item); -} - -template -void DestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator, - enum UNIQUE_VALIDATION_ERROR_CODE expected_custom_allocator_code, - enum UNIQUE_VALIDATION_ERROR_CODE expected_default_allocator_code) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map); - - auto object_handle = HandleToUint64(object); - bool custom_allocator = pAllocator != nullptr; - VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type]; - - if (object_handle != VK_NULL_HANDLE) { - auto item = device_data->object_map[object_type].find(object_handle); - if (item != device_data->object_map[object_type].end()) { - ObjTrackState *pNode = item->second; - - log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, debug_object_type, object_handle, OBJTRACK_NONE, - "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", - object_string[object_type], HandleToUint64(object), device_data->num_total_objects - 1, - device_data->num_objects[pNode->object_type] - 1, object_string[object_type]); - - auto allocated_with_custom = (pNode->status & OBJSTATUS_CUSTOM_ALLOCATOR) ? true : false; - if (allocated_with_custom && !custom_allocator && expected_custom_allocator_code != VALIDATION_ERROR_UNDEFINED) { - // This check only verifies that custom allocation callbacks were provided to both Create and Destroy calls, - // it cannot verify that these allocation callbacks are compatible with each other. - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle, - expected_custom_allocator_code, - "Custom allocator not specified while destroying %s obj 0x%" PRIxLEAST64 " but specified at creation.", - object_string[object_type], object_handle); - } else if (!allocated_with_custom && custom_allocator && - expected_default_allocator_code != VALIDATION_ERROR_UNDEFINED) { - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle, - expected_default_allocator_code, - "Custom allocator specified while destroying %s obj 0x%" PRIxLEAST64 " but not specified at creation.", - object_string[object_type], object_handle); - } - - DestroyObjectSilently(dispatchable_object, object, object_type); - } else { - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, object_handle, - OBJTRACK_UNKNOWN_OBJECT, - "Unable to remove %s obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", - object_string[object_type], object_handle); - } - } -} - -} // namespace object_tracker diff --git a/layers/object_tracker_layer.md b/layers/object_tracker_layer.md deleted file mode 100644 index 4f64f467..00000000 --- a/layers/object_tracker_layer.md +++ /dev/null @@ -1,12 +0,0 @@ -# VK\_LAYER\_LUNARG\_object\_tracker -The `VK_LAYER_LUNARG_object_tracker` layer tracks all Vulkan objects. Object lifetimes are validated along with issues related to unknown objects and object destruction and cleanup. - -All Vulkan dispatchable and non-dispatchable objects are tracked by the `VK_LAYER_LUNARG_object_tracker` layer. - -This layer validates that: - - - only known objects are referenced and destroyed - - lookups are performed only on objects being tracked - - objects are correctly freed/destroyed. - -The `VK_LAYER_LUNARG_object_tracker` layer will print errors if validation checks are not correctly met and warnings if improper reference of objects is detected. diff --git a/layers/object_tracker_utils.cpp b/layers/object_tracker_utils.cpp deleted file mode 100644 index 26c5ff49..00000000 --- a/layers/object_tracker_utils.cpp +++ /dev/null @@ -1,1410 +0,0 @@ -/* 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: Jon Ashburn - * Author: Tobin Ehlis - */ - -#include "object_tracker.h" - -namespace object_tracker { - -std::unordered_map layer_data_map; -device_table_map ot_device_table_map; -instance_table_map ot_instance_table_map; -std::mutex global_lock; -uint64_t object_track_index = 0; -uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - -void InitObjectTracker(layer_data *my_data, const VkAllocationCallbacks *pAllocator) { - layer_debug_report_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_object_tracker"); - layer_debug_messenger_actions(my_data->report_data, my_data->logging_messenger, pAllocator, "lunarg_object_tracker"); -} - -// Add new queue to head of global queue list -void AddQueueInfo(VkDevice device, uint32_t queue_node_index, VkQueue queue) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - auto queueItem = device_data->queue_info_map.find(queue); - if (queueItem == device_data->queue_info_map.end()) { - ObjTrackQueueInfo *p_queue_info = new ObjTrackQueueInfo; - if (p_queue_info != NULL) { - memset(p_queue_info, 0, sizeof(ObjTrackQueueInfo)); - p_queue_info->queue = queue; - p_queue_info->queue_node_index = queue_node_index; - device_data->queue_info_map[queue] = p_queue_info; - } else { - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - HandleToUint64(queue), OBJTRACK_INTERNAL_ERROR, - "ERROR: VK_ERROR_OUT_OF_HOST_MEMORY -- could not allocate memory for Queue Information"); - } - } -} - -// Destroy memRef lists and free all memory -void DestroyQueueDataStructures(VkDevice device) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - for (auto queue_item : device_data->queue_info_map) { - delete queue_item.second; - } - device_data->queue_info_map.clear(); - - // Destroy the items in the queue map - auto queue = device_data->object_map[kVulkanObjectTypeQueue].begin(); - while (queue != device_data->object_map[kVulkanObjectTypeQueue].end()) { - uint32_t obj_index = queue->second->object_type; - assert(device_data->num_total_objects > 0); - device_data->num_total_objects--; - assert(device_data->num_objects[obj_index] > 0); - device_data->num_objects[obj_index]--; - log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - queue->second->handle, OBJTRACK_NONE, - "OBJ_STAT Destroy Queue obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " Queue objs).", - queue->second->handle, device_data->num_total_objects, device_data->num_objects[obj_index]); - delete queue->second; - queue = device_data->object_map[kVulkanObjectTypeQueue].erase(queue); - } -} - -// Check Queue type flags for selected queue operations -void ValidateQueueFlags(VkQueue queue, const char *function) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - auto queue_item = device_data->queue_info_map.find(queue); - if (queue_item != device_data->queue_info_map.end()) { - ObjTrackQueueInfo *pQueueInfo = queue_item->second; - if (pQueueInfo != NULL) { - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(device_data->physical_device), layer_data_map); - if ((instance_data->queue_family_properties[pQueueInfo->queue_node_index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) == - 0) { - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - HandleToUint64(queue), VALIDATION_ERROR_31600011, - "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not set.", function); - } - } - } -} - -// Look for this device object in any of the instance child devices lists. -// NOTE: This is of dubious value. In most circumstances Vulkan will die a flaming death if a dispatchable object is invalid. -// However, if this layer is loaded first and GetProcAddress is used to make API calls, it will detect bad DOs. -bool ValidateDeviceObject(uint64_t device_handle, enum UNIQUE_VALIDATION_ERROR_CODE invalid_handle_code, - enum UNIQUE_VALIDATION_ERROR_CODE wrong_device_code) { - VkInstance last_instance = nullptr; - for (auto layer_data : layer_data_map) { - for (auto object : layer_data.second->object_map[kVulkanObjectTypeDevice]) { - // Grab last instance to use for possible error message - last_instance = layer_data.second->instance; - if (object.second->handle == device_handle) return false; - } - } - - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(last_instance), layer_data_map); - return log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, device_handle, - invalid_handle_code, "Invalid Device Object 0x%" PRIxLEAST64 ".", device_handle); -} - -void AllocateCommandBuffer(VkDevice device, const VkCommandPool command_pool, const VkCommandBuffer command_buffer, - VkCommandBufferLevel level) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(command_buffer), OBJTRACK_NONE, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, - object_track_index++, "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT", HandleToUint64(command_buffer)); - - ObjTrackState *pNewObjNode = new ObjTrackState; - pNewObjNode->object_type = kVulkanObjectTypeCommandBuffer; - pNewObjNode->handle = HandleToUint64(command_buffer); - pNewObjNode->parent_object = HandleToUint64(command_pool); - if (level == VK_COMMAND_BUFFER_LEVEL_SECONDARY) { - pNewObjNode->status = OBJSTATUS_COMMAND_BUFFER_SECONDARY; - } else { - pNewObjNode->status = OBJSTATUS_NONE; - } - device_data->object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)] = pNewObjNode; - device_data->num_objects[kVulkanObjectTypeCommandBuffer]++; - device_data->num_total_objects++; -} - -bool ValidateCommandBuffer(VkDevice device, VkCommandPool command_pool, VkCommandBuffer command_buffer) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - uint64_t object_handle = HandleToUint64(command_buffer); - if (device_data->object_map[kVulkanObjectTypeCommandBuffer].find(object_handle) != - device_data->object_map[kVulkanObjectTypeCommandBuffer].end()) { - ObjTrackState *pNode = device_data->object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)]; - - if (pNode->parent_object != HandleToUint64(command_pool)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - object_handle, VALIDATION_ERROR_28411407, - "FreeCommandBuffers is attempting to free Command Buffer 0x%" PRIxLEAST64 - " belonging to Command Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").", - HandleToUint64(command_buffer), pNode->parent_object, HandleToUint64(command_pool)); - } - } else { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - object_handle, VALIDATION_ERROR_28400060, "Invalid %s Object 0x%" PRIxLEAST64 ".", - object_string[kVulkanObjectTypeCommandBuffer], object_handle); - } - return skip; -} - -void AllocateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - HandleToUint64(descriptor_set), OBJTRACK_NONE, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, - object_track_index++, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT", HandleToUint64(descriptor_set)); - - ObjTrackState *pNewObjNode = new ObjTrackState; - pNewObjNode->object_type = kVulkanObjectTypeDescriptorSet; - pNewObjNode->status = OBJSTATUS_NONE; - pNewObjNode->handle = HandleToUint64(descriptor_set); - pNewObjNode->parent_object = HandleToUint64(descriptor_pool); - device_data->object_map[kVulkanObjectTypeDescriptorSet][HandleToUint64(descriptor_set)] = pNewObjNode; - device_data->num_objects[kVulkanObjectTypeDescriptorSet]++; - device_data->num_total_objects++; -} - -bool ValidateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - uint64_t object_handle = HandleToUint64(descriptor_set); - auto dsItem = device_data->object_map[kVulkanObjectTypeDescriptorSet].find(object_handle); - if (dsItem != device_data->object_map[kVulkanObjectTypeDescriptorSet].end()) { - ObjTrackState *pNode = dsItem->second; - - if (pNode->parent_object != HandleToUint64(descriptor_pool)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - object_handle, VALIDATION_ERROR_28613007, - "FreeDescriptorSets is attempting to free descriptorSet 0x%" PRIxLEAST64 - " belonging to Descriptor Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").", - HandleToUint64(descriptor_set), pNode->parent_object, HandleToUint64(descriptor_pool)); - } - } else { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - object_handle, VALIDATION_ERROR_2860026c, "Invalid %s Object 0x%" PRIxLEAST64 ".", - object_string[kVulkanObjectTypeDescriptorSet], object_handle); - } - return skip; -} - -template -static bool ValidateDescriptorWrite(DispObj disp, VkWriteDescriptorSet const *desc, bool isPush) { - bool skip = false; - - if (!isPush && desc->dstSet) { - skip |= ValidateObject(disp, desc->dstSet, kVulkanObjectTypeDescriptorSet, false, VALIDATION_ERROR_15c00280, - VALIDATION_ERROR_15c00009); - } - - if ((desc->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || - (desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) { - for (uint32_t idx2 = 0; idx2 < desc->descriptorCount; ++idx2) { - skip |= ValidateObject(disp, desc->pTexelBufferView[idx2], kVulkanObjectTypeBufferView, false, - VALIDATION_ERROR_15c00286, VALIDATION_ERROR_15c00009); - } - } - - if ((desc->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || - (desc->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || (desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) || - (desc->descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) { - for (uint32_t idx3 = 0; idx3 < desc->descriptorCount; ++idx3) { - skip |= ValidateObject(disp, desc->pImageInfo[idx3].imageView, kVulkanObjectTypeImageView, false, - VALIDATION_ERROR_15c0028c, VALIDATION_ERROR_04600009); - } - } - - if ((desc->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || - (desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || - (desc->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || - (desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { - for (uint32_t idx4 = 0; idx4 < desc->descriptorCount; ++idx4) { - if (desc->pBufferInfo[idx4].buffer) { - skip |= ValidateObject(disp, desc->pBufferInfo[idx4].buffer, kVulkanObjectTypeBuffer, false, - VALIDATION_ERROR_04401a01, VALIDATION_ERROR_UNDEFINED); - } - } - } - - return skip; -} - -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites) { - bool skip = false; - { - std::lock_guard lock(global_lock); - skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1be02401, - VALIDATION_ERROR_1be00009); - skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_1be0be01, - VALIDATION_ERROR_1be00009); - if (pDescriptorWrites) { - for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) { - skip |= ValidateDescriptorWrite(commandBuffer, &pDescriptorWrites[index0], true); - } - } - } - if (skip) return; - get_dispatch_table(ot_device_table_map, commandBuffer) - ->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); -} - -void CreateQueue(VkDevice device, VkQueue vkObj) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - HandleToUint64(vkObj), OBJTRACK_NONE, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, - object_track_index++, "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT", HandleToUint64(vkObj)); - - ObjTrackState *p_obj_node = NULL; - auto queue_item = device_data->object_map[kVulkanObjectTypeQueue].find(HandleToUint64(vkObj)); - if (queue_item == device_data->object_map[kVulkanObjectTypeQueue].end()) { - p_obj_node = new ObjTrackState; - device_data->object_map[kVulkanObjectTypeQueue][HandleToUint64(vkObj)] = p_obj_node; - device_data->num_objects[kVulkanObjectTypeQueue]++; - device_data->num_total_objects++; - } else { - p_obj_node = queue_item->second; - } - p_obj_node->object_type = kVulkanObjectTypeQueue; - p_obj_node->status = OBJSTATUS_NONE; - p_obj_node->handle = HandleToUint64(vkObj); -} - -void CreateSwapchainImageObject(VkDevice dispatchable_object, VkImage swapchain_image, VkSwapchainKHR swapchain) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map); - log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - HandleToUint64(swapchain_image), OBJTRACK_NONE, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, - object_track_index++, "SwapchainImage", HandleToUint64(swapchain_image)); - - ObjTrackState *pNewObjNode = new ObjTrackState; - pNewObjNode->object_type = kVulkanObjectTypeImage; - pNewObjNode->status = OBJSTATUS_NONE; - pNewObjNode->handle = HandleToUint64(swapchain_image); - pNewObjNode->parent_object = HandleToUint64(swapchain); - device_data->swapchainImageMap[HandleToUint64(swapchain_image)] = pNewObjNode; -} - -void DeviceReportUndestroyedObjects(VkDevice device, VulkanObjectType object_type, enum UNIQUE_VALIDATION_ERROR_CODE error_code) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - for (const auto &item : device_data->object_map[object_type]) { - const ObjTrackState *object_info = item.second; - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[object_type], object_info->handle, - error_code, "OBJ ERROR : For device 0x%" PRIxLEAST64 ", %s object 0x%" PRIxLEAST64 " has not been destroyed.", - HandleToUint64(device), object_string[object_type], object_info->handle); - } -} - -void DeviceDestroyUndestroyedObjects(VkDevice device, VulkanObjectType object_type) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - while (!device_data->object_map[object_type].empty()) { - auto item = device_data->object_map[object_type].begin(); - - ObjTrackState *object_info = item->second; - DestroyObjectSilently(device, object_info->handle, object_type); - } -} - -VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - std::unique_lock lock(global_lock); - - dispatch_key key = get_dispatch_key(instance); - layer_data *instance_data = GetLayerDataPtr(key, layer_data_map); - - // Enable the temporary callback(s) here to catch cleanup issues: - if (instance_data->num_tmp_debug_messengers > 0) { - layer_enable_tmp_debug_messengers(instance_data->report_data, instance_data->num_tmp_debug_messengers, - instance_data->tmp_messenger_create_infos, instance_data->tmp_debug_messengers); - } - if (instance_data->num_tmp_report_callbacks > 0) { - layer_enable_tmp_report_callbacks(instance_data->report_data, instance_data->num_tmp_report_callbacks, - instance_data->tmp_report_create_infos, instance_data->tmp_report_callbacks); - } - - // TODO: The instance handle can not be validated here. The loader will likely have to validate it. - ValidateObject(instance, instance, kVulkanObjectTypeInstance, true, VALIDATION_ERROR_2580bc01, VALIDATION_ERROR_UNDEFINED); - - // Destroy physical devices - for (auto iit = instance_data->object_map[kVulkanObjectTypePhysicalDevice].begin(); - iit != instance_data->object_map[kVulkanObjectTypePhysicalDevice].end();) { - ObjTrackState *pNode = iit->second; - VkPhysicalDevice physical_device = reinterpret_cast(pNode->handle); - - DestroyObject(instance, physical_device, kVulkanObjectTypePhysicalDevice, nullptr, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - iit = instance_data->object_map[kVulkanObjectTypePhysicalDevice].begin(); - } - - // Destroy child devices - for (auto iit = instance_data->object_map[kVulkanObjectTypeDevice].begin(); - iit != instance_data->object_map[kVulkanObjectTypeDevice].end();) { - ObjTrackState *pNode = iit->second; - - VkDevice device = reinterpret_cast(pNode->handle); - VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[pNode->object_type]; - - log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, pNode->handle, OBJTRACK_OBJECT_LEAK, - "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", - string_VkDebugReportObjectTypeEXT(debug_object_type), pNode->handle); - - // Report any remaining objects in LL - ReportUndestroyedObjects(device, VALIDATION_ERROR_258004ea); - DestroyUndestroyedObjects(device); - - DestroyObject(instance, device, kVulkanObjectTypeDevice, pAllocator, VALIDATION_ERROR_258004ec, VALIDATION_ERROR_258004ee); - iit = instance_data->object_map[kVulkanObjectTypeDevice].begin(); - } - - instance_data->object_map[kVulkanObjectTypeDevice].clear(); - - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance); - pInstanceTable->DestroyInstance(instance, pAllocator); - - // Disable and cleanup the temporary callback(s): - layer_disable_tmp_debug_messengers(instance_data->report_data, instance_data->num_tmp_debug_messengers, - instance_data->tmp_debug_messengers); - layer_disable_tmp_report_callbacks(instance_data->report_data, instance_data->num_tmp_report_callbacks, - instance_data->tmp_report_callbacks); - if (instance_data->num_tmp_debug_messengers > 0) { - layer_free_tmp_debug_messengers(instance_data->tmp_messenger_create_infos, instance_data->tmp_debug_messengers); - instance_data->num_tmp_debug_messengers = 0; - } - if (instance_data->num_tmp_report_callbacks > 0) { - layer_free_tmp_report_callbacks(instance_data->tmp_report_create_infos, instance_data->tmp_report_callbacks); - instance_data->num_tmp_report_callbacks = 0; - } - - // Clean up logging callback, if any - while (instance_data->logging_messenger.size() > 0) { - VkDebugUtilsMessengerEXT messenger = instance_data->logging_messenger.back(); - layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator); - instance_data->logging_messenger.pop_back(); - } - while (instance_data->logging_callback.size() > 0) { - VkDebugReportCallbackEXT callback = instance_data->logging_callback.back(); - layer_destroy_report_callback(instance_data->report_data, callback, pAllocator); - instance_data->logging_callback.pop_back(); - } - - DestroyObject(instance, instance, kVulkanObjectTypeInstance, pAllocator, VALIDATION_ERROR_258004ec, VALIDATION_ERROR_258004ee); - - layer_debug_utils_destroy_instance(instance_data->report_data); - FreeLayerDataPtr(key, layer_data_map); - - lock.unlock(); - ot_instance_table_map.erase(key); - delete pInstanceTable; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { - std::unique_lock lock(global_lock); - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - ValidateObject(device, device, kVulkanObjectTypeDevice, true, VALIDATION_ERROR_24a05601, VALIDATION_ERROR_UNDEFINED); - DestroyObject(device_data->instance, device, kVulkanObjectTypeDevice, pAllocator, VALIDATION_ERROR_24a002f6, - VALIDATION_ERROR_24a002f8); - - // Report any remaining objects associated with this VkDevice object in LL - ReportUndestroyedObjects(device, VALIDATION_ERROR_24a002f4); - DestroyUndestroyedObjects(device); - - // Clean up Queue's MemRef Linked Lists - DestroyQueueDataStructures(device); - - lock.unlock(); - - dispatch_key key = get_dispatch_key(device); - VkLayerDispatchTable *pDisp = get_dispatch_table(ot_device_table_map, device); - pDisp->DestroyDevice(device, pAllocator); - ot_device_table_map.erase(key); - delete pDisp; - - FreeLayerDataPtr(key, layer_data_map); -} - -VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { - std::unique_lock lock(global_lock); - ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_29605601, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - - get_dispatch_table(ot_device_table_map, device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); - - lock.lock(); - CreateQueue(device, *pQueue); - AddQueueInfo(device, queueFamilyIndex, *pQueue); -} - -VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) { - std::unique_lock lock(global_lock); - ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_43405601, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - - get_dispatch_table(ot_device_table_map, device)->GetDeviceQueue2(device, pQueueInfo, pQueue); - - lock.lock(); - if (*pQueue != VK_NULL_HANDLE) { - CreateQueue(device, *pQueue); - AddQueueInfo(device, pQueueInfo->queueFamilyIndex, *pQueue); - } -} - -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, - const VkCopyDescriptorSet *pDescriptorCopies) { - bool skip = false; - { - std::lock_guard lock(global_lock); - skip |= - ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33c05601, VALIDATION_ERROR_UNDEFINED); - if (pDescriptorCopies) { - for (uint32_t idx0 = 0; idx0 < descriptorCopyCount; ++idx0) { - if (pDescriptorCopies[idx0].dstSet) { - skip |= ValidateObject(device, pDescriptorCopies[idx0].dstSet, kVulkanObjectTypeDescriptorSet, false, - VALIDATION_ERROR_03207601, VALIDATION_ERROR_03200009); - } - if (pDescriptorCopies[idx0].srcSet) { - skip |= ValidateObject(device, pDescriptorCopies[idx0].srcSet, kVulkanObjectTypeDescriptorSet, false, - VALIDATION_ERROR_0322d201, VALIDATION_ERROR_03200009); - } - } - } - if (pDescriptorWrites) { - for (uint32_t idx1 = 0; idx1 < descriptorWriteCount; ++idx1) { - skip |= ValidateDescriptorWrite(device, &pDescriptorWrites[idx1], false); - } - } - } - if (skip) { - return; - } - get_dispatch_table(ot_device_table_map, device) - ->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, - const VkComputePipelineCreateInfo *pCreateInfos, - const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f205601, VALIDATION_ERROR_UNDEFINED); - if (pCreateInfos) { - for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) { - if (pCreateInfos[idx0].basePipelineHandle) { - skip |= ValidateObject(device, pCreateInfos[idx0].basePipelineHandle, kVulkanObjectTypePipeline, true, - VALIDATION_ERROR_03000572, VALIDATION_ERROR_03000009); - } - if (pCreateInfos[idx0].layout) { - skip |= ValidateObject(device, pCreateInfos[idx0].layout, kVulkanObjectTypePipelineLayout, false, - VALIDATION_ERROR_0300be01, VALIDATION_ERROR_03000009); - } - if (pCreateInfos[idx0].stage.module) { - skip |= ValidateObject(device, pCreateInfos[idx0].stage.module, kVulkanObjectTypeShaderModule, false, - VALIDATION_ERROR_1060d201, VALIDATION_ERROR_UNDEFINED); - } - } - } - if (pipelineCache) { - skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_1f228001, - VALIDATION_ERROR_1f228007); - } - lock.unlock(); - if (skip) { - for (uint32_t i = 0; i < createInfoCount; i++) { - pPipelines[i] = VK_NULL_HANDLE; - } - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = get_dispatch_table(ot_device_table_map, device) - ->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - lock.lock(); - for (uint32_t idx1 = 0; idx1 < createInfoCount; ++idx1) { - if (pPipelines[idx1] != VK_NULL_HANDLE) { - CreateObject(device, pPipelines[idx1], kVulkanObjectTypePipeline, pAllocator); - } - } - lock.unlock(); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags) { - bool skip = false; - std::unique_lock lock(global_lock); - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32a05601, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_32a04601, - VALIDATION_ERROR_32a04607); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - // A DescriptorPool's descriptor sets are implicitly deleted when the pool is reset. - // Remove this pool's descriptor sets from our descriptorSet map. - auto itr = device_data->object_map[kVulkanObjectTypeDescriptorSet].begin(); - while (itr != device_data->object_map[kVulkanObjectTypeDescriptorSet].end()) { - ObjTrackState *pNode = (*itr).second; - auto del_itr = itr++; - if (pNode->parent_object == HandleToUint64(descriptorPool)) { - DestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet, nullptr, - VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - } - } - lock.unlock(); - VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetDescriptorPool(device, descriptorPool, flags); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer command_buffer, const VkCommandBufferBeginInfo *begin_info) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(command_buffer), layer_data_map); - bool skip = false; - { - std::lock_guard lock(global_lock); - skip |= ValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_16e02401, - VALIDATION_ERROR_UNDEFINED); - if (begin_info) { - ObjTrackState *pNode = device_data->object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)]; - if ((begin_info->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY) && - (begin_info->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) { - skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer, kVulkanObjectTypeFramebuffer, - true, VALIDATION_ERROR_0280006e, VALIDATION_ERROR_02a00009); - skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->renderPass, kVulkanObjectTypeRenderPass, false, - VALIDATION_ERROR_0280006a, VALIDATION_ERROR_02a00009); - } - } - } - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = get_dispatch_table(ot_device_table_map, command_buffer)->BeginCommandBuffer(command_buffer, begin_info); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pCallback) { - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance); - VkResult result = pInstanceTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); - if (VK_SUCCESS == result) { - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - result = layer_create_report_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pCallback); - CreateObject(instance, *pCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, - const VkAllocationCallbacks *pAllocator) { - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance); - pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - layer_destroy_report_callback(instance_data->report_data, msgCallback, pAllocator); - DestroyObject(instance, msgCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator, VALIDATION_ERROR_242009b4, - VALIDATION_ERROR_242009b6); -} - -VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, - int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance); - pInstanceTable->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); -} - -// VK_EXT_debug_utils commands -VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - if (pNameInfo->pObjectName) { - dev_data->report_data->debugUtilsObjectNameMap->insert( - std::make_pair((uint64_t &&) pNameInfo->objectHandle, pNameInfo->pObjectName)); - } else { - dev_data->report_data->debugUtilsObjectNameMap->erase(pNameInfo->objectHandle); - } - VkResult result = dev_data->dispatch_table.SetDebugUtilsObjectNameEXT(device, pNameInfo); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.SetDebugUtilsObjectTagEXT(device, pTagInfo); - return result; -} - -VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - if (!skip) { - BeginQueueDebugUtilsLabel(dev_data->report_data, queue, pLabelInfo); - if (dev_data->dispatch_table.QueueBeginDebugUtilsLabelEXT) { - dev_data->dispatch_table.QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); - } - } -} - -VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(VkQueue queue) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - if (!skip) { - if (dev_data->dispatch_table.QueueEndDebugUtilsLabelEXT) { - dev_data->dispatch_table.QueueEndDebugUtilsLabelEXT(queue); - } - EndQueueDebugUtilsLabel(dev_data->report_data, queue); - } -} - -VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - if (!skip) { - InsertQueueDebugUtilsLabel(dev_data->report_data, queue, pLabelInfo); - if (dev_data->dispatch_table.QueueInsertDebugUtilsLabelEXT) { - dev_data->dispatch_table.QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); - } - } -} - -VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - if (!skip) { - BeginCmdDebugUtilsLabel(dev_data->report_data, commandBuffer, pLabelInfo); - if (dev_data->dispatch_table.CmdBeginDebugUtilsLabelEXT) { - dev_data->dispatch_table.CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); - } - } -} - -VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - if (!skip) { - if (dev_data->dispatch_table.CmdEndDebugUtilsLabelEXT) { - dev_data->dispatch_table.CmdEndDebugUtilsLabelEXT(commandBuffer); - } - EndCmdDebugUtilsLabel(dev_data->report_data, commandBuffer); - } -} - -VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - if (!skip) { - InsertCmdDebugUtilsLabel(dev_data->report_data, commandBuffer, pLabelInfo); - if (dev_data->dispatch_table.CmdInsertDebugUtilsLabelEXT) { - dev_data->dispatch_table.CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger) { - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance); - VkResult result = pInstanceTable->CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); - if (VK_SUCCESS == result) { - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - result = layer_create_messenger_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pMessenger); - CreateObject(instance, *pMessenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance); - pInstanceTable->DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator); - DestroyObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); -} - -VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) { - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance); - pInstanceTable->SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); -} - -static const VkExtensionProperties instance_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}, - {VK_EXT_DEBUG_UTILS_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_SPEC_VERSION}}; - -static const VkLayerProperties globalLayerProps = {"VK_LAYER_LUNARG_object_tracker", - VK_LAYER_API_VERSION, // specVersion - 1, // implementationVersion - "LunarG Validation Layer"}; - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName)) - return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties); - - return VK_ERROR_LAYER_NOT_PRESENT; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, - uint32_t *pCount, VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName)) - return util_GetExtensionProperties(0, nullptr, pCount, pProperties); - - assert(physicalDevice); - VkLayerInstanceDispatchTable *pTable = get_dispatch_table(ot_instance_table_map, physicalDevice); - return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - std::lock_guard lock(global_lock); - bool skip = ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_1fc27a01, - VALIDATION_ERROR_UNDEFINED); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - layer_data *phy_dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); - VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(phy_dev_data->instance, "vkCreateDevice"); - if (fpCreateDevice == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); - if (result != VK_SUCCESS) { - return result; - } - - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); - device_data->report_data = layer_debug_utils_create_device(phy_dev_data->report_data, *pDevice); - layer_init_device_dispatch_table(*pDevice, &device_data->dispatch_table, fpGetDeviceProcAddr); - - // Add link back to physDev - device_data->physical_device = physicalDevice; - device_data->instance = phy_dev_data->instance; - - initDeviceTable(*pDevice, fpGetDeviceProcAddr, ot_device_table_map); - - CreateObject(phy_dev_data->instance, *pDevice, kVulkanObjectTypeDevice, pAllocator); - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, - VkImage *pSwapchainImages) { - bool skip = false; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30805601, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_3082f001, - VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - VkResult result = get_dispatch_table(ot_device_table_map, device) - ->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); - if (pSwapchainImages != NULL) { - lock.lock(); - for (uint32_t i = 0; i < *pSwapchainImageCount; i++) { - CreateSwapchainImageObject(device, pSwapchainImages[i], swapchain); - } - lock.unlock(); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorSetLayout *pSetLayout) { - bool skip = false; - { - std::lock_guard lock(global_lock); - skip |= - ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f805601, VALIDATION_ERROR_UNDEFINED); - if (pCreateInfo) { - if (pCreateInfo->pBindings) { - for (uint32_t binding_index = 0; binding_index < pCreateInfo->bindingCount; ++binding_index) { - const VkDescriptorSetLayoutBinding &binding = pCreateInfo->pBindings[binding_index]; - const bool is_sampler_type = binding.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || - binding.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - if (binding.pImmutableSamplers && is_sampler_type) { - for (uint32_t index2 = 0; index2 < binding.descriptorCount; ++index2) { - const VkSampler sampler = binding.pImmutableSamplers[index2]; - skip |= ValidateObject(device, sampler, kVulkanObjectTypeSampler, false, VALIDATION_ERROR_04e00234, - VALIDATION_ERROR_UNDEFINED); - } - } - } - } - } - } - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = - get_dispatch_table(ot_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); - if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); - CreateObject(device, *pSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties *pQueueFamilyProperties) { - bool skip = false; - { - std::lock_guard lock(global_lock); - skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2da27a01, - VALIDATION_ERROR_UNDEFINED); - } - if (skip) { - return; - } - get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - std::lock_guard lock(global_lock); - if (pQueueFamilyProperties != NULL) { - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); - if (instance_data->queue_family_properties.size() < *pQueueFamilyPropertyCount) { - instance_data->queue_family_properties.resize(*pQueueFamilyPropertyCount); - } - for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) { - instance_data->queue_family_properties[i] = pQueueFamilyProperties[i]; - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) { - VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); - if (fpCreateInstance == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); - if (result != VK_SUCCESS) { - return result; - } - - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map); - instance_data->instance = *pInstance; - initInstanceTable(*pInstance, fpGetInstanceProcAddr, ot_instance_table_map); - VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, *pInstance); - - // Look for one or more debug report create info structures, and copy the - // callback(s) for each one found (for use by vkDestroyInstance) - layer_copy_tmp_debug_messengers(pCreateInfo->pNext, &instance_data->num_tmp_debug_messengers, - &instance_data->tmp_messenger_create_infos, &instance_data->tmp_debug_messengers); - layer_copy_tmp_report_callbacks(pCreateInfo->pNext, &instance_data->num_tmp_report_callbacks, - &instance_data->tmp_report_create_infos, &instance_data->tmp_report_callbacks); - - instance_data->report_data = debug_utils_create_instance(pInstanceTable, *pInstance, pCreateInfo->enabledExtensionCount, - pCreateInfo->ppEnabledExtensionNames); - - InitObjectTracker(instance_data, pAllocator); - - CreateObject(*pInstance, *pInstance, kVulkanObjectTypeInstance, pAllocator); - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, - VkPhysicalDevice *pPhysicalDevices) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= - ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2800bc01, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = get_dispatch_table(ot_instance_table_map, instance) - ->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); - lock.lock(); - if (result == VK_SUCCESS) { - if (pPhysicalDevices) { - for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) { - CreateObject(instance, pPhysicalDevices[i], kVulkanObjectTypePhysicalDevice, nullptr); - } - } - } - lock.unlock(); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, - VkCommandBuffer *pCommandBuffers) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16805601, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, pAllocateInfo->commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_02602801, - VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - VkResult result = - get_dispatch_table(ot_device_table_map, device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); - - lock.lock(); - for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) { - AllocateCommandBuffer(device, pAllocateInfo->commandPool, pCommandBuffers[i], pAllocateInfo->level); - } - lock.unlock(); - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, - VkDescriptorSet *pDescriptorSets) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16a05601, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, pAllocateInfo->descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_04c04601, - VALIDATION_ERROR_04c00009); - for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) { - skip |= ValidateObject(device, pAllocateInfo->pSetLayouts[i], kVulkanObjectTypeDescriptorSetLayout, false, - VALIDATION_ERROR_04c22c01, VALIDATION_ERROR_04c00009); - } - lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - - VkResult result = - get_dispatch_table(ot_device_table_map, device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); - - if (VK_SUCCESS == result) { - lock.lock(); - for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) { - AllocateDescriptorSet(device, pAllocateInfo->descriptorPool, pDescriptorSets[i]); - } - lock.unlock(); - } - - return result; -} - -VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, - const VkCommandBuffer *pCommandBuffers) { - bool skip = false; - std::unique_lock lock(global_lock); - ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28405601, VALIDATION_ERROR_UNDEFINED); - ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_28402801, VALIDATION_ERROR_28402807); - for (uint32_t i = 0; i < commandBufferCount; i++) { - if (pCommandBuffers[i] != VK_NULL_HANDLE) { - skip |= ValidateCommandBuffer(device, commandPool, pCommandBuffers[i]); - } - } - - for (uint32_t i = 0; i < commandBufferCount; i++) { - DestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer, nullptr, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - } - - lock.unlock(); - if (!skip) { - get_dispatch_table(ot_device_table_map, device) - ->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); - } -} - -VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); - // A swapchain's images are implicitly deleted when the swapchain is deleted. - // Remove this swapchain's images from our map of such images. - std::unordered_map::iterator itr = device_data->swapchainImageMap.begin(); - while (itr != device_data->swapchainImageMap.end()) { - ObjTrackState *pNode = (*itr).second; - if (pNode->parent_object == HandleToUint64(swapchain)) { - delete pNode; - auto delete_item = itr++; - device_data->swapchainImageMap.erase(delete_item); - } else { - ++itr; - } - } - DestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, pAllocator, VALIDATION_ERROR_26e00a06, - VALIDATION_ERROR_26e00a08); - lock.unlock(); - - get_dispatch_table(ot_device_table_map, device)->DestroySwapchainKHR(device, swapchain, pAllocator); -} - -VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, - const VkDescriptorSet *pDescriptorSets) { - bool skip = false; - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28605601, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_28604601, - VALIDATION_ERROR_28604607); - for (uint32_t i = 0; i < descriptorSetCount; i++) { - if (pDescriptorSets[i] != VK_NULL_HANDLE) { - skip |= ValidateDescriptorSet(device, descriptorPool, pDescriptorSets[i]); - } - } - - for (uint32_t i = 0; i < descriptorSetCount; i++) { - DestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet, nullptr, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - } - - lock.unlock(); - if (!skip) { - result = get_dispatch_table(ot_device_table_map, device) - ->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, - const VkAllocationCallbacks *pAllocator) { - bool skip = VK_FALSE; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24405601, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, true, VALIDATION_ERROR_24404601, - VALIDATION_ERROR_24404607); - lock.unlock(); - if (skip) { - return; - } - // A DescriptorPool's descriptor sets are implicitly deleted when the pool is deleted. - // Remove this pool's descriptor sets from our descriptorSet map. - lock.lock(); - std::unordered_map::iterator itr = device_data->object_map[kVulkanObjectTypeDescriptorSet].begin(); - while (itr != device_data->object_map[kVulkanObjectTypeDescriptorSet].end()) { - ObjTrackState *pNode = (*itr).second; - auto del_itr = itr++; - if (pNode->parent_object == HandleToUint64(descriptorPool)) { - DestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet, nullptr, - VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - } - } - DestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator, VALIDATION_ERROR_24400260, - VALIDATION_ERROR_24400262); - lock.unlock(); - get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool, pAllocator); -} - -VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24005601, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, true, VALIDATION_ERROR_24002801, - VALIDATION_ERROR_24002807); - lock.unlock(); - if (skip) { - return; - } - lock.lock(); - // A CommandPool's command buffers are implicitly deleted when the pool is deleted. - // Remove this pool's cmdBuffers from our cmd buffer map. - auto itr = device_data->object_map[kVulkanObjectTypeCommandBuffer].begin(); - auto del_itr = itr; - while (itr != device_data->object_map[kVulkanObjectTypeCommandBuffer].end()) { - ObjTrackState *pNode = (*itr).second; - del_itr = itr++; - if (pNode->parent_object == HandleToUint64(commandPool)) { - skip |= ValidateCommandBuffer(device, commandPool, reinterpret_cast((*del_itr).first)); - DestroyObject(device, reinterpret_cast((*del_itr).first), kVulkanObjectTypeCommandBuffer, nullptr, - VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - } - } - DestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator, VALIDATION_ERROR_24000054, - VALIDATION_ERROR_24000056); - lock.unlock(); - get_dispatch_table(ot_device_table_map, device)->DestroyCommandPool(device, commandPool, pAllocator); -} - -// Note: This is the core version of this routine. The extension version is below. -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - bool skip = false; - { - std::lock_guard lock(global_lock); - skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - } - if (skip) { - return; - } - get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - std::lock_guard lock(global_lock); - if (pQueueFamilyProperties != NULL) { - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); - if (instance_data->queue_family_properties.size() < *pQueueFamilyPropertyCount) { - instance_data->queue_family_properties.resize(*pQueueFamilyPropertyCount); - } - for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) { - instance_data->queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties; - } - } -} - -// Note: This is the extension version of this routine. The core version is above. -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - bool skip = false; - { - std::lock_guard lock(global_lock); - skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - } - if (skip) { - return; - } - get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - std::lock_guard lock(global_lock); - if (pQueueFamilyProperties != NULL) { - layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); - if (instance_data->queue_family_properties.size() < *pQueueFamilyPropertyCount) { - instance_data->queue_family_properties.resize(*pQueueFamilyPropertyCount); - } - for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) { - instance_data->queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties; - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, - VkDisplayPropertiesKHR *pProperties) { - bool skip = false; - std::unique_lock lock(global_lock); - skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2b827a01, - VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); - - lock.lock(); - if (result == VK_SUCCESS) { - if (pProperties) { - for (uint32_t i = 0; i < *pPropertyCount; ++i) { - CreateObject(physicalDevice, pProperties[i].display, kVulkanObjectTypeDisplayKHR, nullptr); - } - } - } - lock.unlock(); - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) { - bool skip = false; - std::unique_lock lock(global_lock); - skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_29827a01, - VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_29806001, - VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); - - lock.lock(); - if (result == VK_SUCCESS) { - if (pProperties) { - for (uint32_t i = 0; i < *pPropertyCount; ++i) { - CreateObject(physicalDevice, pProperties[i].displayMode, kVulkanObjectTypeDisplayModeKHR, nullptr); - } - } - } - lock.unlock(); - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) { - bool skip = VK_FALSE; - std::unique_lock lock(global_lock); - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - if (pNameInfo->pObjectName) { - dev_data->report_data->debugObjectNameMap->insert( - std::make_pair((uint64_t &&) pNameInfo->object, pNameInfo->pObjectName)); - } else { - dev_data->report_data->debugObjectNameMap->erase(pNameInfo->object); - } - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23605601, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; - } - VkResult result = dev_data->dispatch_table.DebugMarkerSetObjectNameEXT(device, pNameInfo); - return result; -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { - assert(instance); - - if (get_dispatch_table(ot_instance_table_map, instance)->GetPhysicalDeviceProcAddr == NULL) { - return NULL; - } - return get_dispatch_table(ot_instance_table_map, instance)->GetPhysicalDeviceProcAddr(instance, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - auto table = get_dispatch_table(ot_device_table_map, device); - if (!table->GetDeviceProcAddr) return NULL; - return table->GetDeviceProcAddr(device, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - auto table = get_dispatch_table(ot_instance_table_map, instance); - if (!table->GetInstanceProcAddr) return nullptr; - return table->GetInstanceProcAddr(instance, funcName); -} - -} // namespace object_tracker - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - return object_tracker::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, - VkLayerProperties *pProperties) { - return object_tracker::EnumerateInstanceLayerProperties(pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - // The layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return object_tracker::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { - return object_tracker::GetDeviceProcAddr(dev, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { - return object_tracker::GetInstanceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - // The layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return object_tracker::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, - const char *funcName) { - return object_tracker::GetPhysicalDeviceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { - assert(pVersionStruct != NULL); - assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); - - // Fill in the function pointers if our version is at least capable of having the structure contain them. - if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { - pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; - pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; - pVersionStruct->pfnGetPhysicalDeviceProcAddr = vk_layerGetPhysicalDeviceProcAddr; - } - - if (pVersionStruct->loaderLayerInterfaceVersion < CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - object_tracker::loader_layer_if_version = pVersionStruct->loaderLayerInterfaceVersion; - } else if (pVersionStruct->loaderLayerInterfaceVersion > CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - pVersionStruct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - } - - return VK_SUCCESS; -} diff --git a/layers/old_vuid_to_new_mapping.txt b/layers/old_vuid_to_new_mapping.txt deleted file mode 100644 index 5b9eb30f..00000000 --- a/layers/old_vuid_to_new_mapping.txt +++ /dev/null @@ -1,3107 +0,0 @@ -# This doc is stored for historical purposes -# In May of 2017, Valid Usage IDs were migrated from -# their initial definitions to new values derived from -# string-based VUIDs that are integrated into the spec -# This file has the mapping from the old IDs to the -# new IDs to be used for any tools/bugs/code that has -# the old IDs and needs to be migrated to the new IDs -# These mappings are only for those old IDs that were -# active at the time of migration and going forward -# only new IDs will be used/generated so no new mappings -# will be added and at some point this file may go away. -VALIDATION_ERROR_00000:VALIDATION_ERROR_2a80bc01 -VALIDATION_ERROR_00001:VALIDATION_ERROR_2a81c001 -VALIDATION_ERROR_00002:VALIDATION_ERROR_29405601 -VALIDATION_ERROR_00003:VALIDATION_ERROR_2941c001 -VALIDATION_ERROR_00004:VALIDATION_ERROR_21211e01 -VALIDATION_ERROR_00005:VALIDATION_ERROR_2120ec01 -VALIDATION_ERROR_00006:VALIDATION_ERROR_21219c01 -VALIDATION_ERROR_00007:VALIDATION_ERROR_0be2b00b -VALIDATION_ERROR_00009:VALIDATION_ERROR_0be09005 -VALIDATION_ERROR_00010:VALIDATION_ERROR_0be0ee01 -VALIDATION_ERROR_00011:VALIDATION_ERROR_0be29001 -VALIDATION_ERROR_00012:VALIDATION_ERROR_0be28e01 -VALIDATION_ERROR_00014:VALIDATION_ERROR_0062b00b -VALIDATION_ERROR_00015:VALIDATION_ERROR_0061c40d -VALIDATION_ERROR_00016:VALIDATION_ERROR_0060f001 -VALIDATION_ERROR_00017:VALIDATION_ERROR_00615c01 -VALIDATION_ERROR_00018:VALIDATION_ERROR_258004ea -VALIDATION_ERROR_00019:VALIDATION_ERROR_258004ec -VALIDATION_ERROR_00020:VALIDATION_ERROR_258004ee -VALIDATION_ERROR_00021:VALIDATION_ERROR_2580bc01 -VALIDATION_ERROR_00022:VALIDATION_ERROR_2580ec01 -VALIDATION_ERROR_00023:VALIDATION_ERROR_2800bc01 -VALIDATION_ERROR_00024:VALIDATION_ERROR_2801d601 -VALIDATION_ERROR_00025:VALIDATION_ERROR_2801dc01 -VALIDATION_ERROR_00026:VALIDATION_ERROR_2d627a01 -VALIDATION_ERROR_00027:VALIDATION_ERROR_2d61f401 -VALIDATION_ERROR_00028:VALIDATION_ERROR_2da27a01 -VALIDATION_ERROR_00029:VALIDATION_ERROR_2da20201 -VALIDATION_ERROR_00030:VALIDATION_ERROR_2da20001 -VALIDATION_ERROR_00031:VALIDATION_ERROR_1fc27a01 -VALIDATION_ERROR_00032:VALIDATION_ERROR_1fc11e01 -VALIDATION_ERROR_00033:VALIDATION_ERROR_1fc0ec01 -VALIDATION_ERROR_00034:VALIDATION_ERROR_1fc13801 -VALIDATION_ERROR_00035:VALIDATION_ERROR_056002e8 -VALIDATION_ERROR_00036:VALIDATION_ERROR_0562b00b -VALIDATION_ERROR_00038:VALIDATION_ERROR_05609005 -VALIDATION_ERROR_00039:VALIDATION_ERROR_0561fe01 -VALIDATION_ERROR_00040:VALIDATION_ERROR_05629001 -VALIDATION_ERROR_00041:VALIDATION_ERROR_05628e01 -VALIDATION_ERROR_00042:VALIDATION_ERROR_05615a01 -VALIDATION_ERROR_00043:VALIDATION_ERROR_0562a01b -VALIDATION_ERROR_00049:VALIDATION_ERROR_24a002f4 -VALIDATION_ERROR_00050:VALIDATION_ERROR_24a002f6 -VALIDATION_ERROR_00051:VALIDATION_ERROR_24a002f8 -VALIDATION_ERROR_00052:VALIDATION_ERROR_24a05601 -VALIDATION_ERROR_00053:VALIDATION_ERROR_24a0ec01 -VALIDATION_ERROR_00054:VALIDATION_ERROR_06c002fa -VALIDATION_ERROR_00060:VALIDATION_ERROR_29600300 -VALIDATION_ERROR_00061:VALIDATION_ERROR_29600302 -VALIDATION_ERROR_00062:VALIDATION_ERROR_29605601 -VALIDATION_ERROR_00063:VALIDATION_ERROR_2961fc01 -VALIDATION_ERROR_00064:VALIDATION_ERROR_1f005601 -VALIDATION_ERROR_00065:VALIDATION_ERROR_1f011e01 -VALIDATION_ERROR_00066:VALIDATION_ERROR_1f00ec01 -VALIDATION_ERROR_00067:VALIDATION_ERROR_1f011601 -VALIDATION_ERROR_00068:VALIDATION_ERROR_02c0004e -VALIDATION_ERROR_00069:VALIDATION_ERROR_02c2b00b -VALIDATION_ERROR_00070:VALIDATION_ERROR_02c1c40d -VALIDATION_ERROR_00071:VALIDATION_ERROR_02c09001 -VALIDATION_ERROR_00072:VALIDATION_ERROR_32800050 -VALIDATION_ERROR_00073:VALIDATION_ERROR_32805601 -VALIDATION_ERROR_00074:VALIDATION_ERROR_32802801 -VALIDATION_ERROR_00075:VALIDATION_ERROR_32809001 -VALIDATION_ERROR_00076:VALIDATION_ERROR_32802807 -VALIDATION_ERROR_00077:VALIDATION_ERROR_24000052 -VALIDATION_ERROR_00078:VALIDATION_ERROR_24000054 -VALIDATION_ERROR_00079:VALIDATION_ERROR_24000056 -VALIDATION_ERROR_00080:VALIDATION_ERROR_24005601 -VALIDATION_ERROR_00081:VALIDATION_ERROR_24002801 -VALIDATION_ERROR_00082:VALIDATION_ERROR_2400ec01 -VALIDATION_ERROR_00083:VALIDATION_ERROR_24002807 -VALIDATION_ERROR_00084:VALIDATION_ERROR_16805601 -VALIDATION_ERROR_00085:VALIDATION_ERROR_1680ea01 -VALIDATION_ERROR_00086:VALIDATION_ERROR_16811401 -VALIDATION_ERROR_00087:VALIDATION_ERROR_02600058 -VALIDATION_ERROR_00088:VALIDATION_ERROR_0262b00b -VALIDATION_ERROR_00089:VALIDATION_ERROR_0261c40d -VALIDATION_ERROR_00090:VALIDATION_ERROR_02602801 -VALIDATION_ERROR_00091:VALIDATION_ERROR_0260c001 -VALIDATION_ERROR_00092:VALIDATION_ERROR_3260005a -VALIDATION_ERROR_00093:VALIDATION_ERROR_3260005c -VALIDATION_ERROR_00094:VALIDATION_ERROR_32602401 -VALIDATION_ERROR_00095:VALIDATION_ERROR_32609001 -VALIDATION_ERROR_00096:VALIDATION_ERROR_2840005e -VALIDATION_ERROR_00097:VALIDATION_ERROR_28400060 -VALIDATION_ERROR_00098:VALIDATION_ERROR_28405601 -VALIDATION_ERROR_00099:VALIDATION_ERROR_28402801 -VALIDATION_ERROR_00100:VALIDATION_ERROR_2840261b -VALIDATION_ERROR_00101:VALIDATION_ERROR_28402807 -VALIDATION_ERROR_00102:VALIDATION_ERROR_28411407 -VALIDATION_ERROR_00103:VALIDATION_ERROR_16e00062 -VALIDATION_ERROR_00105:VALIDATION_ERROR_16e00064 -VALIDATION_ERROR_00106:VALIDATION_ERROR_16e00066 -VALIDATION_ERROR_00107:VALIDATION_ERROR_16e00068 -VALIDATION_ERROR_00108:VALIDATION_ERROR_16e02401 -VALIDATION_ERROR_00109:VALIDATION_ERROR_16e0f601 -VALIDATION_ERROR_00110:VALIDATION_ERROR_0280006a -VALIDATION_ERROR_00111:VALIDATION_ERROR_0280006c -VALIDATION_ERROR_00112:VALIDATION_ERROR_0280006e -VALIDATION_ERROR_00113:VALIDATION_ERROR_0282b00b -VALIDATION_ERROR_00114:VALIDATION_ERROR_0281c40d -VALIDATION_ERROR_00115:VALIDATION_ERROR_02809001 -VALIDATION_ERROR_00116:VALIDATION_ERROR_02a00070 -VALIDATION_ERROR_00117:VALIDATION_ERROR_02a00072 -VALIDATION_ERROR_00118:VALIDATION_ERROR_02a00074 -VALIDATION_ERROR_00119:VALIDATION_ERROR_02a2b00b -VALIDATION_ERROR_00120:VALIDATION_ERROR_02a1c40d -VALIDATION_ERROR_00121:VALIDATION_ERROR_02a00009 -VALIDATION_ERROR_00122:VALIDATION_ERROR_27400076 -VALIDATION_ERROR_00123:VALIDATION_ERROR_27400078 -VALIDATION_ERROR_00124:VALIDATION_ERROR_2740007a -VALIDATION_ERROR_00125:VALIDATION_ERROR_27402401 -VALIDATION_ERROR_00126:VALIDATION_ERROR_31a0007e -VALIDATION_ERROR_00127:VALIDATION_ERROR_31a00080 -VALIDATION_ERROR_00128:VALIDATION_ERROR_31a29c01 -VALIDATION_ERROR_00129:VALIDATION_ERROR_31a24001 -VALIDATION_ERROR_00130:VALIDATION_ERROR_31a08801 -VALIDATION_ERROR_00131:VALIDATION_ERROR_31a00009 -VALIDATION_ERROR_00132:VALIDATION_ERROR_31a00086 -VALIDATION_ERROR_00133:VALIDATION_ERROR_31a0008e -VALIDATION_ERROR_00134:VALIDATION_ERROR_31a00090 -VALIDATION_ERROR_00135:VALIDATION_ERROR_31a00092 -VALIDATION_ERROR_00139:VALIDATION_ERROR_31a00094 -VALIDATION_ERROR_00140:VALIDATION_ERROR_13c00096 -VALIDATION_ERROR_00141:VALIDATION_ERROR_31a00088 -VALIDATION_ERROR_00142:VALIDATION_ERROR_13c00098 -VALIDATION_ERROR_00143:VALIDATION_ERROR_13c0009a -VALIDATION_ERROR_00144:VALIDATION_ERROR_13c2b00b -VALIDATION_ERROR_00146:VALIDATION_ERROR_13c27601 -VALIDATION_ERROR_00147:VALIDATION_ERROR_13c27001 -VALIDATION_ERROR_00148:VALIDATION_ERROR_13c27003 -VALIDATION_ERROR_00149:VALIDATION_ERROR_13c11401 -VALIDATION_ERROR_00150:VALIDATION_ERROR_13c23401 -VALIDATION_ERROR_00151:VALIDATION_ERROR_13c00009 -VALIDATION_ERROR_00152:VALIDATION_ERROR_1b2000ae -VALIDATION_ERROR_00154:VALIDATION_ERROR_1b2000b4 -VALIDATION_ERROR_00155:VALIDATION_ERROR_1b2000b2 -VALIDATION_ERROR_00156:VALIDATION_ERROR_1b2000b0 -VALIDATION_ERROR_00157:VALIDATION_ERROR_1b2000bc -VALIDATION_ERROR_00158:VALIDATION_ERROR_1b2000be -VALIDATION_ERROR_00159:VALIDATION_ERROR_1b202401 -VALIDATION_ERROR_00160:VALIDATION_ERROR_1b211401 -VALIDATION_ERROR_00161:VALIDATION_ERROR_1b202413 -VALIDATION_ERROR_00162:VALIDATION_ERROR_1b202415 -VALIDATION_ERROR_00163:VALIDATION_ERROR_1b200019 -VALIDATION_ERROR_00164:VALIDATION_ERROR_1b20261b -VALIDATION_ERROR_00165:VALIDATION_ERROR_1b200009 -VALIDATION_ERROR_00166:VALIDATION_ERROR_20405601 -VALIDATION_ERROR_00167:VALIDATION_ERROR_20411e01 -VALIDATION_ERROR_00168:VALIDATION_ERROR_2040ec01 -VALIDATION_ERROR_00169:VALIDATION_ERROR_20417001 -VALIDATION_ERROR_00170:VALIDATION_ERROR_0922b00b -VALIDATION_ERROR_00171:VALIDATION_ERROR_0921c40d -VALIDATION_ERROR_00172:VALIDATION_ERROR_09209001 -VALIDATION_ERROR_00173:VALIDATION_ERROR_24e008c0 -VALIDATION_ERROR_00174:VALIDATION_ERROR_24e008c2 -VALIDATION_ERROR_00175:VALIDATION_ERROR_24e008c4 -VALIDATION_ERROR_00176:VALIDATION_ERROR_24e05601 -VALIDATION_ERROR_00177:VALIDATION_ERROR_24e08801 -VALIDATION_ERROR_00178:VALIDATION_ERROR_24e0ec01 -VALIDATION_ERROR_00179:VALIDATION_ERROR_24e08807 -VALIDATION_ERROR_00180:VALIDATION_ERROR_2a005601 -VALIDATION_ERROR_00181:VALIDATION_ERROR_2a008801 -VALIDATION_ERROR_00182:VALIDATION_ERROR_2a008807 -VALIDATION_ERROR_00183:VALIDATION_ERROR_32e008c6 -VALIDATION_ERROR_00184:VALIDATION_ERROR_32e05601 -VALIDATION_ERROR_00185:VALIDATION_ERROR_32e17201 -VALIDATION_ERROR_00186:VALIDATION_ERROR_32e08a1b -VALIDATION_ERROR_00187:VALIDATION_ERROR_32e17207 -VALIDATION_ERROR_00188:VALIDATION_ERROR_33e05601 -VALIDATION_ERROR_00189:VALIDATION_ERROR_33e17201 -VALIDATION_ERROR_00190:VALIDATION_ERROR_33e08a1b -VALIDATION_ERROR_00191:VALIDATION_ERROR_33e17207 -VALIDATION_ERROR_00192:VALIDATION_ERROR_22405601 -VALIDATION_ERROR_00193:VALIDATION_ERROR_22411e01 -VALIDATION_ERROR_00194:VALIDATION_ERROR_2240ec01 -VALIDATION_ERROR_00195:VALIDATION_ERROR_22422801 -VALIDATION_ERROR_00196:VALIDATION_ERROR_1282b00b -VALIDATION_ERROR_00197:VALIDATION_ERROR_1281c40d -VALIDATION_ERROR_00198:VALIDATION_ERROR_12809005 -VALIDATION_ERROR_00199:VALIDATION_ERROR_268008e2 -VALIDATION_ERROR_00200:VALIDATION_ERROR_268008e4 -VALIDATION_ERROR_00201:VALIDATION_ERROR_268008e6 -VALIDATION_ERROR_00202:VALIDATION_ERROR_26805601 -VALIDATION_ERROR_00203:VALIDATION_ERROR_2682b801 -VALIDATION_ERROR_00204:VALIDATION_ERROR_2680ec01 -VALIDATION_ERROR_00205:VALIDATION_ERROR_2682b807 -VALIDATION_ERROR_00206:VALIDATION_ERROR_20205601 -VALIDATION_ERROR_00207:VALIDATION_ERROR_20211e01 -VALIDATION_ERROR_00208:VALIDATION_ERROR_2020ec01 -VALIDATION_ERROR_00209:VALIDATION_ERROR_20215e01 -VALIDATION_ERROR_00210:VALIDATION_ERROR_07e2b00b -VALIDATION_ERROR_00211:VALIDATION_ERROR_07e1c40d -VALIDATION_ERROR_00212:VALIDATION_ERROR_07e09005 -VALIDATION_ERROR_00213:VALIDATION_ERROR_24c008f2 -VALIDATION_ERROR_00214:VALIDATION_ERROR_24c008f4 -VALIDATION_ERROR_00215:VALIDATION_ERROR_24c008f6 -VALIDATION_ERROR_00216:VALIDATION_ERROR_24c05601 -VALIDATION_ERROR_00217:VALIDATION_ERROR_24c07e01 -VALIDATION_ERROR_00218:VALIDATION_ERROR_24c0ec01 -VALIDATION_ERROR_00219:VALIDATION_ERROR_24c07e07 -VALIDATION_ERROR_00220:VALIDATION_ERROR_29e05601 -VALIDATION_ERROR_00221:VALIDATION_ERROR_29e07e01 -VALIDATION_ERROR_00222:VALIDATION_ERROR_29e07e07 -VALIDATION_ERROR_00223:VALIDATION_ERROR_33005601 -VALIDATION_ERROR_00224:VALIDATION_ERROR_33007e01 -VALIDATION_ERROR_00225:VALIDATION_ERROR_33007e07 -VALIDATION_ERROR_00226:VALIDATION_ERROR_32c008f8 -VALIDATION_ERROR_00227:VALIDATION_ERROR_32c05601 -VALIDATION_ERROR_00228:VALIDATION_ERROR_32c07e01 -VALIDATION_ERROR_00229:VALIDATION_ERROR_32c07e07 -VALIDATION_ERROR_00230:VALIDATION_ERROR_1d4008fc -VALIDATION_ERROR_00231:VALIDATION_ERROR_1d4008fe -VALIDATION_ERROR_00232:VALIDATION_ERROR_1d402401 -VALIDATION_ERROR_00233:VALIDATION_ERROR_1d407e01 -VALIDATION_ERROR_00234:VALIDATION_ERROR_1d42de01 -VALIDATION_ERROR_00235:VALIDATION_ERROR_1d42de03 -VALIDATION_ERROR_00236:VALIDATION_ERROR_1d402413 -VALIDATION_ERROR_00237:VALIDATION_ERROR_1d402415 -VALIDATION_ERROR_00238:VALIDATION_ERROR_1d400017 -VALIDATION_ERROR_00239:VALIDATION_ERROR_1d400009 -VALIDATION_ERROR_00240:VALIDATION_ERROR_1c400904 -VALIDATION_ERROR_00241:VALIDATION_ERROR_1c400906 -VALIDATION_ERROR_00242:VALIDATION_ERROR_1c400908 -VALIDATION_ERROR_00243:VALIDATION_ERROR_1c402401 -VALIDATION_ERROR_00244:VALIDATION_ERROR_1c407e01 -VALIDATION_ERROR_00245:VALIDATION_ERROR_1c42de01 -VALIDATION_ERROR_00246:VALIDATION_ERROR_1c42de03 -VALIDATION_ERROR_00247:VALIDATION_ERROR_1c402413 -VALIDATION_ERROR_00248:VALIDATION_ERROR_1c402415 -VALIDATION_ERROR_00249:VALIDATION_ERROR_1c400017 -VALIDATION_ERROR_00250:VALIDATION_ERROR_1c400009 -VALIDATION_ERROR_00252:VALIDATION_ERROR_1e602401 -VALIDATION_ERROR_00253:VALIDATION_ERROR_1e616001 -VALIDATION_ERROR_00254:VALIDATION_ERROR_1e62d401 -VALIDATION_ERROR_00255:VALIDATION_ERROR_1e62d403 -VALIDATION_ERROR_00256:VALIDATION_ERROR_1e607801 -VALIDATION_ERROR_00257:VALIDATION_ERROR_1e607803 -VALIDATION_ERROR_00258:VALIDATION_ERROR_1e61ac01 -VALIDATION_ERROR_00259:VALIDATION_ERROR_1e610401 -VALIDATION_ERROR_00260:VALIDATION_ERROR_1e618a01 -VALIDATION_ERROR_00261:VALIDATION_ERROR_1e602413 -VALIDATION_ERROR_00262:VALIDATION_ERROR_1e602415 -VALIDATION_ERROR_00263:VALIDATION_ERROR_1e60801b -VALIDATION_ERROR_00264:VALIDATION_ERROR_1e600009 -VALIDATION_ERROR_00265:VALIDATION_ERROR_1b800920 -VALIDATION_ERROR_00266:VALIDATION_ERROR_1b800922 -VALIDATION_ERROR_00267:VALIDATION_ERROR_1b800924 -VALIDATION_ERROR_00268:VALIDATION_ERROR_1b800926 -VALIDATION_ERROR_00269:VALIDATION_ERROR_1b800928 -VALIDATION_ERROR_00270:VALIDATION_ERROR_1b802401 -VALIDATION_ERROR_00271:VALIDATION_ERROR_1b82d401 -VALIDATION_ERROR_00272:VALIDATION_ERROR_1b82d403 -VALIDATION_ERROR_00273:VALIDATION_ERROR_1b807801 -VALIDATION_ERROR_00274:VALIDATION_ERROR_1b807803 -VALIDATION_ERROR_00275:VALIDATION_ERROR_1b803e01 -VALIDATION_ERROR_00276:VALIDATION_ERROR_1b81ac01 -VALIDATION_ERROR_00277:VALIDATION_ERROR_1b810401 -VALIDATION_ERROR_00278:VALIDATION_ERROR_1b818a01 -VALIDATION_ERROR_00279:VALIDATION_ERROR_1b802413 -VALIDATION_ERROR_00280:VALIDATION_ERROR_1b802415 -VALIDATION_ERROR_00281:VALIDATION_ERROR_0c82b00b -VALIDATION_ERROR_00282:VALIDATION_ERROR_0c81c40d -VALIDATION_ERROR_00283:VALIDATION_ERROR_0c82c401 -VALIDATION_ERROR_00284:VALIDATION_ERROR_0c806801 -VALIDATION_ERROR_00285:VALIDATION_ERROR_01800946 -VALIDATION_ERROR_00286:VALIDATION_ERROR_01800948 -VALIDATION_ERROR_00287:VALIDATION_ERROR_0180094a -VALIDATION_ERROR_00290:VALIDATION_ERROR_01800958 -VALIDATION_ERROR_00291:VALIDATION_ERROR_0182b00b -VALIDATION_ERROR_00292:VALIDATION_ERROR_0181c40d -VALIDATION_ERROR_00293:VALIDATION_ERROR_0182c401 -VALIDATION_ERROR_00294:VALIDATION_ERROR_01806801 -VALIDATION_ERROR_00295:VALIDATION_ERROR_01801a01 -VALIDATION_ERROR_00296:VALIDATION_ERROR_0a00095a -VALIDATION_ERROR_00297:VALIDATION_ERROR_0a00095c -VALIDATION_ERROR_00300:VALIDATION_ERROR_0a00096a -VALIDATION_ERROR_00302:VALIDATION_ERROR_0a00096e -VALIDATION_ERROR_00303:VALIDATION_ERROR_0a000970 -VALIDATION_ERROR_00304:VALIDATION_ERROR_0a000972 -VALIDATION_ERROR_00305:VALIDATION_ERROR_0a000974 -VALIDATION_ERROR_00306:VALIDATION_ERROR_0a000976 -VALIDATION_ERROR_00307:VALIDATION_ERROR_0a000978 -VALIDATION_ERROR_00308:VALIDATION_ERROR_0a00097a -VALIDATION_ERROR_00309:VALIDATION_ERROR_0a02b00b -VALIDATION_ERROR_00310:VALIDATION_ERROR_0a01c40d -VALIDATION_ERROR_00311:VALIDATION_ERROR_0a02c401 -VALIDATION_ERROR_00312:VALIDATION_ERROR_0a006801 -VALIDATION_ERROR_00313:VALIDATION_ERROR_0a00dc01 -VALIDATION_ERROR_00314:VALIDATION_ERROR_0a00d401 -VALIDATION_ERROR_00315:VALIDATION_ERROR_0a00a001 -VALIDATION_ERROR_00316:VALIDATION_ERROR_0a02ea01 -VALIDATION_ERROR_00317:VALIDATION_ERROR_31c29c01 -VALIDATION_ERROR_00318:VALIDATION_ERROR_27005601 -VALIDATION_ERROR_00319:VALIDATION_ERROR_22005601 -VALIDATION_ERROR_00320:VALIDATION_ERROR_22011e01 -VALIDATION_ERROR_00321:VALIDATION_ERROR_2200ec01 -VALIDATION_ERROR_00322:VALIDATION_ERROR_22021601 -VALIDATION_ERROR_00323:VALIDATION_ERROR_12200680 -VALIDATION_ERROR_00324:VALIDATION_ERROR_12200682 -VALIDATION_ERROR_00325:VALIDATION_ERROR_12200684 -VALIDATION_ERROR_00326:VALIDATION_ERROR_12200686 -VALIDATION_ERROR_00327:VALIDATION_ERROR_1222b00b -VALIDATION_ERROR_00328:VALIDATION_ERROR_1221c40d -VALIDATION_ERROR_00329:VALIDATION_ERROR_12209005 -VALIDATION_ERROR_00330:VALIDATION_ERROR_1220f201 -VALIDATION_ERROR_00331:VALIDATION_ERROR_12224201 -VALIDATION_ERROR_00332:VALIDATION_ERROR_12212601 -VALIDATION_ERROR_00333:VALIDATION_ERROR_1222e61b -VALIDATION_ERROR_00334:VALIDATION_ERROR_00800696 -VALIDATION_ERROR_00335:VALIDATION_ERROR_00809001 -VALIDATION_ERROR_00336:VALIDATION_ERROR_00809201 -VALIDATION_ERROR_00337:VALIDATION_ERROR_0082b401 -VALIDATION_ERROR_00338:VALIDATION_ERROR_0080c201 -VALIDATION_ERROR_00339:VALIDATION_ERROR_0082e401 -VALIDATION_ERROR_00340:VALIDATION_ERROR_0082e001 -VALIDATION_ERROR_00341:VALIDATION_ERROR_0082e201 -VALIDATION_ERROR_00342:VALIDATION_ERROR_0080b801 -VALIDATION_ERROR_00343:VALIDATION_ERROR_00808e01 -VALIDATION_ERROR_00347:VALIDATION_ERROR_14000698 -VALIDATION_ERROR_00348:VALIDATION_ERROR_1400069a -VALIDATION_ERROR_00349:VALIDATION_ERROR_1400069c -VALIDATION_ERROR_00350:VALIDATION_ERROR_1400069e -VALIDATION_ERROR_00351:VALIDATION_ERROR_140006a0 -VALIDATION_ERROR_00352:VALIDATION_ERROR_140006a2 -VALIDATION_ERROR_00353:VALIDATION_ERROR_140006a4 -VALIDATION_ERROR_00354:VALIDATION_ERROR_140006a6 -VALIDATION_ERROR_00355:VALIDATION_ERROR_140006a8 -VALIDATION_ERROR_00356:VALIDATION_ERROR_140006aa -VALIDATION_ERROR_00357:VALIDATION_ERROR_140006ac -VALIDATION_ERROR_00358:VALIDATION_ERROR_140006ae -VALIDATION_ERROR_00360:VALIDATION_ERROR_14027e01 -VALIDATION_ERROR_00361:VALIDATION_ERROR_14019a01 -VALIDATION_ERROR_00362:VALIDATION_ERROR_14011001 -VALIDATION_ERROR_00363:VALIDATION_ERROR_14021c01 -VALIDATION_ERROR_00364:VALIDATION_ERROR_14012a01 -VALIDATION_ERROR_00365:VALIDATION_ERROR_1401f001 -VALIDATION_ERROR_00366:VALIDATION_ERROR_00a006b2 -VALIDATION_ERROR_00367:VALIDATION_ERROR_00a0be01 -VALIDATION_ERROR_00368:VALIDATION_ERROR_13e006b8 -VALIDATION_ERROR_00369:VALIDATION_ERROR_13e006ba -VALIDATION_ERROR_00370:VALIDATION_ERROR_13e006bc -VALIDATION_ERROR_00371:VALIDATION_ERROR_13e006be -VALIDATION_ERROR_00372:VALIDATION_ERROR_13e006c0 -VALIDATION_ERROR_00373:VALIDATION_ERROR_13e006c2 -VALIDATION_ERROR_00374:VALIDATION_ERROR_13e006c4 -VALIDATION_ERROR_00375:VALIDATION_ERROR_13e006c6 -VALIDATION_ERROR_00376:VALIDATION_ERROR_13e2d401 -VALIDATION_ERROR_00377:VALIDATION_ERROR_13e2d403 -VALIDATION_ERROR_00378:VALIDATION_ERROR_13e07801 -VALIDATION_ERROR_00379:VALIDATION_ERROR_13e07803 -VALIDATION_ERROR_00380:VALIDATION_ERROR_13e2c401 -VALIDATION_ERROR_00381:VALIDATION_ERROR_13e06801 -VALIDATION_ERROR_00382:VALIDATION_ERROR_13e03e01 -VALIDATION_ERROR_00393:VALIDATION_ERROR_264006d2 -VALIDATION_ERROR_00394:VALIDATION_ERROR_264006d4 -VALIDATION_ERROR_00395:VALIDATION_ERROR_264006d6 -VALIDATION_ERROR_00396:VALIDATION_ERROR_26405601 -VALIDATION_ERROR_00397:VALIDATION_ERROR_2642ae01 -VALIDATION_ERROR_00398:VALIDATION_ERROR_2640ec01 -VALIDATION_ERROR_00399:VALIDATION_ERROR_2642ae07 -VALIDATION_ERROR_00400:VALIDATION_ERROR_20605601 -VALIDATION_ERROR_00401:VALIDATION_ERROR_20611e01 -VALIDATION_ERROR_00402:VALIDATION_ERROR_2060ec01 -VALIDATION_ERROR_00403:VALIDATION_ERROR_20617801 -VALIDATION_ERROR_00404:VALIDATION_ERROR_094006d8 -VALIDATION_ERROR_00405:VALIDATION_ERROR_094006da -VALIDATION_ERROR_00406:VALIDATION_ERROR_094006dc -VALIDATION_ERROR_00407:VALIDATION_ERROR_094006de -VALIDATION_ERROR_00408:VALIDATION_ERROR_094006e0 -VALIDATION_ERROR_00409:VALIDATION_ERROR_094006e2 -VALIDATION_ERROR_00410:VALIDATION_ERROR_094006e4 -VALIDATION_ERROR_00411:VALIDATION_ERROR_094006e6 -VALIDATION_ERROR_00412:VALIDATION_ERROR_094006e8 -VALIDATION_ERROR_00413:VALIDATION_ERROR_094006ec -VALIDATION_ERROR_00414:VALIDATION_ERROR_094006f0 -VALIDATION_ERROR_00415:VALIDATION_ERROR_094006f4 -VALIDATION_ERROR_00416:VALIDATION_ERROR_0942b00b -VALIDATION_ERROR_00417:VALIDATION_ERROR_0941c40d -VALIDATION_ERROR_00418:VALIDATION_ERROR_09409005 -VALIDATION_ERROR_00419:VALIDATION_ERROR_0942ae01 -VALIDATION_ERROR_00420:VALIDATION_ERROR_0940f201 -VALIDATION_ERROR_00421:VALIDATION_ERROR_09400009 -VALIDATION_ERROR_00422:VALIDATION_ERROR_250006f8 -VALIDATION_ERROR_00423:VALIDATION_ERROR_250006fa -VALIDATION_ERROR_00424:VALIDATION_ERROR_250006fc -VALIDATION_ERROR_00425:VALIDATION_ERROR_25005601 -VALIDATION_ERROR_00426:VALIDATION_ERROR_25009401 -VALIDATION_ERROR_00427:VALIDATION_ERROR_2500ec01 -VALIDATION_ERROR_00428:VALIDATION_ERROR_25009407 -VALIDATION_ERROR_00429:VALIDATION_ERROR_17a006fe -VALIDATION_ERROR_00430:VALIDATION_ERROR_17a00700 -VALIDATION_ERROR_00431:VALIDATION_ERROR_17a00702 -VALIDATION_ERROR_00432:VALIDATION_ERROR_17a00704 -VALIDATION_ERROR_00433:VALIDATION_ERROR_17a00706 -VALIDATION_ERROR_00434:VALIDATION_ERROR_17a00708 -VALIDATION_ERROR_00435:VALIDATION_ERROR_17a02401 -VALIDATION_ERROR_00436:VALIDATION_ERROR_17a21801 -VALIDATION_ERROR_00437:VALIDATION_ERROR_17a03201 -VALIDATION_ERROR_00438:VALIDATION_ERROR_17a02413 -VALIDATION_ERROR_00439:VALIDATION_ERROR_17a02415 -VALIDATION_ERROR_00440:VALIDATION_ERROR_17a00017 -VALIDATION_ERROR_00441:VALIDATION_ERROR_17a00019 -VALIDATION_ERROR_00442:VALIDATION_ERROR_1200070c -VALIDATION_ERROR_00443:VALIDATION_ERROR_1202b00b -VALIDATION_ERROR_00445:VALIDATION_ERROR_1202ae01 -VALIDATION_ERROR_00446:VALIDATION_ERROR_12009401 -VALIDATION_ERROR_00447:VALIDATION_ERROR_1200070e -VALIDATION_ERROR_00448:VALIDATION_ERROR_12000009 -VALIDATION_ERROR_00449:VALIDATION_ERROR_30005601 -VALIDATION_ERROR_00450:VALIDATION_ERROR_3002ae01 -VALIDATION_ERROR_00451:VALIDATION_ERROR_30017a01 -VALIDATION_ERROR_00452:VALIDATION_ERROR_3002ae07 -VALIDATION_ERROR_00453:VALIDATION_ERROR_1b60071a -VALIDATION_ERROR_00454:VALIDATION_ERROR_1b602401 -VALIDATION_ERROR_00455:VALIDATION_ERROR_1b603201 -VALIDATION_ERROR_00456:VALIDATION_ERROR_1b602413 -VALIDATION_ERROR_00457:VALIDATION_ERROR_1b602415 -VALIDATION_ERROR_00458:VALIDATION_ERROR_1b600017 -VALIDATION_ERROR_00459:VALIDATION_ERROR_1b600019 -VALIDATION_ERROR_00460:VALIDATION_ERROR_1b00071c -VALIDATION_ERROR_00461:VALIDATION_ERROR_1b002401 -VALIDATION_ERROR_00462:VALIDATION_ERROR_1b002413 -VALIDATION_ERROR_00463:VALIDATION_ERROR_1b002415 -VALIDATION_ERROR_00464:VALIDATION_ERROR_1b000017 -VALIDATION_ERROR_00465:VALIDATION_ERROR_1b000019 -VALIDATION_ERROR_00466:VALIDATION_ERROR_22605601 -VALIDATION_ERROR_00467:VALIDATION_ERROR_22611e01 -VALIDATION_ERROR_00468:VALIDATION_ERROR_2260ec01 -VALIDATION_ERROR_00469:VALIDATION_ERROR_22622e01 -VALIDATION_ERROR_00470:VALIDATION_ERROR_12a0087a -VALIDATION_ERROR_00474:VALIDATION_ERROR_12a00882 -VALIDATION_ERROR_00475:VALIDATION_ERROR_12a2b00b -VALIDATION_ERROR_00476:VALIDATION_ERROR_12a1c40d -VALIDATION_ERROR_00477:VALIDATION_ERROR_12a09005 -VALIDATION_ERROR_00479:VALIDATION_ERROR_26a00888 -VALIDATION_ERROR_00480:VALIDATION_ERROR_26a0088a -VALIDATION_ERROR_00481:VALIDATION_ERROR_26a05601 -VALIDATION_ERROR_00482:VALIDATION_ERROR_26a2be01 -VALIDATION_ERROR_00483:VALIDATION_ERROR_26a0ec01 -VALIDATION_ERROR_00484:VALIDATION_ERROR_26a2be07 -VALIDATION_ERROR_00485:VALIDATION_ERROR_1f20056e -VALIDATION_ERROR_00486:VALIDATION_ERROR_1f205601 -VALIDATION_ERROR_00487:VALIDATION_ERROR_1f228001 -VALIDATION_ERROR_00488:VALIDATION_ERROR_1f212001 -VALIDATION_ERROR_00489:VALIDATION_ERROR_1f20ec01 -VALIDATION_ERROR_00490:VALIDATION_ERROR_1f21e201 -VALIDATION_ERROR_00491:VALIDATION_ERROR_1f20381b -VALIDATION_ERROR_00492:VALIDATION_ERROR_1f228007 -VALIDATION_ERROR_00493:VALIDATION_ERROR_03000576 -VALIDATION_ERROR_00494:VALIDATION_ERROR_03000574 -VALIDATION_ERROR_00495:VALIDATION_ERROR_03000578 -VALIDATION_ERROR_00496:VALIDATION_ERROR_03000572 -VALIDATION_ERROR_00498:VALIDATION_ERROR_0300057a -VALIDATION_ERROR_00499:VALIDATION_ERROR_0300057c -VALIDATION_ERROR_00500:VALIDATION_ERROR_0300057e -VALIDATION_ERROR_00501:VALIDATION_ERROR_0302b00b -VALIDATION_ERROR_00502:VALIDATION_ERROR_0301c40d -VALIDATION_ERROR_00503:VALIDATION_ERROR_03009001 -VALIDATION_ERROR_00504:VALIDATION_ERROR_0302d801 -VALIDATION_ERROR_00505:VALIDATION_ERROR_0300be01 -VALIDATION_ERROR_00506:VALIDATION_ERROR_03000009 -VALIDATION_ERROR_00507:VALIDATION_ERROR_10600580 -VALIDATION_ERROR_00508:VALIDATION_ERROR_10600582 -VALIDATION_ERROR_00509:VALIDATION_ERROR_10600584 -VALIDATION_ERROR_00510:VALIDATION_ERROR_10600586 -VALIDATION_ERROR_00511:VALIDATION_ERROR_1062b00b -VALIDATION_ERROR_00512:VALIDATION_ERROR_1061c40d -VALIDATION_ERROR_00513:VALIDATION_ERROR_10609005 -VALIDATION_ERROR_00514:VALIDATION_ERROR_1062d801 -VALIDATION_ERROR_00515:VALIDATION_ERROR_1060d201 -VALIDATION_ERROR_00516:VALIDATION_ERROR_1061c001 -VALIDATION_ERROR_00517:VALIDATION_ERROR_10623a01 -VALIDATION_ERROR_00518:VALIDATION_ERROR_208005a0 -VALIDATION_ERROR_00519:VALIDATION_ERROR_20805601 -VALIDATION_ERROR_00520:VALIDATION_ERROR_20828001 -VALIDATION_ERROR_00521:VALIDATION_ERROR_20812001 -VALIDATION_ERROR_00522:VALIDATION_ERROR_2080ec01 -VALIDATION_ERROR_00523:VALIDATION_ERROR_2081e201 -VALIDATION_ERROR_00524:VALIDATION_ERROR_2080381b -VALIDATION_ERROR_00525:VALIDATION_ERROR_20828007 -VALIDATION_ERROR_00526:VALIDATION_ERROR_096005a8 -VALIDATION_ERROR_00527:VALIDATION_ERROR_096005a6 -VALIDATION_ERROR_00528:VALIDATION_ERROR_096005aa -VALIDATION_ERROR_00529:VALIDATION_ERROR_096005a4 -VALIDATION_ERROR_00531:VALIDATION_ERROR_096005ac -VALIDATION_ERROR_00532:VALIDATION_ERROR_096005ae -VALIDATION_ERROR_00533:VALIDATION_ERROR_096005b0 -VALIDATION_ERROR_00534:VALIDATION_ERROR_096005b2 -VALIDATION_ERROR_00535:VALIDATION_ERROR_096005b4 -VALIDATION_ERROR_00536:VALIDATION_ERROR_096005b6 -VALIDATION_ERROR_00537:VALIDATION_ERROR_096005b8 -VALIDATION_ERROR_00538:VALIDATION_ERROR_0962b00b -VALIDATION_ERROR_00539:VALIDATION_ERROR_0961c40d -VALIDATION_ERROR_00540:VALIDATION_ERROR_09609001 -VALIDATION_ERROR_00541:VALIDATION_ERROR_09623e01 -VALIDATION_ERROR_00542:VALIDATION_ERROR_09626801 -VALIDATION_ERROR_00543:VALIDATION_ERROR_09619801 -VALIDATION_ERROR_00544:VALIDATION_ERROR_09620801 -VALIDATION_ERROR_00545:VALIDATION_ERROR_09615601 -VALIDATION_ERROR_00546:VALIDATION_ERROR_0960be01 -VALIDATION_ERROR_00547:VALIDATION_ERROR_0962ae01 -VALIDATION_ERROR_00548:VALIDATION_ERROR_0962da1b -VALIDATION_ERROR_00549:VALIDATION_ERROR_09600009 -VALIDATION_ERROR_00550:VALIDATION_ERROR_0fa2b00b -VALIDATION_ERROR_00551:VALIDATION_ERROR_0fa1c40d -VALIDATION_ERROR_00552:VALIDATION_ERROR_0fa09005 -VALIDATION_ERROR_00553:VALIDATION_ERROR_0fa15801 -VALIDATION_ERROR_00554:VALIDATION_ERROR_0fa07c1b -VALIDATION_ERROR_00555:VALIDATION_ERROR_25c005fa -VALIDATION_ERROR_00556:VALIDATION_ERROR_25c005fc -VALIDATION_ERROR_00557:VALIDATION_ERROR_25c005fe -VALIDATION_ERROR_00558:VALIDATION_ERROR_25c05601 -VALIDATION_ERROR_00559:VALIDATION_ERROR_25c27c01 -VALIDATION_ERROR_00560:VALIDATION_ERROR_25c0ec01 -VALIDATION_ERROR_00561:VALIDATION_ERROR_25c27c07 -VALIDATION_ERROR_00562:VALIDATION_ERROR_21a05601 -VALIDATION_ERROR_00563:VALIDATION_ERROR_21a11e01 -VALIDATION_ERROR_00564:VALIDATION_ERROR_21a0ec01 -VALIDATION_ERROR_00565:VALIDATION_ERROR_21a1de01 -VALIDATION_ERROR_00566:VALIDATION_ERROR_0f000600 -VALIDATION_ERROR_00567:VALIDATION_ERROR_0f02b00b -VALIDATION_ERROR_00568:VALIDATION_ERROR_0f01c40d -VALIDATION_ERROR_00569:VALIDATION_ERROR_0f009005 -VALIDATION_ERROR_00570:VALIDATION_ERROR_0f019601 -VALIDATION_ERROR_00571:VALIDATION_ERROR_31400604 -VALIDATION_ERROR_00572:VALIDATION_ERROR_31405601 -VALIDATION_ERROR_00573:VALIDATION_ERROR_31406e01 -VALIDATION_ERROR_00574:VALIDATION_ERROR_31423c01 -VALIDATION_ERROR_00575:VALIDATION_ERROR_3142ca1b -VALIDATION_ERROR_00576:VALIDATION_ERROR_31406e07 -VALIDATION_ERROR_00577:VALIDATION_ERROR_31423c07 -VALIDATION_ERROR_00578:VALIDATION_ERROR_2f805601 -VALIDATION_ERROR_00579:VALIDATION_ERROR_2f828001 -VALIDATION_ERROR_00580:VALIDATION_ERROR_2f812401 -VALIDATION_ERROR_00581:VALIDATION_ERROR_2f812201 -VALIDATION_ERROR_00582:VALIDATION_ERROR_2f828007 -VALIDATION_ERROR_00583:VALIDATION_ERROR_25e00606 -VALIDATION_ERROR_00584:VALIDATION_ERROR_25e00608 -VALIDATION_ERROR_00585:VALIDATION_ERROR_25e05601 -VALIDATION_ERROR_00586:VALIDATION_ERROR_25e28001 -VALIDATION_ERROR_00587:VALIDATION_ERROR_25e0ec01 -VALIDATION_ERROR_00588:VALIDATION_ERROR_25e28007 -VALIDATION_ERROR_00589:VALIDATION_ERROR_1360060a -VALIDATION_ERROR_00590:VALIDATION_ERROR_1360060c -VALIDATION_ERROR_00591:VALIDATION_ERROR_1360060e -VALIDATION_ERROR_00592:VALIDATION_ERROR_13612201 -VALIDATION_ERROR_00593:VALIDATION_ERROR_13800610 -VALIDATION_ERROR_00594:VALIDATION_ERROR_18000612 -VALIDATION_ERROR_00595:VALIDATION_ERROR_18000614 -VALIDATION_ERROR_00596:VALIDATION_ERROR_18000616 -VALIDATION_ERROR_00597:VALIDATION_ERROR_18000618 -VALIDATION_ERROR_00598:VALIDATION_ERROR_1800061a -VALIDATION_ERROR_00599:VALIDATION_ERROR_18002401 -VALIDATION_ERROR_00600:VALIDATION_ERROR_18027e01 -VALIDATION_ERROR_00601:VALIDATION_ERROR_18027c01 -VALIDATION_ERROR_00602:VALIDATION_ERROR_18002413 -VALIDATION_ERROR_00603:VALIDATION_ERROR_18002415 -VALIDATION_ERROR_00604:VALIDATION_ERROR_18000009 -VALIDATION_ERROR_00605:VALIDATION_ERROR_002004f0 -VALIDATION_ERROR_00606:VALIDATION_ERROR_002004f2 -VALIDATION_ERROR_00607:VALIDATION_ERROR_002004f4 -VALIDATION_ERROR_00608:VALIDATION_ERROR_002004f6 -VALIDATION_ERROR_00609:VALIDATION_ERROR_2ce27a01 -VALIDATION_ERROR_00610:VALIDATION_ERROR_2ce1b001 -VALIDATION_ERROR_00611:VALIDATION_ERROR_16c004f8 -VALIDATION_ERROR_00612:VALIDATION_ERROR_16c05601 -VALIDATION_ERROR_00613:VALIDATION_ERROR_16c0ea01 -VALIDATION_ERROR_00614:VALIDATION_ERROR_16c0ec01 -VALIDATION_ERROR_00615:VALIDATION_ERROR_16c1aa01 -VALIDATION_ERROR_00616:VALIDATION_ERROR_0c6004fa -VALIDATION_ERROR_00617:VALIDATION_ERROR_0c6004fc -VALIDATION_ERROR_00618:VALIDATION_ERROR_0c62b00b -VALIDATION_ERROR_00620:VALIDATION_ERROR_2880054a -VALIDATION_ERROR_00621:VALIDATION_ERROR_28805601 -VALIDATION_ERROR_00622:VALIDATION_ERROR_2880c601 -VALIDATION_ERROR_00623:VALIDATION_ERROR_2880ec01 -VALIDATION_ERROR_00624:VALIDATION_ERROR_2880c607 -VALIDATION_ERROR_00625:VALIDATION_ERROR_3120054c -VALIDATION_ERROR_00626:VALIDATION_ERROR_3120054e -VALIDATION_ERROR_00627:VALIDATION_ERROR_31200550 -VALIDATION_ERROR_00628:VALIDATION_ERROR_31200552 -VALIDATION_ERROR_00629:VALIDATION_ERROR_31200554 -VALIDATION_ERROR_00630:VALIDATION_ERROR_31205601 -VALIDATION_ERROR_00631:VALIDATION_ERROR_3120c601 -VALIDATION_ERROR_00632:VALIDATION_ERROR_31209005 -VALIDATION_ERROR_00633:VALIDATION_ERROR_31228c01 -VALIDATION_ERROR_00634:VALIDATION_ERROR_3120c607 -VALIDATION_ERROR_00635:VALIDATION_ERROR_28205601 -VALIDATION_ERROR_00636:VALIDATION_ERROR_2821b201 -VALIDATION_ERROR_00637:VALIDATION_ERROR_2820c81b -VALIDATION_ERROR_00638:VALIDATION_ERROR_31005601 -VALIDATION_ERROR_00639:VALIDATION_ERROR_3101b201 -VALIDATION_ERROR_00640:VALIDATION_ERROR_3100c81b -VALIDATION_ERROR_00641:VALIDATION_ERROR_0c200558 -VALIDATION_ERROR_00642:VALIDATION_ERROR_0c20055a -VALIDATION_ERROR_00643:VALIDATION_ERROR_0c20055c -VALIDATION_ERROR_00644:VALIDATION_ERROR_0c20055e -VALIDATION_ERROR_00645:VALIDATION_ERROR_0c200560 -VALIDATION_ERROR_00646:VALIDATION_ERROR_0c22b00b -VALIDATION_ERROR_00647:VALIDATION_ERROR_0c21c40d -VALIDATION_ERROR_00648:VALIDATION_ERROR_0c20c601 -VALIDATION_ERROR_00649:VALIDATION_ERROR_33600562 -VALIDATION_ERROR_00650:VALIDATION_ERROR_33605601 -VALIDATION_ERROR_00651:VALIDATION_ERROR_3360c601 -VALIDATION_ERROR_00652:VALIDATION_ERROR_3360c607 -VALIDATION_ERROR_00653:VALIDATION_ERROR_29200564 -VALIDATION_ERROR_00654:VALIDATION_ERROR_29205601 -VALIDATION_ERROR_00655:VALIDATION_ERROR_2920c601 -VALIDATION_ERROR_00656:VALIDATION_ERROR_29211801 -VALIDATION_ERROR_00657:VALIDATION_ERROR_2920c607 -VALIDATION_ERROR_00658:VALIDATION_ERROR_1ec0071e -VALIDATION_ERROR_00659:VALIDATION_ERROR_1ec05601 -VALIDATION_ERROR_00660:VALIDATION_ERROR_1ec11e01 -VALIDATION_ERROR_00661:VALIDATION_ERROR_1ec0ec01 -VALIDATION_ERROR_00662:VALIDATION_ERROR_1ec10001 -VALIDATION_ERROR_00663:VALIDATION_ERROR_01400720 -VALIDATION_ERROR_00664:VALIDATION_ERROR_01400722 -VALIDATION_ERROR_00665:VALIDATION_ERROR_01400724 -VALIDATION_ERROR_00666:VALIDATION_ERROR_01400726 -VALIDATION_ERROR_00667:VALIDATION_ERROR_01400728 -VALIDATION_ERROR_00668:VALIDATION_ERROR_0140072a -VALIDATION_ERROR_00669:VALIDATION_ERROR_0140072c -VALIDATION_ERROR_00670:VALIDATION_ERROR_0142b00b -VALIDATION_ERROR_00672:VALIDATION_ERROR_01409001 -VALIDATION_ERROR_00673:VALIDATION_ERROR_01430601 -VALIDATION_ERROR_00674:VALIDATION_ERROR_01430603 -VALIDATION_ERROR_00675:VALIDATION_ERROR_0142c001 -VALIDATION_ERROR_00676:VALIDATION_ERROR_23c00734 -VALIDATION_ERROR_00677:VALIDATION_ERROR_23c00736 -VALIDATION_ERROR_00678:VALIDATION_ERROR_23c00738 -VALIDATION_ERROR_00679:VALIDATION_ERROR_23c05601 -VALIDATION_ERROR_00680:VALIDATION_ERROR_23c01a01 -VALIDATION_ERROR_00681:VALIDATION_ERROR_23c0ec01 -VALIDATION_ERROR_00682:VALIDATION_ERROR_23c01a07 -VALIDATION_ERROR_00683:VALIDATION_ERROR_1ee05601 -VALIDATION_ERROR_00684:VALIDATION_ERROR_1ee11e01 -VALIDATION_ERROR_00685:VALIDATION_ERROR_1ee0ec01 -VALIDATION_ERROR_00686:VALIDATION_ERROR_1ee26a01 -VALIDATION_ERROR_00687:VALIDATION_ERROR_01a0073a -VALIDATION_ERROR_00688:VALIDATION_ERROR_01a0073c -VALIDATION_ERROR_00691:VALIDATION_ERROR_01a00742 -VALIDATION_ERROR_00692:VALIDATION_ERROR_01a00744 -VALIDATION_ERROR_00693:VALIDATION_ERROR_01a00746 -VALIDATION_ERROR_00694:VALIDATION_ERROR_01a00748 -VALIDATION_ERROR_00695:VALIDATION_ERROR_01a0074a -VALIDATION_ERROR_00696:VALIDATION_ERROR_01a2b00b -VALIDATION_ERROR_00697:VALIDATION_ERROR_01a1c40d -VALIDATION_ERROR_00698:VALIDATION_ERROR_01a09005 -VALIDATION_ERROR_00699:VALIDATION_ERROR_01a01a01 -VALIDATION_ERROR_00700:VALIDATION_ERROR_01a09201 -VALIDATION_ERROR_00701:VALIDATION_ERROR_23e00750 -VALIDATION_ERROR_00702:VALIDATION_ERROR_23e00752 -VALIDATION_ERROR_00703:VALIDATION_ERROR_23e00754 -VALIDATION_ERROR_00704:VALIDATION_ERROR_23e05601 -VALIDATION_ERROR_00705:VALIDATION_ERROR_23e01c01 -VALIDATION_ERROR_00706:VALIDATION_ERROR_23e0ec01 -VALIDATION_ERROR_00707:VALIDATION_ERROR_23e01c07 -VALIDATION_ERROR_00708:VALIDATION_ERROR_20c00756 -VALIDATION_ERROR_00709:VALIDATION_ERROR_20c05601 -VALIDATION_ERROR_00710:VALIDATION_ERROR_20c11e01 -VALIDATION_ERROR_00711:VALIDATION_ERROR_20c0ec01 -VALIDATION_ERROR_00712:VALIDATION_ERROR_20c17e01 -VALIDATION_ERROR_00713:VALIDATION_ERROR_09e0075a -VALIDATION_ERROR_00714:VALIDATION_ERROR_09e0075c -VALIDATION_ERROR_00715:VALIDATION_ERROR_09e0075e -VALIDATION_ERROR_00717:VALIDATION_ERROR_09e00766 -VALIDATION_ERROR_00718:VALIDATION_ERROR_09e00768 -VALIDATION_ERROR_00719:VALIDATION_ERROR_09e0076a -VALIDATION_ERROR_00720:VALIDATION_ERROR_09e0076e -VALIDATION_ERROR_00721:VALIDATION_ERROR_09e2b00b -VALIDATION_ERROR_00723:VALIDATION_ERROR_09e09001 -VALIDATION_ERROR_00724:VALIDATION_ERROR_09e0ac01 -VALIDATION_ERROR_00725:VALIDATION_ERROR_09e09201 -VALIDATION_ERROR_00726:VALIDATION_ERROR_09e2b401 -VALIDATION_ERROR_00727:VALIDATION_ERROR_09e2fa01 -VALIDATION_ERROR_00728:VALIDATION_ERROR_09e30601 -VALIDATION_ERROR_00729:VALIDATION_ERROR_09e30603 -VALIDATION_ERROR_00730:VALIDATION_ERROR_09e2c001 -VALIDATION_ERROR_00731:VALIDATION_ERROR_09e0b801 -VALIDATION_ERROR_00732:VALIDATION_ERROR_2a6007c8 -VALIDATION_ERROR_00733:VALIDATION_ERROR_2a6007ca -VALIDATION_ERROR_00734:VALIDATION_ERROR_2a605601 -VALIDATION_ERROR_00735:VALIDATION_ERROR_2a60a001 -VALIDATION_ERROR_00736:VALIDATION_ERROR_2a624401 -VALIDATION_ERROR_00737:VALIDATION_ERROR_2a61a201 -VALIDATION_ERROR_00738:VALIDATION_ERROR_2a60a007 -VALIDATION_ERROR_00739:VALIDATION_ERROR_0a4007cc -VALIDATION_ERROR_00740:VALIDATION_ERROR_0a4007ce -VALIDATION_ERROR_00741:VALIDATION_ERROR_0a400c01 -VALIDATION_ERROR_00742:VALIDATION_ERROR_0a400c03 -VALIDATION_ERROR_00743:VALIDATION_ERROR_252007d0 -VALIDATION_ERROR_00744:VALIDATION_ERROR_252007d2 -VALIDATION_ERROR_00745:VALIDATION_ERROR_252007d4 -VALIDATION_ERROR_00746:VALIDATION_ERROR_25205601 -VALIDATION_ERROR_00747:VALIDATION_ERROR_2520a001 -VALIDATION_ERROR_00748:VALIDATION_ERROR_2520ec01 -VALIDATION_ERROR_00749:VALIDATION_ERROR_2520a007 -VALIDATION_ERROR_00750:VALIDATION_ERROR_20e05601 -VALIDATION_ERROR_00751:VALIDATION_ERROR_20e11e01 -VALIDATION_ERROR_00752:VALIDATION_ERROR_20e0ec01 -VALIDATION_ERROR_00753:VALIDATION_ERROR_20e26a01 -VALIDATION_ERROR_00754:VALIDATION_ERROR_0ac007d6 -VALIDATION_ERROR_00755:VALIDATION_ERROR_0ac007d8 -VALIDATION_ERROR_00759:VALIDATION_ERROR_0ac007dc -VALIDATION_ERROR_00760:VALIDATION_ERROR_0ac2b00b -VALIDATION_ERROR_00761:VALIDATION_ERROR_0ac1c40d -VALIDATION_ERROR_00762:VALIDATION_ERROR_0ac09005 -VALIDATION_ERROR_00763:VALIDATION_ERROR_0ac0a001 -VALIDATION_ERROR_00764:VALIDATION_ERROR_0ac30801 -VALIDATION_ERROR_00765:VALIDATION_ERROR_0ac09201 -VALIDATION_ERROR_00766:VALIDATION_ERROR_0ac02c01 -VALIDATION_ERROR_00767:VALIDATION_ERROR_0ac2ea01 -VALIDATION_ERROR_00768:VALIDATION_ERROR_0a8007fc -VALIDATION_ERROR_00769:VALIDATION_ERROR_0a800800 -VALIDATION_ERROR_00770:VALIDATION_ERROR_0a800c01 -VALIDATION_ERROR_00771:VALIDATION_ERROR_0a800c03 -VALIDATION_ERROR_00772:VALIDATION_ERROR_02e2a201 -VALIDATION_ERROR_00773:VALIDATION_ERROR_02e09a01 -VALIDATION_ERROR_00774:VALIDATION_ERROR_02e01001 -VALIDATION_ERROR_00775:VALIDATION_ERROR_02e00001 -VALIDATION_ERROR_00776:VALIDATION_ERROR_25400804 -VALIDATION_ERROR_00777:VALIDATION_ERROR_25400806 -VALIDATION_ERROR_00778:VALIDATION_ERROR_25400808 -VALIDATION_ERROR_00779:VALIDATION_ERROR_25405601 -VALIDATION_ERROR_00780:VALIDATION_ERROR_2540b001 -VALIDATION_ERROR_00781:VALIDATION_ERROR_2540ec01 -VALIDATION_ERROR_00782:VALIDATION_ERROR_2540b007 -VALIDATION_ERROR_00783:VALIDATION_ERROR_28a05601 -VALIDATION_ERROR_00784:VALIDATION_ERROR_28a01a01 -VALIDATION_ERROR_00785:VALIDATION_ERROR_28a1b401 -VALIDATION_ERROR_00786:VALIDATION_ERROR_28a01a07 -VALIDATION_ERROR_00787:VALIDATION_ERROR_2a205601 -VALIDATION_ERROR_00788:VALIDATION_ERROR_2a20a001 -VALIDATION_ERROR_00789:VALIDATION_ERROR_2a21b401 -VALIDATION_ERROR_00790:VALIDATION_ERROR_2a20a007 -VALIDATION_ERROR_00791:VALIDATION_ERROR_1700080a -VALIDATION_ERROR_00792:VALIDATION_ERROR_1700080c -VALIDATION_ERROR_00793:VALIDATION_ERROR_1700080e -VALIDATION_ERROR_00794:VALIDATION_ERROR_17000810 -VALIDATION_ERROR_00795:VALIDATION_ERROR_17000812 -VALIDATION_ERROR_00796:VALIDATION_ERROR_17000814 -VALIDATION_ERROR_00797:VALIDATION_ERROR_17000816 -VALIDATION_ERROR_00798:VALIDATION_ERROR_17005601 -VALIDATION_ERROR_00799:VALIDATION_ERROR_17001a01 -VALIDATION_ERROR_00800:VALIDATION_ERROR_1700c601 -VALIDATION_ERROR_00801:VALIDATION_ERROR_17001a07 -VALIDATION_ERROR_00802:VALIDATION_ERROR_1700c607 -VALIDATION_ERROR_00803:VALIDATION_ERROR_17400828 -VALIDATION_ERROR_00804:VALIDATION_ERROR_1740082a -VALIDATION_ERROR_00805:VALIDATION_ERROR_1740082c -VALIDATION_ERROR_00806:VALIDATION_ERROR_1740082e -VALIDATION_ERROR_00807:VALIDATION_ERROR_17405601 -VALIDATION_ERROR_00808:VALIDATION_ERROR_1740a001 -VALIDATION_ERROR_00809:VALIDATION_ERROR_1740c601 -VALIDATION_ERROR_00810:VALIDATION_ERROR_1740a007 -VALIDATION_ERROR_00811:VALIDATION_ERROR_1740c607 -VALIDATION_ERROR_00812:VALIDATION_ERROR_22205601 -VALIDATION_ERROR_00813:VALIDATION_ERROR_22211e01 -VALIDATION_ERROR_00814:VALIDATION_ERROR_2220ec01 -VALIDATION_ERROR_00815:VALIDATION_ERROR_22222401 -VALIDATION_ERROR_00816:VALIDATION_ERROR_1260085a -VALIDATION_ERROR_00817:VALIDATION_ERROR_1260085c -VALIDATION_ERROR_00818:VALIDATION_ERROR_1260085e -VALIDATION_ERROR_00819:VALIDATION_ERROR_12600860 -VALIDATION_ERROR_00820:VALIDATION_ERROR_12600862 -VALIDATION_ERROR_00821:VALIDATION_ERROR_12600864 -VALIDATION_ERROR_00822:VALIDATION_ERROR_12600866 -VALIDATION_ERROR_00823:VALIDATION_ERROR_12600868 -VALIDATION_ERROR_00824:VALIDATION_ERROR_1260086a -VALIDATION_ERROR_00825:VALIDATION_ERROR_1260086c -VALIDATION_ERROR_00826:VALIDATION_ERROR_1260086e -VALIDATION_ERROR_00827:VALIDATION_ERROR_12600870 -VALIDATION_ERROR_00828:VALIDATION_ERROR_1262b00b -VALIDATION_ERROR_00829:VALIDATION_ERROR_1261c40d -VALIDATION_ERROR_00830:VALIDATION_ERROR_12609005 -VALIDATION_ERROR_00831:VALIDATION_ERROR_1260c401 -VALIDATION_ERROR_00832:VALIDATION_ERROR_1260ca01 -VALIDATION_ERROR_00833:VALIDATION_ERROR_1260cc01 -VALIDATION_ERROR_00834:VALIDATION_ERROR_12600201 -VALIDATION_ERROR_00835:VALIDATION_ERROR_12600401 -VALIDATION_ERROR_00836:VALIDATION_ERROR_12600601 -VALIDATION_ERROR_00837:VALIDATION_ERROR_26600874 -VALIDATION_ERROR_00838:VALIDATION_ERROR_26600876 -VALIDATION_ERROR_00839:VALIDATION_ERROR_26600878 -VALIDATION_ERROR_00840:VALIDATION_ERROR_26605601 -VALIDATION_ERROR_00841:VALIDATION_ERROR_2662b201 -VALIDATION_ERROR_00842:VALIDATION_ERROR_2660ec01 -VALIDATION_ERROR_00843:VALIDATION_ERROR_2662b207 -VALIDATION_ERROR_00844:VALIDATION_ERROR_1f805601 -VALIDATION_ERROR_00845:VALIDATION_ERROR_1f811e01 -VALIDATION_ERROR_00846:VALIDATION_ERROR_1f80ec01 -VALIDATION_ERROR_00847:VALIDATION_ERROR_1f822a01 -VALIDATION_ERROR_00848:VALIDATION_ERROR_0502b00b -VALIDATION_ERROR_00849:VALIDATION_ERROR_0501c40d -VALIDATION_ERROR_00851:VALIDATION_ERROR_0500fc01 -VALIDATION_ERROR_00852:VALIDATION_ERROR_04e00234 -VALIDATION_ERROR_00853:VALIDATION_ERROR_04e00236 -VALIDATION_ERROR_00854:VALIDATION_ERROR_04e04e01 -VALIDATION_ERROR_00855:VALIDATION_ERROR_24600238 -VALIDATION_ERROR_00856:VALIDATION_ERROR_2460023a -VALIDATION_ERROR_00857:VALIDATION_ERROR_24605601 -VALIDATION_ERROR_00858:VALIDATION_ERROR_24604c01 -VALIDATION_ERROR_00859:VALIDATION_ERROR_2460ec01 -VALIDATION_ERROR_00860:VALIDATION_ERROR_24604c07 -VALIDATION_ERROR_00861:VALIDATION_ERROR_21c05601 -VALIDATION_ERROR_00862:VALIDATION_ERROR_21c11e01 -VALIDATION_ERROR_00863:VALIDATION_ERROR_21c0ec01 -VALIDATION_ERROR_00864:VALIDATION_ERROR_21c1e001 -VALIDATION_ERROR_00865:VALIDATION_ERROR_0fe0023c -VALIDATION_ERROR_00866:VALIDATION_ERROR_0fe0023e -VALIDATION_ERROR_00867:VALIDATION_ERROR_0fe00240 -VALIDATION_ERROR_00868:VALIDATION_ERROR_0fe00242 -VALIDATION_ERROR_00869:VALIDATION_ERROR_0fe00244 -VALIDATION_ERROR_00870:VALIDATION_ERROR_0fe00246 -VALIDATION_ERROR_00871:VALIDATION_ERROR_0fe00248 -VALIDATION_ERROR_00872:VALIDATION_ERROR_0fe2b00b -VALIDATION_ERROR_00873:VALIDATION_ERROR_0fe1c40d -VALIDATION_ERROR_00874:VALIDATION_ERROR_0fe09005 -VALIDATION_ERROR_00875:VALIDATION_ERROR_0fe22c01 -VALIDATION_ERROR_00876:VALIDATION_ERROR_0fe1f801 -VALIDATION_ERROR_00877:VALIDATION_ERROR_11a0024c -VALIDATION_ERROR_00878:VALIDATION_ERROR_11a00250 -VALIDATION_ERROR_00879:VALIDATION_ERROR_11a00252 -VALIDATION_ERROR_00880:VALIDATION_ERROR_11a00254 -VALIDATION_ERROR_00881:VALIDATION_ERROR_11a2dc01 -VALIDATION_ERROR_00882:VALIDATION_ERROR_11a2dc03 -VALIDATION_ERROR_00883:VALIDATION_ERROR_26000256 -VALIDATION_ERROR_00884:VALIDATION_ERROR_26000258 -VALIDATION_ERROR_00885:VALIDATION_ERROR_26005601 -VALIDATION_ERROR_00886:VALIDATION_ERROR_26028201 -VALIDATION_ERROR_00887:VALIDATION_ERROR_2600ec01 -VALIDATION_ERROR_00888:VALIDATION_ERROR_26028207 -VALIDATION_ERROR_00889:VALIDATION_ERROR_1f605601 -VALIDATION_ERROR_00890:VALIDATION_ERROR_1f611e01 -VALIDATION_ERROR_00891:VALIDATION_ERROR_1f60ec01 -VALIDATION_ERROR_00892:VALIDATION_ERROR_1f612e01 -VALIDATION_ERROR_00893:VALIDATION_ERROR_0480025a -VALIDATION_ERROR_00894:VALIDATION_ERROR_0482b00b -VALIDATION_ERROR_00895:VALIDATION_ERROR_0481c40d -VALIDATION_ERROR_00896:VALIDATION_ERROR_04809001 -VALIDATION_ERROR_00897:VALIDATION_ERROR_0481e401 -VALIDATION_ERROR_00898:VALIDATION_ERROR_0482881b -VALIDATION_ERROR_00899:VALIDATION_ERROR_04a0025c -VALIDATION_ERROR_00900:VALIDATION_ERROR_04a30401 -VALIDATION_ERROR_00901:VALIDATION_ERROR_2440025e -VALIDATION_ERROR_00902:VALIDATION_ERROR_24400260 -VALIDATION_ERROR_00903:VALIDATION_ERROR_24400262 -VALIDATION_ERROR_00904:VALIDATION_ERROR_24405601 -VALIDATION_ERROR_00905:VALIDATION_ERROR_24404601 -VALIDATION_ERROR_00906:VALIDATION_ERROR_2440ec01 -VALIDATION_ERROR_00907:VALIDATION_ERROR_24404607 -VALIDATION_ERROR_00908:VALIDATION_ERROR_16a05601 -VALIDATION_ERROR_00909:VALIDATION_ERROR_16a0ea01 -VALIDATION_ERROR_00910:VALIDATION_ERROR_16a13001 -VALIDATION_ERROR_00911:VALIDATION_ERROR_04c00264 -VALIDATION_ERROR_00912:VALIDATION_ERROR_04c00266 -VALIDATION_ERROR_00913:VALIDATION_ERROR_04c2b00b -VALIDATION_ERROR_00914:VALIDATION_ERROR_04c1c40d -VALIDATION_ERROR_00915:VALIDATION_ERROR_04c04601 -VALIDATION_ERROR_00916:VALIDATION_ERROR_04c22c01 -VALIDATION_ERROR_00917:VALIDATION_ERROR_04c04a1b -VALIDATION_ERROR_00918:VALIDATION_ERROR_04c00009 -VALIDATION_ERROR_00919:VALIDATION_ERROR_2860026a -VALIDATION_ERROR_00920:VALIDATION_ERROR_2860026c -VALIDATION_ERROR_00921:VALIDATION_ERROR_2860026e -VALIDATION_ERROR_00922:VALIDATION_ERROR_28600270 -VALIDATION_ERROR_00923:VALIDATION_ERROR_28605601 -VALIDATION_ERROR_00924:VALIDATION_ERROR_28604601 -VALIDATION_ERROR_00925:VALIDATION_ERROR_28604a1b -VALIDATION_ERROR_00926:VALIDATION_ERROR_28604607 -VALIDATION_ERROR_00927:VALIDATION_ERROR_28613007 -VALIDATION_ERROR_00928:VALIDATION_ERROR_32a00272 -VALIDATION_ERROR_00929:VALIDATION_ERROR_32a05601 -VALIDATION_ERROR_00930:VALIDATION_ERROR_32a04601 -VALIDATION_ERROR_00931:VALIDATION_ERROR_32a09005 -VALIDATION_ERROR_00932:VALIDATION_ERROR_32a04607 -VALIDATION_ERROR_00933:VALIDATION_ERROR_33c05601 -VALIDATION_ERROR_00934:VALIDATION_ERROR_33c13601 -VALIDATION_ERROR_00935:VALIDATION_ERROR_33c12c01 -VALIDATION_ERROR_00936:VALIDATION_ERROR_15c00276 -VALIDATION_ERROR_00937:VALIDATION_ERROR_15c0027e -VALIDATION_ERROR_00938:VALIDATION_ERROR_15c00282 -VALIDATION_ERROR_00939:VALIDATION_ERROR_15c00284 -VALIDATION_ERROR_00940:VALIDATION_ERROR_15c00286 -VALIDATION_ERROR_00941:VALIDATION_ERROR_15c00288 -VALIDATION_ERROR_00942:VALIDATION_ERROR_15c0028a -VALIDATION_ERROR_00943:VALIDATION_ERROR_15c0028c -VALIDATION_ERROR_00944:VALIDATION_ERROR_15c0028e -VALIDATION_ERROR_00945:VALIDATION_ERROR_15c00290 -VALIDATION_ERROR_00946:VALIDATION_ERROR_15c00292 -VALIDATION_ERROR_00947:VALIDATION_ERROR_15c00296 -VALIDATION_ERROR_00948:VALIDATION_ERROR_15c00298 -VALIDATION_ERROR_00949:VALIDATION_ERROR_15c0029a -VALIDATION_ERROR_00950:VALIDATION_ERROR_15c0029c -VALIDATION_ERROR_00951:VALIDATION_ERROR_15c0029e -VALIDATION_ERROR_00952:VALIDATION_ERROR_15c002a0 -VALIDATION_ERROR_00953:VALIDATION_ERROR_15c2b00b -VALIDATION_ERROR_00954:VALIDATION_ERROR_15c1c40d -VALIDATION_ERROR_00955:VALIDATION_ERROR_15c00280 -VALIDATION_ERROR_00956:VALIDATION_ERROR_15c04e01 -VALIDATION_ERROR_00957:VALIDATION_ERROR_15c0441b -VALIDATION_ERROR_00958:VALIDATION_ERROR_15c00009 -VALIDATION_ERROR_00959:VALIDATION_ERROR_044002a8 -VALIDATION_ERROR_00960:VALIDATION_ERROR_044002aa -VALIDATION_ERROR_00961:VALIDATION_ERROR_044002ac -VALIDATION_ERROR_00962:VALIDATION_ERROR_04401a01 -VALIDATION_ERROR_00963:VALIDATION_ERROR_04600009 -VALIDATION_ERROR_00964:VALIDATION_ERROR_032002b2 -VALIDATION_ERROR_00965:VALIDATION_ERROR_032002b4 -VALIDATION_ERROR_00966:VALIDATION_ERROR_032002b6 -VALIDATION_ERROR_00967:VALIDATION_ERROR_032002b8 -VALIDATION_ERROR_00968:VALIDATION_ERROR_032002ba -VALIDATION_ERROR_00969:VALIDATION_ERROR_0322b00b -VALIDATION_ERROR_00970:VALIDATION_ERROR_0321c40d -VALIDATION_ERROR_00971:VALIDATION_ERROR_0322d201 -VALIDATION_ERROR_00972:VALIDATION_ERROR_03207601 -VALIDATION_ERROR_00973:VALIDATION_ERROR_03200009 -VALIDATION_ERROR_00974:VALIDATION_ERROR_17c002cc -VALIDATION_ERROR_00975:VALIDATION_ERROR_17c002ce -VALIDATION_ERROR_00976:VALIDATION_ERROR_17c002d0 -VALIDATION_ERROR_00977:VALIDATION_ERROR_17c002d2 -VALIDATION_ERROR_00978:VALIDATION_ERROR_17c002d4 -VALIDATION_ERROR_00979:VALIDATION_ERROR_17c02401 -VALIDATION_ERROR_00980:VALIDATION_ERROR_17c27e01 -VALIDATION_ERROR_00981:VALIDATION_ERROR_17c0be01 -VALIDATION_ERROR_00982:VALIDATION_ERROR_17c13001 -VALIDATION_ERROR_00983:VALIDATION_ERROR_17c15401 -VALIDATION_ERROR_00984:VALIDATION_ERROR_17c02413 -VALIDATION_ERROR_00985:VALIDATION_ERROR_17c02415 -VALIDATION_ERROR_00986:VALIDATION_ERROR_17c04a1b -VALIDATION_ERROR_00987:VALIDATION_ERROR_17c00009 -VALIDATION_ERROR_00988:VALIDATION_ERROR_1bc002de -VALIDATION_ERROR_00989:VALIDATION_ERROR_1bc002e0 -VALIDATION_ERROR_00990:VALIDATION_ERROR_1bc002e2 -VALIDATION_ERROR_00991:VALIDATION_ERROR_1bc002e4 -VALIDATION_ERROR_00992:VALIDATION_ERROR_1bc002e6 -VALIDATION_ERROR_00993:VALIDATION_ERROR_1bc02401 -VALIDATION_ERROR_00994:VALIDATION_ERROR_1bc0be01 -VALIDATION_ERROR_00995:VALIDATION_ERROR_1bc2dc01 -VALIDATION_ERROR_00996:VALIDATION_ERROR_1bc2dc03 -VALIDATION_ERROR_00997:VALIDATION_ERROR_1bc26201 -VALIDATION_ERROR_00998:VALIDATION_ERROR_1bc02413 -VALIDATION_ERROR_00999:VALIDATION_ERROR_1bc02415 -VALIDATION_ERROR_01000:VALIDATION_ERROR_1bc2c21b -VALIDATION_ERROR_01001:VALIDATION_ERROR_1bc00009 -VALIDATION_ERROR_01002:VALIDATION_ERROR_21e05601 -VALIDATION_ERROR_01003:VALIDATION_ERROR_21e11e01 -VALIDATION_ERROR_01004:VALIDATION_ERROR_21e0ec01 -VALIDATION_ERROR_01005:VALIDATION_ERROR_21e1fa01 -VALIDATION_ERROR_01006:VALIDATION_ERROR_11c0062e -VALIDATION_ERROR_01007:VALIDATION_ERROR_11c00630 -VALIDATION_ERROR_01008:VALIDATION_ERROR_11c2b00b -VALIDATION_ERROR_01009:VALIDATION_ERROR_11c1c40d -VALIDATION_ERROR_01010:VALIDATION_ERROR_11c09005 -VALIDATION_ERROR_01011:VALIDATION_ERROR_11c29a01 -VALIDATION_ERROR_01012:VALIDATION_ERROR_26200632 -VALIDATION_ERROR_01013:VALIDATION_ERROR_26200634 -VALIDATION_ERROR_01014:VALIDATION_ERROR_26200636 -VALIDATION_ERROR_01015:VALIDATION_ERROR_26205601 -VALIDATION_ERROR_01016:VALIDATION_ERROR_26229801 -VALIDATION_ERROR_01017:VALIDATION_ERROR_2620ec01 -VALIDATION_ERROR_01018:VALIDATION_ERROR_26229807 -VALIDATION_ERROR_01019:VALIDATION_ERROR_1c600638 -VALIDATION_ERROR_01020:VALIDATION_ERROR_1c60063a -VALIDATION_ERROR_01021:VALIDATION_ERROR_1c602401 -VALIDATION_ERROR_01022:VALIDATION_ERROR_1c629801 -VALIDATION_ERROR_01023:VALIDATION_ERROR_1c602413 -VALIDATION_ERROR_01024:VALIDATION_ERROR_1c602415 -VALIDATION_ERROR_01025:VALIDATION_ERROR_1c600017 -VALIDATION_ERROR_01026:VALIDATION_ERROR_1c600009 -VALIDATION_ERROR_01027:VALIDATION_ERROR_1780063c -VALIDATION_ERROR_01028:VALIDATION_ERROR_1780063e -VALIDATION_ERROR_01029:VALIDATION_ERROR_17800640 -VALIDATION_ERROR_01030:VALIDATION_ERROR_17800642 -VALIDATION_ERROR_01031:VALIDATION_ERROR_17800644 -VALIDATION_ERROR_01032:VALIDATION_ERROR_17800646 -VALIDATION_ERROR_01033:VALIDATION_ERROR_17800648 -VALIDATION_ERROR_01034:VALIDATION_ERROR_1780064a -VALIDATION_ERROR_01035:VALIDATION_ERROR_17802401 -VALIDATION_ERROR_01036:VALIDATION_ERROR_17829801 -VALIDATION_ERROR_01037:VALIDATION_ERROR_17809001 -VALIDATION_ERROR_01038:VALIDATION_ERROR_17802413 -VALIDATION_ERROR_01039:VALIDATION_ERROR_17802415 -VALIDATION_ERROR_01040:VALIDATION_ERROR_17800009 -VALIDATION_ERROR_01041:VALIDATION_ERROR_1ae00652 -VALIDATION_ERROR_01042:VALIDATION_ERROR_1ae00654 -VALIDATION_ERROR_01043:VALIDATION_ERROR_1ae02401 -VALIDATION_ERROR_01044:VALIDATION_ERROR_1ae29801 -VALIDATION_ERROR_01045:VALIDATION_ERROR_1ae02413 -VALIDATION_ERROR_01046:VALIDATION_ERROR_1ae02415 -VALIDATION_ERROR_01047:VALIDATION_ERROR_1ae00009 -VALIDATION_ERROR_01048:VALIDATION_ERROR_2fa0065a -VALIDATION_ERROR_01049:VALIDATION_ERROR_2fa0065c -VALIDATION_ERROR_01050:VALIDATION_ERROR_2fa0065e -VALIDATION_ERROR_01051:VALIDATION_ERROR_2fa00660 -VALIDATION_ERROR_01052:VALIDATION_ERROR_2fa00662 -VALIDATION_ERROR_01053:VALIDATION_ERROR_2fa00664 -VALIDATION_ERROR_01054:VALIDATION_ERROR_2fa05601 -VALIDATION_ERROR_01055:VALIDATION_ERROR_2fa29801 -VALIDATION_ERROR_01056:VALIDATION_ERROR_2fa12201 -VALIDATION_ERROR_01057:VALIDATION_ERROR_2fa09001 -VALIDATION_ERROR_01058:VALIDATION_ERROR_2fa03c1b -VALIDATION_ERROR_01059:VALIDATION_ERROR_2fa29807 -VALIDATION_ERROR_01060:VALIDATION_ERROR_19400666 -VALIDATION_ERROR_01061:VALIDATION_ERROR_19400668 -VALIDATION_ERROR_01062:VALIDATION_ERROR_1940066a -VALIDATION_ERROR_01063:VALIDATION_ERROR_1940066c -VALIDATION_ERROR_01064:VALIDATION_ERROR_1940066e -VALIDATION_ERROR_01065:VALIDATION_ERROR_19400670 -VALIDATION_ERROR_01066:VALIDATION_ERROR_19400672 -VALIDATION_ERROR_01067:VALIDATION_ERROR_19400676 -VALIDATION_ERROR_01068:VALIDATION_ERROR_19402401 -VALIDATION_ERROR_01069:VALIDATION_ERROR_19429801 -VALIDATION_ERROR_01070:VALIDATION_ERROR_19406c01 -VALIDATION_ERROR_01071:VALIDATION_ERROR_19409001 -VALIDATION_ERROR_01072:VALIDATION_ERROR_19402413 -VALIDATION_ERROR_01073:VALIDATION_ERROR_19402415 -VALIDATION_ERROR_01074:VALIDATION_ERROR_19400017 -VALIDATION_ERROR_01075:VALIDATION_ERROR_19400009 -VALIDATION_ERROR_01076:VALIDATION_ERROR_1e800678 -VALIDATION_ERROR_01077:VALIDATION_ERROR_1e80067a -VALIDATION_ERROR_01078:VALIDATION_ERROR_1e802401 -VALIDATION_ERROR_01079:VALIDATION_ERROR_1e828401 -VALIDATION_ERROR_01080:VALIDATION_ERROR_1e829801 -VALIDATION_ERROR_01081:VALIDATION_ERROR_1e802413 -VALIDATION_ERROR_01082:VALIDATION_ERROR_1e802415 -VALIDATION_ERROR_01083:VALIDATION_ERROR_1e800009 -VALIDATION_ERROR_01084:VALIDATION_ERROR_18800004 -VALIDATION_ERROR_01085:VALIDATION_ERROR_18800008 -VALIDATION_ERROR_01086:VALIDATION_ERROR_1880000a -VALIDATION_ERROR_01087:VALIDATION_ERROR_1880000c -VALIDATION_ERROR_01088:VALIDATION_ERROR_1880000e -VALIDATION_ERROR_01089:VALIDATION_ERROR_18802401 -VALIDATION_ERROR_01090:VALIDATION_ERROR_1880a001 -VALIDATION_ERROR_01091:VALIDATION_ERROR_1880a601 -VALIDATION_ERROR_01092:VALIDATION_ERROR_18810e01 -VALIDATION_ERROR_01093:VALIDATION_ERROR_18820601 -VALIDATION_ERROR_01094:VALIDATION_ERROR_18802413 -VALIDATION_ERROR_01095:VALIDATION_ERROR_18802415 -VALIDATION_ERROR_01096:VALIDATION_ERROR_18800017 -VALIDATION_ERROR_01097:VALIDATION_ERROR_1882a41b -VALIDATION_ERROR_01098:VALIDATION_ERROR_18800009 -VALIDATION_ERROR_01099:VALIDATION_ERROR_18a00012 -VALIDATION_ERROR_01100:VALIDATION_ERROR_18a00016 -VALIDATION_ERROR_01101:VALIDATION_ERROR_18a00018 -VALIDATION_ERROR_01102:VALIDATION_ERROR_18a0001a -VALIDATION_ERROR_01103:VALIDATION_ERROR_18a0001c -VALIDATION_ERROR_01104:VALIDATION_ERROR_18a02401 -VALIDATION_ERROR_01105:VALIDATION_ERROR_18a0a001 -VALIDATION_ERROR_01106:VALIDATION_ERROR_18a0a601 -VALIDATION_ERROR_01107:VALIDATION_ERROR_18a12801 -VALIDATION_ERROR_01108:VALIDATION_ERROR_18a20601 -VALIDATION_ERROR_01109:VALIDATION_ERROR_18a02413 -VALIDATION_ERROR_01110:VALIDATION_ERROR_18a02415 -VALIDATION_ERROR_01111:VALIDATION_ERROR_18a00017 -VALIDATION_ERROR_01112:VALIDATION_ERROR_18a2a41b -VALIDATION_ERROR_01113:VALIDATION_ERROR_18a00009 -VALIDATION_ERROR_01114:VALIDATION_ERROR_1860001e -VALIDATION_ERROR_01115:VALIDATION_ERROR_18600020 -VALIDATION_ERROR_01116:VALIDATION_ERROR_18600022 -VALIDATION_ERROR_01117:VALIDATION_ERROR_18602401 -VALIDATION_ERROR_01118:VALIDATION_ERROR_1860f201 -VALIDATION_ERROR_01119:VALIDATION_ERROR_18620e01 -VALIDATION_ERROR_01120:VALIDATION_ERROR_18602413 -VALIDATION_ERROR_01121:VALIDATION_ERROR_18602415 -VALIDATION_ERROR_01122:VALIDATION_ERROR_18600017 -VALIDATION_ERROR_01123:VALIDATION_ERROR_18600e1b -VALIDATION_ERROR_01124:VALIDATION_ERROR_1862aa1b -VALIDATION_ERROR_01125:VALIDATION_ERROR_01c00026 -VALIDATION_ERROR_01126:VALIDATION_ERROR_01c00028 -VALIDATION_ERROR_01127:VALIDATION_ERROR_01c00c01 -VALIDATION_ERROR_01128:VALIDATION_ERROR_01c00c03 -VALIDATION_ERROR_01129:VALIDATION_ERROR_01c0002a -VALIDATION_ERROR_01130:VALIDATION_ERROR_01e0002c -VALIDATION_ERROR_01131:VALIDATION_ERROR_0200002e -VALIDATION_ERROR_01132:VALIDATION_ERROR_1b400030 -VALIDATION_ERROR_01133:VALIDATION_ERROR_1b400032 -VALIDATION_ERROR_01134:VALIDATION_ERROR_1b400034 -VALIDATION_ERROR_01135:VALIDATION_ERROR_1b400036 -VALIDATION_ERROR_01136:VALIDATION_ERROR_1b400038 -VALIDATION_ERROR_01137:VALIDATION_ERROR_1b40003a -VALIDATION_ERROR_01138:VALIDATION_ERROR_1b402401 -VALIDATION_ERROR_01139:VALIDATION_ERROR_1b406c01 -VALIDATION_ERROR_01140:VALIDATION_ERROR_1b402413 -VALIDATION_ERROR_01141:VALIDATION_ERROR_1b402415 -VALIDATION_ERROR_01142:VALIDATION_ERROR_1b400017 -VALIDATION_ERROR_01143:VALIDATION_ERROR_1b400009 -VALIDATION_ERROR_01144:VALIDATION_ERROR_1e400040 -VALIDATION_ERROR_01145:VALIDATION_ERROR_1e400042 -VALIDATION_ERROR_01146:VALIDATION_ERROR_1e400044 -VALIDATION_ERROR_01147:VALIDATION_ERROR_1e400048 -VALIDATION_ERROR_01148:VALIDATION_ERROR_1e40004a -VALIDATION_ERROR_01149:VALIDATION_ERROR_1e40004c -VALIDATION_ERROR_01150:VALIDATION_ERROR_1e402401 -VALIDATION_ERROR_01151:VALIDATION_ERROR_1e406c01 -VALIDATION_ERROR_01152:VALIDATION_ERROR_1e412201 -VALIDATION_ERROR_01153:VALIDATION_ERROR_1e402413 -VALIDATION_ERROR_01154:VALIDATION_ERROR_1e402415 -VALIDATION_ERROR_01155:VALIDATION_ERROR_1e400017 -VALIDATION_ERROR_01156:VALIDATION_ERROR_1e403c1b -VALIDATION_ERROR_01157:VALIDATION_ERROR_1e400009 -VALIDATION_ERROR_01158:VALIDATION_ERROR_18c000e0 -VALIDATION_ERROR_01159:VALIDATION_ERROR_18c000e2 -VALIDATION_ERROR_01160:VALIDATION_ERROR_18c000e4 -VALIDATION_ERROR_01161:VALIDATION_ERROR_18c000e6 -VALIDATION_ERROR_01162:VALIDATION_ERROR_18c000e8 -VALIDATION_ERROR_01163:VALIDATION_ERROR_18c000ea -VALIDATION_ERROR_01164:VALIDATION_ERROR_18c000ec -VALIDATION_ERROR_01165:VALIDATION_ERROR_18c000f0 -VALIDATION_ERROR_01166:VALIDATION_ERROR_18c02401 -VALIDATION_ERROR_01167:VALIDATION_ERROR_18c2c801 -VALIDATION_ERROR_01168:VALIDATION_ERROR_18c06c01 -VALIDATION_ERROR_01169:VALIDATION_ERROR_18c21001 -VALIDATION_ERROR_01170:VALIDATION_ERROR_18c02413 -VALIDATION_ERROR_01171:VALIDATION_ERROR_18c02415 -VALIDATION_ERROR_01172:VALIDATION_ERROR_18c00017 -VALIDATION_ERROR_01173:VALIDATION_ERROR_18c2ac1b -VALIDATION_ERROR_01174:VALIDATION_ERROR_18c00009 -VALIDATION_ERROR_01175:VALIDATION_ERROR_190000f4 -VALIDATION_ERROR_01176:VALIDATION_ERROR_190000f6 -VALIDATION_ERROR_01177:VALIDATION_ERROR_190000f8 -VALIDATION_ERROR_01178:VALIDATION_ERROR_190000fc -VALIDATION_ERROR_01179:VALIDATION_ERROR_19000100 -VALIDATION_ERROR_01180:VALIDATION_ERROR_19000102 -VALIDATION_ERROR_01181:VALIDATION_ERROR_19000106 -VALIDATION_ERROR_01182:VALIDATION_ERROR_1900010a -VALIDATION_ERROR_01183:VALIDATION_ERROR_1900010c -VALIDATION_ERROR_01184:VALIDATION_ERROR_1900010e -VALIDATION_ERROR_01185:VALIDATION_ERROR_19000110 -VALIDATION_ERROR_01186:VALIDATION_ERROR_19002401 -VALIDATION_ERROR_01187:VALIDATION_ERROR_1902ce01 -VALIDATION_ERROR_01188:VALIDATION_ERROR_1902d001 -VALIDATION_ERROR_01189:VALIDATION_ERROR_19007201 -VALIDATION_ERROR_01190:VALIDATION_ERROR_19007401 -VALIDATION_ERROR_01191:VALIDATION_ERROR_19021001 -VALIDATION_ERROR_01192:VALIDATION_ERROR_19002413 -VALIDATION_ERROR_01193:VALIDATION_ERROR_19002415 -VALIDATION_ERROR_01194:VALIDATION_ERROR_19000017 -VALIDATION_ERROR_01195:VALIDATION_ERROR_1902ac1b -VALIDATION_ERROR_01196:VALIDATION_ERROR_19000009 -VALIDATION_ERROR_01197:VALIDATION_ERROR_09c00112 -VALIDATION_ERROR_01198:VALIDATION_ERROR_09c00118 -VALIDATION_ERROR_01199:VALIDATION_ERROR_09c0011a -VALIDATION_ERROR_01200:VALIDATION_ERROR_09c0011c -VALIDATION_ERROR_01201:VALIDATION_ERROR_09c0011e -VALIDATION_ERROR_01202:VALIDATION_ERROR_09c00120 -VALIDATION_ERROR_01203:VALIDATION_ERROR_09c00122 -VALIDATION_ERROR_01204:VALIDATION_ERROR_09c00126 -VALIDATION_ERROR_01205:VALIDATION_ERROR_09c0012c -VALIDATION_ERROR_01206:VALIDATION_ERROR_09c0012e -VALIDATION_ERROR_01207:VALIDATION_ERROR_09c00132 -VALIDATION_ERROR_01209:VALIDATION_ERROR_09c0013a -VALIDATION_ERROR_01210:VALIDATION_ERROR_09c0013c -VALIDATION_ERROR_01211:VALIDATION_ERROR_09c0013e -VALIDATION_ERROR_01212:VALIDATION_ERROR_09c00140 -VALIDATION_ERROR_01214:VALIDATION_ERROR_09c00144 -VALIDATION_ERROR_01215:VALIDATION_ERROR_09c00146 -VALIDATION_ERROR_01216:VALIDATION_ERROR_09c00148 -VALIDATION_ERROR_01217:VALIDATION_ERROR_09c0014a -VALIDATION_ERROR_01218:VALIDATION_ERROR_09c0014c -VALIDATION_ERROR_01219:VALIDATION_ERROR_09c2d601 -VALIDATION_ERROR_01220:VALIDATION_ERROR_09c07a01 -VALIDATION_ERROR_01221:VALIDATION_ERROR_0a60014e -VALIDATION_ERROR_01222:VALIDATION_ERROR_0a600150 -VALIDATION_ERROR_01223:VALIDATION_ERROR_0a600152 -VALIDATION_ERROR_01224:VALIDATION_ERROR_0a600154 -VALIDATION_ERROR_01225:VALIDATION_ERROR_0a600c01 -VALIDATION_ERROR_01226:VALIDATION_ERROR_0a600c03 -VALIDATION_ERROR_01227:VALIDATION_ERROR_18e00156 -VALIDATION_ERROR_01228:VALIDATION_ERROR_18e00158 -VALIDATION_ERROR_01229:VALIDATION_ERROR_18e0015a -VALIDATION_ERROR_01230:VALIDATION_ERROR_18e0015c -VALIDATION_ERROR_01231:VALIDATION_ERROR_18e00162 -VALIDATION_ERROR_01232:VALIDATION_ERROR_18e00166 -VALIDATION_ERROR_01233:VALIDATION_ERROR_18e00168 -VALIDATION_ERROR_01234:VALIDATION_ERROR_18e0016a -VALIDATION_ERROR_01235:VALIDATION_ERROR_18e02401 -VALIDATION_ERROR_01236:VALIDATION_ERROR_18e2c801 -VALIDATION_ERROR_01237:VALIDATION_ERROR_18e07201 -VALIDATION_ERROR_01238:VALIDATION_ERROR_18e07401 -VALIDATION_ERROR_01239:VALIDATION_ERROR_18e21001 -VALIDATION_ERROR_01240:VALIDATION_ERROR_18e02413 -VALIDATION_ERROR_01241:VALIDATION_ERROR_18e02415 -VALIDATION_ERROR_01242:VALIDATION_ERROR_18e00017 -VALIDATION_ERROR_01243:VALIDATION_ERROR_18e2ac1b -VALIDATION_ERROR_01244:VALIDATION_ERROR_18e00009 -VALIDATION_ERROR_01245:VALIDATION_ERROR_1920016c -VALIDATION_ERROR_01246:VALIDATION_ERROR_1920016e -VALIDATION_ERROR_01247:VALIDATION_ERROR_19200170 -VALIDATION_ERROR_01248:VALIDATION_ERROR_19200174 -VALIDATION_ERROR_01249:VALIDATION_ERROR_19200178 -VALIDATION_ERROR_01250:VALIDATION_ERROR_1920017a -VALIDATION_ERROR_01251:VALIDATION_ERROR_1920017c -VALIDATION_ERROR_01252:VALIDATION_ERROR_1920017e -VALIDATION_ERROR_01253:VALIDATION_ERROR_19202401 -VALIDATION_ERROR_01254:VALIDATION_ERROR_1922ce01 -VALIDATION_ERROR_01255:VALIDATION_ERROR_1922d001 -VALIDATION_ERROR_01256:VALIDATION_ERROR_19206c01 -VALIDATION_ERROR_01257:VALIDATION_ERROR_19221001 -VALIDATION_ERROR_01258:VALIDATION_ERROR_19202413 -VALIDATION_ERROR_01259:VALIDATION_ERROR_19202415 -VALIDATION_ERROR_01260:VALIDATION_ERROR_19200017 -VALIDATION_ERROR_01261:VALIDATION_ERROR_1922ac1b -VALIDATION_ERROR_01262:VALIDATION_ERROR_19200009 -VALIDATION_ERROR_01263:VALIDATION_ERROR_01600182 -VALIDATION_ERROR_01264:VALIDATION_ERROR_01600184 -VALIDATION_ERROR_01265:VALIDATION_ERROR_01600186 -VALIDATION_ERROR_01266:VALIDATION_ERROR_01600188 -VALIDATION_ERROR_01267:VALIDATION_ERROR_0160018a -VALIDATION_ERROR_01268:VALIDATION_ERROR_0160018c -VALIDATION_ERROR_01269:VALIDATION_ERROR_01600190 -VALIDATION_ERROR_01271:VALIDATION_ERROR_01600196 -VALIDATION_ERROR_01272:VALIDATION_ERROR_01600198 -VALIDATION_ERROR_01273:VALIDATION_ERROR_0160019a -VALIDATION_ERROR_01274:VALIDATION_ERROR_0160019c -VALIDATION_ERROR_01275:VALIDATION_ERROR_0160019e -VALIDATION_ERROR_01276:VALIDATION_ERROR_016001a0 -VALIDATION_ERROR_01277:VALIDATION_ERROR_016001a2 -VALIDATION_ERROR_01278:VALIDATION_ERROR_016001a4 -VALIDATION_ERROR_01279:VALIDATION_ERROR_016001a6 -VALIDATION_ERROR_01280:VALIDATION_ERROR_016001a8 -VALIDATION_ERROR_01281:VALIDATION_ERROR_016001aa -VALIDATION_ERROR_01282:VALIDATION_ERROR_016001ac -VALIDATION_ERROR_01283:VALIDATION_ERROR_0160aa01 -VALIDATION_ERROR_01287:VALIDATION_ERROR_184001ae -VALIDATION_ERROR_01288:VALIDATION_ERROR_184001b0 -VALIDATION_ERROR_01289:VALIDATION_ERROR_184001b2 -VALIDATION_ERROR_01291:VALIDATION_ERROR_18402401 -VALIDATION_ERROR_01292:VALIDATION_ERROR_1842ce01 -VALIDATION_ERROR_01293:VALIDATION_ERROR_1842d001 -VALIDATION_ERROR_01294:VALIDATION_ERROR_18407201 -VALIDATION_ERROR_01295:VALIDATION_ERROR_18407401 -VALIDATION_ERROR_01296:VALIDATION_ERROR_18421001 -VALIDATION_ERROR_01297:VALIDATION_ERROR_18408c01 -VALIDATION_ERROR_01298:VALIDATION_ERROR_18402413 -VALIDATION_ERROR_01299:VALIDATION_ERROR_18402415 -VALIDATION_ERROR_01300:VALIDATION_ERROR_18400017 -VALIDATION_ERROR_01301:VALIDATION_ERROR_1842ac1b -VALIDATION_ERROR_01302:VALIDATION_ERROR_18400009 -VALIDATION_ERROR_01303:VALIDATION_ERROR_09a001dc -VALIDATION_ERROR_01304:VALIDATION_ERROR_09a001de -VALIDATION_ERROR_01305:VALIDATION_ERROR_09a001e0 -VALIDATION_ERROR_01306:VALIDATION_ERROR_09a001e2 -VALIDATION_ERROR_01307:VALIDATION_ERROR_09a001e4 -VALIDATION_ERROR_01309:VALIDATION_ERROR_09a001e6 -VALIDATION_ERROR_01310:VALIDATION_ERROR_09a001e8 -VALIDATION_ERROR_01311:VALIDATION_ERROR_09a001ec -VALIDATION_ERROR_01312:VALIDATION_ERROR_09a001f0 -VALIDATION_ERROR_01313:VALIDATION_ERROR_09a001f2 -VALIDATION_ERROR_01314:VALIDATION_ERROR_09a001f6 -VALIDATION_ERROR_01315:VALIDATION_ERROR_09a2d601 -VALIDATION_ERROR_01316:VALIDATION_ERROR_09a07a01 -VALIDATION_ERROR_01317:VALIDATION_ERROR_1c8001fa -VALIDATION_ERROR_01318:VALIDATION_ERROR_1c8001fc -VALIDATION_ERROR_01319:VALIDATION_ERROR_1c8001fe -VALIDATION_ERROR_01320:VALIDATION_ERROR_1c800202 -VALIDATION_ERROR_01321:VALIDATION_ERROR_1c800206 -VALIDATION_ERROR_01322:VALIDATION_ERROR_1c800208 -VALIDATION_ERROR_01324:VALIDATION_ERROR_1c80020c -VALIDATION_ERROR_01326:VALIDATION_ERROR_1c800210 -VALIDATION_ERROR_01327:VALIDATION_ERROR_1c802401 -VALIDATION_ERROR_01328:VALIDATION_ERROR_1c82ce01 -VALIDATION_ERROR_01329:VALIDATION_ERROR_1c82d001 -VALIDATION_ERROR_01330:VALIDATION_ERROR_1c807201 -VALIDATION_ERROR_01331:VALIDATION_ERROR_1c807401 -VALIDATION_ERROR_01332:VALIDATION_ERROR_1c821001 -VALIDATION_ERROR_01333:VALIDATION_ERROR_1c802413 -VALIDATION_ERROR_01334:VALIDATION_ERROR_1c802415 -VALIDATION_ERROR_01335:VALIDATION_ERROR_1c800017 -VALIDATION_ERROR_01336:VALIDATION_ERROR_1c82ac1b -VALIDATION_ERROR_01337:VALIDATION_ERROR_1c800009 -VALIDATION_ERROR_01338:VALIDATION_ERROR_0a200214 -VALIDATION_ERROR_01339:VALIDATION_ERROR_0a200216 -VALIDATION_ERROR_01340:VALIDATION_ERROR_0a200218 -VALIDATION_ERROR_01341:VALIDATION_ERROR_0a22d601 -VALIDATION_ERROR_01342:VALIDATION_ERROR_0a207a01 -VALIDATION_ERROR_01343:VALIDATION_ERROR_0fc00358 -VALIDATION_ERROR_01344:VALIDATION_ERROR_0fc0035a -VALIDATION_ERROR_01345:VALIDATION_ERROR_0fc0035c -VALIDATION_ERROR_01346:VALIDATION_ERROR_0fc2b00b -VALIDATION_ERROR_01347:VALIDATION_ERROR_0fc1c40d -VALIDATION_ERROR_01348:VALIDATION_ERROR_0fc09005 -VALIDATION_ERROR_01349:VALIDATION_ERROR_0fc30001 -VALIDATION_ERROR_01350:VALIDATION_ERROR_17e0035e -VALIDATION_ERROR_01351:VALIDATION_ERROR_17e00360 -VALIDATION_ERROR_01352:VALIDATION_ERROR_17e00362 -VALIDATION_ERROR_01353:VALIDATION_ERROR_17e02401 -VALIDATION_ERROR_01354:VALIDATION_ERROR_17e01a01 -VALIDATION_ERROR_01355:VALIDATION_ERROR_17e0b201 -VALIDATION_ERROR_01356:VALIDATION_ERROR_17e02413 -VALIDATION_ERROR_01357:VALIDATION_ERROR_17e02415 -VALIDATION_ERROR_01358:VALIDATION_ERROR_17e00009 -VALIDATION_ERROR_01361:VALIDATION_ERROR_1a20036e -VALIDATION_ERROR_01362:VALIDATION_ERROR_1a202401 -VALIDATION_ERROR_01363:VALIDATION_ERROR_1a202413 -VALIDATION_ERROR_01364:VALIDATION_ERROR_1a202415 -VALIDATION_ERROR_01365:VALIDATION_ERROR_1a200017 -VALIDATION_ERROR_01368:VALIDATION_ERROR_1a400394 -VALIDATION_ERROR_01369:VALIDATION_ERROR_1a402401 -VALIDATION_ERROR_01370:VALIDATION_ERROR_1a402413 -VALIDATION_ERROR_01371:VALIDATION_ERROR_1a402415 -VALIDATION_ERROR_01372:VALIDATION_ERROR_1a400017 -VALIDATION_ERROR_01373:VALIDATION_ERROR_1aa003b6 -VALIDATION_ERROR_01374:VALIDATION_ERROR_1aa003b8 -VALIDATION_ERROR_01375:VALIDATION_ERROR_1aa003ba -VALIDATION_ERROR_01376:VALIDATION_ERROR_1aa003bc -VALIDATION_ERROR_01377:VALIDATION_ERROR_1aa02401 -VALIDATION_ERROR_01378:VALIDATION_ERROR_1aa01a01 -VALIDATION_ERROR_01379:VALIDATION_ERROR_1aa02413 -VALIDATION_ERROR_01380:VALIDATION_ERROR_1aa02415 -VALIDATION_ERROR_01381:VALIDATION_ERROR_1aa00017 -VALIDATION_ERROR_01382:VALIDATION_ERROR_1aa00009 -VALIDATION_ERROR_01384:VALIDATION_ERROR_07c003ea -VALIDATION_ERROR_01385:VALIDATION_ERROR_1a60041e -VALIDATION_ERROR_01386:VALIDATION_ERROR_1a600420 -VALIDATION_ERROR_01387:VALIDATION_ERROR_1a600422 -VALIDATION_ERROR_01388:VALIDATION_ERROR_1a600424 -VALIDATION_ERROR_01389:VALIDATION_ERROR_1a602401 -VALIDATION_ERROR_01390:VALIDATION_ERROR_1a601a01 -VALIDATION_ERROR_01391:VALIDATION_ERROR_1a602413 -VALIDATION_ERROR_01392:VALIDATION_ERROR_1a602415 -VALIDATION_ERROR_01393:VALIDATION_ERROR_1a600017 -VALIDATION_ERROR_01394:VALIDATION_ERROR_1a600009 -VALIDATION_ERROR_01396:VALIDATION_ERROR_07a00452 -VALIDATION_ERROR_01397:VALIDATION_ERROR_10a004ca -VALIDATION_ERROR_01398:VALIDATION_ERROR_10a004cc -VALIDATION_ERROR_01399:VALIDATION_ERROR_10a004ce -VALIDATION_ERROR_01400:VALIDATION_ERROR_10a004d0 -VALIDATION_ERROR_01401:VALIDATION_ERROR_10a004d2 -VALIDATION_ERROR_01402:VALIDATION_ERROR_10a2b00b -VALIDATION_ERROR_01403:VALIDATION_ERROR_10a1c40d -VALIDATION_ERROR_01404:VALIDATION_ERROR_10a09005 -VALIDATION_ERROR_01405:VALIDATION_ERROR_10a26601 -VALIDATION_ERROR_01406:VALIDATION_ERROR_10a26401 -VALIDATION_ERROR_01407:VALIDATION_ERROR_14c004d4 -VALIDATION_ERROR_01408:VALIDATION_ERROR_14c004d6 -VALIDATION_ERROR_01409:VALIDATION_ERROR_14c0ba01 -VALIDATION_ERROR_01410:VALIDATION_ERROR_14a004d8 -VALIDATION_ERROR_01411:VALIDATION_ERROR_14a004da -VALIDATION_ERROR_01412:VALIDATION_ERROR_14a004dc -VALIDATION_ERROR_01413:VALIDATION_ERROR_14a004de -VALIDATION_ERROR_01414:VALIDATION_ERROR_14a09201 -VALIDATION_ERROR_01415:VALIDATION_ERROR_182004e0 -VALIDATION_ERROR_01416:VALIDATION_ERROR_182004e2 -VALIDATION_ERROR_01417:VALIDATION_ERROR_182004e4 -VALIDATION_ERROR_01418:VALIDATION_ERROR_182004e6 -VALIDATION_ERROR_01419:VALIDATION_ERROR_18202401 -VALIDATION_ERROR_01420:VALIDATION_ERROR_18210601 -VALIDATION_ERROR_01421:VALIDATION_ERROR_1821d201 -VALIDATION_ERROR_01422:VALIDATION_ERROR_18202413 -VALIDATION_ERROR_01423:VALIDATION_ERROR_18202415 -VALIDATION_ERROR_01424:VALIDATION_ERROR_1820181b -VALIDATION_ERROR_01425:VALIDATION_ERROR_18200009 -VALIDATION_ERROR_01426:VALIDATION_ERROR_1080097c -VALIDATION_ERROR_01427:VALIDATION_ERROR_1082b00b -VALIDATION_ERROR_01428:VALIDATION_ERROR_1081c40d -VALIDATION_ERROR_01429:VALIDATION_ERROR_10809005 -VALIDATION_ERROR_01430:VALIDATION_ERROR_10c00980 -VALIDATION_ERROR_01431:VALIDATION_ERROR_10c00982 -VALIDATION_ERROR_01432:VALIDATION_ERROR_10c00984 -VALIDATION_ERROR_01433:VALIDATION_ERROR_10c00986 -VALIDATION_ERROR_01434:VALIDATION_ERROR_10c00988 -VALIDATION_ERROR_01436:VALIDATION_ERROR_10e1c40d -VALIDATION_ERROR_01437:VALIDATION_ERROR_10e09005 -VALIDATION_ERROR_01438:VALIDATION_ERROR_10e30a1b -VALIDATION_ERROR_01440:VALIDATION_ERROR_1e00098a -VALIDATION_ERROR_01441:VALIDATION_ERROR_1e00098c -VALIDATION_ERROR_01442:VALIDATION_ERROR_1e00098e -VALIDATION_ERROR_01443:VALIDATION_ERROR_1e002401 -VALIDATION_ERROR_01444:VALIDATION_ERROR_1e000994 -VALIDATION_ERROR_01445:VALIDATION_ERROR_1e002413 -VALIDATION_ERROR_01446:VALIDATION_ERROR_1e002415 -VALIDATION_ERROR_01447:VALIDATION_ERROR_1e030a1b -VALIDATION_ERROR_01448:VALIDATION_ERROR_15000996 -VALIDATION_ERROR_01449:VALIDATION_ERROR_1500099a -VALIDATION_ERROR_01450:VALIDATION_ERROR_1500099e -VALIDATION_ERROR_01451:VALIDATION_ERROR_150009a0 -VALIDATION_ERROR_01452:VALIDATION_ERROR_150009a2 -VALIDATION_ERROR_01453:VALIDATION_ERROR_150009a4 -VALIDATION_ERROR_01454:VALIDATION_ERROR_150009a6 -VALIDATION_ERROR_01455:VALIDATION_ERROR_1020061c -VALIDATION_ERROR_01456:VALIDATION_ERROR_1020061e -VALIDATION_ERROR_01457:VALIDATION_ERROR_1022b00b -VALIDATION_ERROR_01460:VALIDATION_ERROR_10228601 -VALIDATION_ERROR_01461:VALIDATION_ERROR_10203a01 -VALIDATION_ERROR_01462:VALIDATION_ERROR_10209801 -VALIDATION_ERROR_01463:VALIDATION_ERROR_10000620 -VALIDATION_ERROR_01464:VALIDATION_ERROR_10000622 -VALIDATION_ERROR_01465:VALIDATION_ERROR_10000624 -VALIDATION_ERROR_01466:VALIDATION_ERROR_1002b00b -VALIDATION_ERROR_01467:VALIDATION_ERROR_1001c40d -VALIDATION_ERROR_01468:VALIDATION_ERROR_10009005 -VALIDATION_ERROR_01469:VALIDATION_ERROR_1002a801 -VALIDATION_ERROR_01476:VALIDATION_ERROR_1d600626 -VALIDATION_ERROR_01477:VALIDATION_ERROR_1d600628 -VALIDATION_ERROR_01478:VALIDATION_ERROR_1d602401 -VALIDATION_ERROR_01479:VALIDATION_ERROR_1d602413 -VALIDATION_ERROR_01480:VALIDATION_ERROR_1d602415 -VALIDATION_ERROR_01481:VALIDATION_ERROR_1cc0062a -VALIDATION_ERROR_01482:VALIDATION_ERROR_1cc0062c -VALIDATION_ERROR_01483:VALIDATION_ERROR_1cc02401 -VALIDATION_ERROR_01484:VALIDATION_ERROR_1cc02413 -VALIDATION_ERROR_01485:VALIDATION_ERROR_1cc02415 -VALIDATION_ERROR_01486:VALIDATION_ERROR_1d80049c -VALIDATION_ERROR_01487:VALIDATION_ERROR_1d80049e -VALIDATION_ERROR_01488:VALIDATION_ERROR_1d8004a0 -VALIDATION_ERROR_01489:VALIDATION_ERROR_1d8004a6 -VALIDATION_ERROR_01490:VALIDATION_ERROR_1d8004a8 -VALIDATION_ERROR_01491:VALIDATION_ERROR_1d8004aa -VALIDATION_ERROR_01492:VALIDATION_ERROR_1d802401 -VALIDATION_ERROR_01493:VALIDATION_ERROR_1d822601 -VALIDATION_ERROR_01494:VALIDATION_ERROR_1d802413 -VALIDATION_ERROR_01495:VALIDATION_ERROR_1d802415 -VALIDATION_ERROR_01496:VALIDATION_ERROR_1d82b61b -VALIDATION_ERROR_01497:VALIDATION_ERROR_0f6004ac -VALIDATION_ERROR_01498:VALIDATION_ERROR_0f62b00b -VALIDATION_ERROR_01499:VALIDATION_ERROR_0f61c40d -VALIDATION_ERROR_01500:VALIDATION_ERROR_0f609005 -VALIDATION_ERROR_01501:VALIDATION_ERROR_0f604001 -VALIDATION_ERROR_01502:VALIDATION_ERROR_0f609601 -VALIDATION_ERROR_01503:VALIDATION_ERROR_0f601201 -VALIDATION_ERROR_01504:VALIDATION_ERROR_1ce004ae -VALIDATION_ERROR_01505:VALIDATION_ERROR_1ce004b0 -VALIDATION_ERROR_01506:VALIDATION_ERROR_1ce004b2 -VALIDATION_ERROR_01507:VALIDATION_ERROR_1ce02401 -VALIDATION_ERROR_01508:VALIDATION_ERROR_1ce02413 -VALIDATION_ERROR_01509:VALIDATION_ERROR_1ce02415 -VALIDATION_ERROR_01510:VALIDATION_ERROR_13a08601 -VALIDATION_ERROR_01511:VALIDATION_ERROR_13a27801 -VALIDATION_ERROR_01512:VALIDATION_ERROR_13a04201 -VALIDATION_ERROR_01513:VALIDATION_ERROR_13a02a01 -VALIDATION_ERROR_01514:VALIDATION_ERROR_1da004b4 -VALIDATION_ERROR_01515:VALIDATION_ERROR_1da02401 -VALIDATION_ERROR_01516:VALIDATION_ERROR_1da08401 -VALIDATION_ERROR_01517:VALIDATION_ERROR_1da08403 -VALIDATION_ERROR_01518:VALIDATION_ERROR_1da02413 -VALIDATION_ERROR_01519:VALIDATION_ERROR_1da02415 -VALIDATION_ERROR_01520:VALIDATION_ERROR_1de004b6 -VALIDATION_ERROR_01521:VALIDATION_ERROR_1de02401 -VALIDATION_ERROR_01522:VALIDATION_ERROR_1de08401 -VALIDATION_ERROR_01523:VALIDATION_ERROR_1de08403 -VALIDATION_ERROR_01524:VALIDATION_ERROR_1de02413 -VALIDATION_ERROR_01525:VALIDATION_ERROR_1de02415 -VALIDATION_ERROR_01526:VALIDATION_ERROR_1dc004b8 -VALIDATION_ERROR_01527:VALIDATION_ERROR_1dc02401 -VALIDATION_ERROR_01528:VALIDATION_ERROR_1dc08401 -VALIDATION_ERROR_01529:VALIDATION_ERROR_1dc08403 -VALIDATION_ERROR_01530:VALIDATION_ERROR_1dc02413 -VALIDATION_ERROR_01531:VALIDATION_ERROR_1dc02415 -VALIDATION_ERROR_01532:VALIDATION_ERROR_0f4004ba -VALIDATION_ERROR_01533:VALIDATION_ERROR_0f4004bc -VALIDATION_ERROR_01534:VALIDATION_ERROR_0f4004be -VALIDATION_ERROR_01535:VALIDATION_ERROR_0f42b00b -VALIDATION_ERROR_01536:VALIDATION_ERROR_0f41c40d -VALIDATION_ERROR_01537:VALIDATION_ERROR_0f409005 -VALIDATION_ERROR_01538:VALIDATION_ERROR_0f40f201 -VALIDATION_ERROR_01539:VALIDATION_ERROR_0f2004c0 -VALIDATION_ERROR_01540:VALIDATION_ERROR_0f2004c2 -VALIDATION_ERROR_01541:VALIDATION_ERROR_0f2004c4 -VALIDATION_ERROR_01542:VALIDATION_ERROR_0f2004c6 -VALIDATION_ERROR_01543:VALIDATION_ERROR_0f22cc01 -VALIDATION_ERROR_01544:VALIDATION_ERROR_0f207001 -VALIDATION_ERROR_01545:VALIDATION_ERROR_0f202001 -VALIDATION_ERROR_01546:VALIDATION_ERROR_0f22c601 -VALIDATION_ERROR_01547:VALIDATION_ERROR_0f206a01 -VALIDATION_ERROR_01548:VALIDATION_ERROR_0f200801 -VALIDATION_ERROR_01549:VALIDATION_ERROR_0f202201 -VALIDATION_ERROR_01550:VALIDATION_ERROR_1ca004c8 -VALIDATION_ERROR_01551:VALIDATION_ERROR_1ca02401 -VALIDATION_ERROR_01552:VALIDATION_ERROR_1ca02413 -VALIDATION_ERROR_01553:VALIDATION_ERROR_1ca02415 -VALIDATION_ERROR_01558:VALIDATION_ERROR_19c0030c -VALIDATION_ERROR_01559:VALIDATION_ERROR_19c02401 -VALIDATION_ERROR_01560:VALIDATION_ERROR_19c02413 -VALIDATION_ERROR_01561:VALIDATION_ERROR_19c02415 -VALIDATION_ERROR_01562:VALIDATION_ERROR_19c00017 -VALIDATION_ERROR_01564:VALIDATION_ERROR_1a000326 -VALIDATION_ERROR_01565:VALIDATION_ERROR_1a002401 -VALIDATION_ERROR_01566:VALIDATION_ERROR_1a001a01 -VALIDATION_ERROR_01567:VALIDATION_ERROR_1a002413 -VALIDATION_ERROR_01568:VALIDATION_ERROR_1a002415 -VALIDATION_ERROR_01569:VALIDATION_ERROR_1a000017 -VALIDATION_ERROR_01570:VALIDATION_ERROR_1a000009 -VALIDATION_ERROR_01571:VALIDATION_ERROR_06e00342 -VALIDATION_ERROR_01572:VALIDATION_ERROR_06e00344 -VALIDATION_ERROR_01573:VALIDATION_ERROR_06e00346 -VALIDATION_ERROR_01600:VALIDATION_ERROR_2de0088c -VALIDATION_ERROR_01601:VALIDATION_ERROR_2de27a01 -VALIDATION_ERROR_01602:VALIDATION_ERROR_2de09201 -VALIDATION_ERROR_01603:VALIDATION_ERROR_2de30401 -VALIDATION_ERROR_01604:VALIDATION_ERROR_2de2b401 -VALIDATION_ERROR_01605:VALIDATION_ERROR_2de30601 -VALIDATION_ERROR_01606:VALIDATION_ERROR_2de30603 -VALIDATION_ERROR_01607:VALIDATION_ERROR_2de2fa01 -VALIDATION_ERROR_01608:VALIDATION_ERROR_2de1f601 -VALIDATION_ERROR_01609:VALIDATION_ERROR_2de1f401 -VALIDATION_ERROR_01610:VALIDATION_ERROR_2a405601 -VALIDATION_ERROR_01611:VALIDATION_ERROR_2a40a001 -VALIDATION_ERROR_01612:VALIDATION_ERROR_2a423601 -VALIDATION_ERROR_01613:VALIDATION_ERROR_2a423801 -VALIDATION_ERROR_01614:VALIDATION_ERROR_2a40a007 -VALIDATION_ERROR_01616:VALIDATION_ERROR_13400892 -VALIDATION_ERROR_01617:VALIDATION_ERROR_13400894 -VALIDATION_ERROR_01618:VALIDATION_ERROR_13400896 -VALIDATION_ERROR_01619:VALIDATION_ERROR_13400898 -VALIDATION_ERROR_01620:VALIDATION_ERROR_1340089a -VALIDATION_ERROR_01621:VALIDATION_ERROR_1340089c -VALIDATION_ERROR_01622:VALIDATION_ERROR_1340c601 -VALIDATION_ERROR_01623:VALIDATION_ERROR_13409001 -VALIDATION_ERROR_01624:VALIDATION_ERROR_12c01a01 -VALIDATION_ERROR_01625:VALIDATION_ERROR_12c0fe01 -VALIDATION_ERROR_01626:VALIDATION_ERROR_12c0141b -VALIDATION_ERROR_01627:VALIDATION_ERROR_1320089e -VALIDATION_ERROR_01628:VALIDATION_ERROR_1320a001 -VALIDATION_ERROR_01629:VALIDATION_ERROR_1320fe01 -VALIDATION_ERROR_01630:VALIDATION_ERROR_1320141b -VALIDATION_ERROR_01631:VALIDATION_ERROR_1300a001 -VALIDATION_ERROR_01632:VALIDATION_ERROR_1300fe01 -VALIDATION_ERROR_01633:VALIDATION_ERROR_1300141b -VALIDATION_ERROR_01634:VALIDATION_ERROR_12e008a0 -VALIDATION_ERROR_01637:VALIDATION_ERROR_12e008a6 -VALIDATION_ERROR_01638:VALIDATION_ERROR_12e008a8 -VALIDATION_ERROR_01639:VALIDATION_ERROR_12e008aa -VALIDATION_ERROR_01640:VALIDATION_ERROR_12e008ac -VALIDATION_ERROR_01641:VALIDATION_ERROR_12e008ae -VALIDATION_ERROR_01642:VALIDATION_ERROR_12e008b0 -VALIDATION_ERROR_01643:VALIDATION_ERROR_12e2e801 -VALIDATION_ERROR_01644:VALIDATION_ERROR_12e0c601 -VALIDATION_ERROR_01645:VALIDATION_ERROR_12e09001 -VALIDATION_ERROR_01646:VALIDATION_ERROR_316008b2 -VALIDATION_ERROR_01647:VALIDATION_ERROR_316008b4 -VALIDATION_ERROR_01648:VALIDATION_ERROR_31629c01 -VALIDATION_ERROR_01649:VALIDATION_ERROR_3160f801 -VALIDATION_ERROR_01650:VALIDATION_ERROR_31608801 -VALIDATION_ERROR_01651:VALIDATION_ERROR_31600011 -VALIDATION_ERROR_01652:VALIDATION_ERROR_31600009 -VALIDATION_ERROR_01653:VALIDATION_ERROR_0122b00b -VALIDATION_ERROR_01655:VALIDATION_ERROR_01227601 -VALIDATION_ERROR_01656:VALIDATION_ERROR_01210201 -VALIDATION_ERROR_01657:VALIDATION_ERROR_01218c01 -VALIDATION_ERROR_01658:VALIDATION_ERROR_01218001 -VALIDATION_ERROR_01659:VALIDATION_ERROR_01223401 -VALIDATION_ERROR_01660:VALIDATION_ERROR_01200009 -VALIDATION_ERROR_01665:VALIDATION_ERROR_27c1f601 -VALIDATION_ERROR_01666:VALIDATION_ERROR_27c1f401 -VALIDATION_ERROR_01667:VALIDATION_ERROR_27827a01 -VALIDATION_ERROR_01668:VALIDATION_ERROR_2781f601 -VALIDATION_ERROR_01669:VALIDATION_ERROR_2781f401 -VALIDATION_ERROR_01671:VALIDATION_ERROR_27a19e01 -VALIDATION_ERROR_01672:VALIDATION_ERROR_27a1f601 -VALIDATION_ERROR_01675:VALIDATION_ERROR_27627a01 -VALIDATION_ERROR_01676:VALIDATION_ERROR_27619e01 -VALIDATION_ERROR_01677:VALIDATION_ERROR_2761f601 -VALIDATION_ERROR_01679:VALIDATION_ERROR_2c016e01 -VALIDATION_ERROR_01680:VALIDATION_ERROR_0e200486 -VALIDATION_ERROR_01683:VALIDATION_ERROR_2c427a01 -VALIDATION_ERROR_01684:VALIDATION_ERROR_2c409201 -VALIDATION_ERROR_01685:VALIDATION_ERROR_2c417601 -VALIDATION_ERROR_01686:VALIDATION_ERROR_2ca27a01 -VALIDATION_ERROR_01687:VALIDATION_ERROR_2ca09201 -VALIDATION_ERROR_01688:VALIDATION_ERROR_2ca30401 -VALIDATION_ERROR_01689:VALIDATION_ERROR_2ca2fa01 -VALIDATION_ERROR_01690:VALIDATION_ERROR_2ca30601 -VALIDATION_ERROR_01691:VALIDATION_ERROR_2ca30603 -VALIDATION_ERROR_01692:VALIDATION_ERROR_2ca09001 -VALIDATION_ERROR_01693:VALIDATION_ERROR_2ca18401 -VALIDATION_ERROR_01694:VALIDATION_ERROR_1582b00b -VALIDATION_ERROR_01696:VALIDATION_ERROR_1560e401 -VALIDATION_ERROR_01697:VALIDATION_ERROR_1560e201 -VALIDATION_ERROR_01698:VALIDATION_ERROR_1560e801 -VALIDATION_ERROR_01699:VALIDATION_ERROR_15621401 -VALIDATION_ERROR_01700:VALIDATION_ERROR_15621201 -VALIDATION_ERROR_01701:VALIDATION_ERROR_15600009 -VALIDATION_ERROR_01702:VALIDATION_ERROR_12000710 -VALIDATION_ERROR_01703:VALIDATION_ERROR_04200512 -VALIDATION_ERROR_01704:VALIDATION_ERROR_04200514 -VALIDATION_ERROR_01705:VALIDATION_ERROR_04200516 -VALIDATION_ERROR_01706:VALIDATION_ERROR_04200518 -VALIDATION_ERROR_01707:VALIDATION_ERROR_0420051a -VALIDATION_ERROR_01708:VALIDATION_ERROR_0422b00b -VALIDATION_ERROR_01710:VALIDATION_ERROR_0420a001 -VALIDATION_ERROR_01711:VALIDATION_ERROR_04201a01 -VALIDATION_ERROR_01712:VALIDATION_ERROR_04200009 -VALIDATION_ERROR_01719:VALIDATION_ERROR_0840f401 -VALIDATION_ERROR_01724:VALIDATION_ERROR_2b000a5c -VALIDATION_ERROR_01725:VALIDATION_ERROR_2b005601 -VALIDATION_ERROR_01726:VALIDATION_ERROR_2b00c601 -VALIDATION_ERROR_01727:VALIDATION_ERROR_2b009c01 -VALIDATION_ERROR_01728:VALIDATION_ERROR_2b009c03 -VALIDATION_ERROR_01729:VALIDATION_ERROR_2b017c01 -VALIDATION_ERROR_01730:VALIDATION_ERROR_2b00c607 -VALIDATION_ERROR_01731:VALIDATION_ERROR_03e00732 -VALIDATION_ERROR_01732:VALIDATION_ERROR_03e2b00b -VALIDATION_ERROR_01733:VALIDATION_ERROR_08c1c40d -VALIDATION_ERROR_01734:VALIDATION_ERROR_040007c4 -VALIDATION_ERROR_01735:VALIDATION_ERROR_0402b00b -VALIDATION_ERROR_01737:VALIDATION_ERROR_0902b00b -VALIDATION_ERROR_01738:VALIDATION_ERROR_0901c40d -VALIDATION_ERROR_01739:VALIDATION_ERROR_09009e01 -VALIDATION_ERROR_01741:VALIDATION_ERROR_12600872 -VALIDATION_ERROR_01742:VALIDATION_ERROR_09c00124 -VALIDATION_ERROR_01743:VALIDATION_ERROR_09c00128 -VALIDATION_ERROR_01744:VALIDATION_ERROR_09c00130 -VALIDATION_ERROR_01745:VALIDATION_ERROR_09c00134 -VALIDATION_ERROR_01746:VALIDATION_ERROR_0160018e -VALIDATION_ERROR_01747:VALIDATION_ERROR_01600192 -VALIDATION_ERROR_01748:VALIDATION_ERROR_09a001ea -VALIDATION_ERROR_01749:VALIDATION_ERROR_09a001ee -VALIDATION_ERROR_01750:VALIDATION_ERROR_09a001f4 -VALIDATION_ERROR_01751:VALIDATION_ERROR_09a001f8 -VALIDATION_ERROR_01752:VALIDATION_ERROR_0a20021a -VALIDATION_ERROR_01753:VALIDATION_ERROR_0a20021c -VALIDATION_ERROR_01754:VALIDATION_ERROR_0a20021e -VALIDATION_ERROR_01755:VALIDATION_ERROR_0a200220 -VALIDATION_ERROR_01756:VALIDATION_ERROR_0a200222 -VALIDATION_ERROR_01757:VALIDATION_ERROR_0a200224 -VALIDATION_ERROR_01758:VALIDATION_ERROR_0a200226 -VALIDATION_ERROR_01759:VALIDATION_ERROR_0a200228 -VALIDATION_ERROR_01760:VALIDATION_ERROR_0a20022a -VALIDATION_ERROR_01761:VALIDATION_ERROR_0a20022c -VALIDATION_ERROR_01762:VALIDATION_ERROR_1a200366 -VALIDATION_ERROR_01763:VALIDATION_ERROR_1a200368 -VALIDATION_ERROR_01764:VALIDATION_ERROR_1a40038c -VALIDATION_ERROR_01765:VALIDATION_ERROR_1a40038e -VALIDATION_ERROR_01766:VALIDATION_ERROR_1ac003ec -VALIDATION_ERROR_01767:VALIDATION_ERROR_1ac003ee -VALIDATION_ERROR_01768:VALIDATION_ERROR_1ac003f0 -VALIDATION_ERROR_01769:VALIDATION_ERROR_1ac003f2 -VALIDATION_ERROR_01770:VALIDATION_ERROR_1ac003f4 -VALIDATION_ERROR_01771:VALIDATION_ERROR_1ac02401 -VALIDATION_ERROR_01772:VALIDATION_ERROR_1ac01a01 -VALIDATION_ERROR_01773:VALIDATION_ERROR_1ac03401 -VALIDATION_ERROR_01774:VALIDATION_ERROR_1ac02413 -VALIDATION_ERROR_01775:VALIDATION_ERROR_1ac02415 -VALIDATION_ERROR_01776:VALIDATION_ERROR_1ac00017 -VALIDATION_ERROR_01777:VALIDATION_ERROR_1ac00009 -VALIDATION_ERROR_01778:VALIDATION_ERROR_1a800456 -VALIDATION_ERROR_01779:VALIDATION_ERROR_1a800458 -VALIDATION_ERROR_01780:VALIDATION_ERROR_1a80045a -VALIDATION_ERROR_01781:VALIDATION_ERROR_1a80045c -VALIDATION_ERROR_01782:VALIDATION_ERROR_1a80045e -VALIDATION_ERROR_01783:VALIDATION_ERROR_1a802401 -VALIDATION_ERROR_01784:VALIDATION_ERROR_1a801a01 -VALIDATION_ERROR_01785:VALIDATION_ERROR_1a803401 -VALIDATION_ERROR_01786:VALIDATION_ERROR_1a802413 -VALIDATION_ERROR_01787:VALIDATION_ERROR_1a802415 -VALIDATION_ERROR_01788:VALIDATION_ERROR_1a800017 -VALIDATION_ERROR_01789:VALIDATION_ERROR_1a800009 -VALIDATION_ERROR_01790:VALIDATION_ERROR_1500099c -VALIDATION_ERROR_01791:VALIDATION_ERROR_1042b00b -VALIDATION_ERROR_01793:VALIDATION_ERROR_1042a601 -VALIDATION_ERROR_01794:VALIDATION_ERROR_1ea0bc01 -VALIDATION_ERROR_01795:VALIDATION_ERROR_1ea11e01 -VALIDATION_ERROR_01796:VALIDATION_ERROR_1ea0ec01 -VALIDATION_ERROR_01797:VALIDATION_ERROR_1ea24801 -VALIDATION_ERROR_01798:VALIDATION_ERROR_004009c0 -VALIDATION_ERROR_01799:VALIDATION_ERROR_0042b00b -VALIDATION_ERROR_01800:VALIDATION_ERROR_0041c40d -VALIDATION_ERROR_01801:VALIDATION_ERROR_00409005 -VALIDATION_ERROR_01802:VALIDATION_ERROR_2160bc01 -VALIDATION_ERROR_01803:VALIDATION_ERROR_21611e01 -VALIDATION_ERROR_01804:VALIDATION_ERROR_2160ec01 -VALIDATION_ERROR_01805:VALIDATION_ERROR_21624801 -VALIDATION_ERROR_01806:VALIDATION_ERROR_0ca009de -VALIDATION_ERROR_01807:VALIDATION_ERROR_0ca009e0 -VALIDATION_ERROR_01808:VALIDATION_ERROR_0ca2b00b -VALIDATION_ERROR_01809:VALIDATION_ERROR_0ca1c40d -VALIDATION_ERROR_01810:VALIDATION_ERROR_0ca09005 -VALIDATION_ERROR_01811:VALIDATION_ERROR_22e0bc01 -VALIDATION_ERROR_01812:VALIDATION_ERROR_22e11e01 -VALIDATION_ERROR_01813:VALIDATION_ERROR_22e0ec01 -VALIDATION_ERROR_01814:VALIDATION_ERROR_22e24801 -VALIDATION_ERROR_01815:VALIDATION_ERROR_15400a30 -VALIDATION_ERROR_01816:VALIDATION_ERROR_15400a32 -VALIDATION_ERROR_01817:VALIDATION_ERROR_1542b00b -VALIDATION_ERROR_01818:VALIDATION_ERROR_1541c40d -VALIDATION_ERROR_01819:VALIDATION_ERROR_15409005 -VALIDATION_ERROR_01820:VALIDATION_ERROR_2300bc01 -VALIDATION_ERROR_01821:VALIDATION_ERROR_23011e01 -VALIDATION_ERROR_01822:VALIDATION_ERROR_2300ec01 -VALIDATION_ERROR_01823:VALIDATION_ERROR_23024801 -VALIDATION_ERROR_01824:VALIDATION_ERROR_15a2b00b -VALIDATION_ERROR_01825:VALIDATION_ERROR_15a1c40d -VALIDATION_ERROR_01826:VALIDATION_ERROR_15a09005 -VALIDATION_ERROR_01827:VALIDATION_ERROR_2320bc01 -VALIDATION_ERROR_01828:VALIDATION_ERROR_23211e01 -VALIDATION_ERROR_01829:VALIDATION_ERROR_2320ec01 -VALIDATION_ERROR_01830:VALIDATION_ERROR_23224801 -VALIDATION_ERROR_01831:VALIDATION_ERROR_15e2b00b -VALIDATION_ERROR_01832:VALIDATION_ERROR_15e1c40d -VALIDATION_ERROR_01833:VALIDATION_ERROR_15e09005 -VALIDATION_ERROR_01834:VALIDATION_ERROR_15e00a3c -VALIDATION_ERROR_01836:VALIDATION_ERROR_2340bc01 -VALIDATION_ERROR_01837:VALIDATION_ERROR_23411e01 -VALIDATION_ERROR_01838:VALIDATION_ERROR_2340ec01 -VALIDATION_ERROR_01839:VALIDATION_ERROR_23424801 -VALIDATION_ERROR_01840:VALIDATION_ERROR_1602b00b -VALIDATION_ERROR_01841:VALIDATION_ERROR_1601c40d -VALIDATION_ERROR_01842:VALIDATION_ERROR_16009005 -VALIDATION_ERROR_01843:VALIDATION_ERROR_16000a42 -VALIDATION_ERROR_01844:VALIDATION_ERROR_26c009e4 -VALIDATION_ERROR_01845:VALIDATION_ERROR_26c009e6 -VALIDATION_ERROR_01846:VALIDATION_ERROR_26c009e8 -VALIDATION_ERROR_01847:VALIDATION_ERROR_26c0bc01 -VALIDATION_ERROR_01848:VALIDATION_ERROR_26c2ec01 -VALIDATION_ERROR_01849:VALIDATION_ERROR_26c0ec01 -VALIDATION_ERROR_01850:VALIDATION_ERROR_26c2ec07 -VALIDATION_ERROR_01851:VALIDATION_ERROR_2b827a01 -VALIDATION_ERROR_01852:VALIDATION_ERROR_2b81f601 -VALIDATION_ERROR_01853:VALIDATION_ERROR_2b81f401 -VALIDATION_ERROR_01854:VALIDATION_ERROR_2b627a01 -VALIDATION_ERROR_01855:VALIDATION_ERROR_2b61f601 -VALIDATION_ERROR_01856:VALIDATION_ERROR_2b61f401 -VALIDATION_ERROR_01857:VALIDATION_ERROR_29c009c2 -VALIDATION_ERROR_01858:VALIDATION_ERROR_29c27a01 -VALIDATION_ERROR_01859:VALIDATION_ERROR_29c14a01 -VALIDATION_ERROR_01860:VALIDATION_ERROR_29c15201 -VALIDATION_ERROR_01861:VALIDATION_ERROR_29827a01 -VALIDATION_ERROR_01862:VALIDATION_ERROR_29806001 -VALIDATION_ERROR_01863:VALIDATION_ERROR_2981f601 -VALIDATION_ERROR_01864:VALIDATION_ERROR_2981f401 -VALIDATION_ERROR_01865:VALIDATION_ERROR_1fe27a01 -VALIDATION_ERROR_01866:VALIDATION_ERROR_1fe06001 -VALIDATION_ERROR_01867:VALIDATION_ERROR_1fe11e01 -VALIDATION_ERROR_01868:VALIDATION_ERROR_1fe0ec01 -VALIDATION_ERROR_01869:VALIDATION_ERROR_1fe1bc01 -VALIDATION_ERROR_01870:VALIDATION_ERROR_072009c4 -VALIDATION_ERROR_01871:VALIDATION_ERROR_072009c6 -VALIDATION_ERROR_01872:VALIDATION_ERROR_0722b00b -VALIDATION_ERROR_01873:VALIDATION_ERROR_0721c40d -VALIDATION_ERROR_01874:VALIDATION_ERROR_07209005 -VALIDATION_ERROR_01875:VALIDATION_ERROR_29a27a01 -VALIDATION_ERROR_01876:VALIDATION_ERROR_29a0ce01 -VALIDATION_ERROR_01877:VALIDATION_ERROR_29a10a01 -VALIDATION_ERROR_01878:VALIDATION_ERROR_2000bc01 -VALIDATION_ERROR_01879:VALIDATION_ERROR_20011e01 -VALIDATION_ERROR_01880:VALIDATION_ERROR_2000ec01 -VALIDATION_ERROR_01881:VALIDATION_ERROR_20024801 -VALIDATION_ERROR_01882:VALIDATION_ERROR_078009c8 -VALIDATION_ERROR_01883:VALIDATION_ERROR_0782b00b -VALIDATION_ERROR_01884:VALIDATION_ERROR_0781c40d -VALIDATION_ERROR_01885:VALIDATION_ERROR_07809005 -VALIDATION_ERROR_01886:VALIDATION_ERROR_07806401 -VALIDATION_ERROR_01887:VALIDATION_ERROR_07830201 -VALIDATION_ERROR_01888:VALIDATION_ERROR_07800a01 -VALIDATION_ERROR_01889:VALIDATION_ERROR_2ee009ea -VALIDATION_ERROR_01890:VALIDATION_ERROR_2ee27a01 -VALIDATION_ERROR_01891:VALIDATION_ERROR_2ee2ec01 -VALIDATION_ERROR_01892:VALIDATION_ERROR_2ee24601 -VALIDATION_ERROR_01893:VALIDATION_ERROR_2d2009e2 -VALIDATION_ERROR_01894:VALIDATION_ERROR_2d227a01 -VALIDATION_ERROR_01895:VALIDATION_ERROR_2d203001 -VALIDATION_ERROR_01896:VALIDATION_ERROR_2f000a34 -VALIDATION_ERROR_01897:VALIDATION_ERROR_2f027a01 -VALIDATION_ERROR_01898:VALIDATION_ERROR_2f006001 -VALIDATION_ERROR_01899:VALIDATION_ERROR_2f200a3a -VALIDATION_ERROR_01900:VALIDATION_ERROR_2f227a01 -VALIDATION_ERROR_01901:VALIDATION_ERROR_2f400a40 -VALIDATION_ERROR_01902:VALIDATION_ERROR_2f427a01 -VALIDATION_ERROR_01903:VALIDATION_ERROR_2f403001 -VALIDATION_ERROR_01904:VALIDATION_ERROR_2f600a46 -VALIDATION_ERROR_01905:VALIDATION_ERROR_2f627a01 -VALIDATION_ERROR_01906:VALIDATION_ERROR_2f606601 -VALIDATION_ERROR_01907:VALIDATION_ERROR_2e627a01 -VALIDATION_ERROR_01908:VALIDATION_ERROR_2e62ec01 -VALIDATION_ERROR_01909:VALIDATION_ERROR_2e624a01 -VALIDATION_ERROR_01910:VALIDATION_ERROR_2ea27a01 -VALIDATION_ERROR_01911:VALIDATION_ERROR_2ea2ec01 -VALIDATION_ERROR_01912:VALIDATION_ERROR_2ea24c01 -VALIDATION_ERROR_01913:VALIDATION_ERROR_2ea24e01 -VALIDATION_ERROR_01914:VALIDATION_ERROR_2ec27a01 -VALIDATION_ERROR_01915:VALIDATION_ERROR_2ec2ec01 -VALIDATION_ERROR_01916:VALIDATION_ERROR_2ec1e801 -VALIDATION_ERROR_01917:VALIDATION_ERROR_2ec1ea01 -VALIDATION_ERROR_01918:VALIDATION_ERROR_22a05601 -VALIDATION_ERROR_01919:VALIDATION_ERROR_22a11e01 -VALIDATION_ERROR_01920:VALIDATION_ERROR_22a0ec01 -VALIDATION_ERROR_01921:VALIDATION_ERROR_22a25201 -VALIDATION_ERROR_01922:VALIDATION_ERROR_146009ec -VALIDATION_ERROR_01923:VALIDATION_ERROR_1462b00b -VALIDATION_ERROR_01926:VALIDATION_ERROR_1462ec01 -VALIDATION_ERROR_01927:VALIDATION_ERROR_1460a401 -VALIDATION_ERROR_01928:VALIDATION_ERROR_1460a201 -VALIDATION_ERROR_01929:VALIDATION_ERROR_1460ae01 -VALIDATION_ERROR_01930:VALIDATION_ERROR_1460ae03 -VALIDATION_ERROR_01931:VALIDATION_ERROR_1460a801 -VALIDATION_ERROR_01932:VALIDATION_ERROR_14629401 -VALIDATION_ERROR_01933:VALIDATION_ERROR_14602e01 -VALIDATION_ERROR_01934:VALIDATION_ERROR_14629601 -VALIDATION_ERROR_01935:VALIDATION_ERROR_1460de01 -VALIDATION_ERROR_01936:VALIDATION_ERROR_1460de07 -VALIDATION_ERROR_01937:VALIDATION_ERROR_26e00a04 -VALIDATION_ERROR_01938:VALIDATION_ERROR_26e00a06 -VALIDATION_ERROR_01939:VALIDATION_ERROR_26e00a08 -VALIDATION_ERROR_01940:VALIDATION_ERROR_26e05601 -VALIDATION_ERROR_01941:VALIDATION_ERROR_26e2f001 -VALIDATION_ERROR_01942:VALIDATION_ERROR_26e0ec01 -VALIDATION_ERROR_01943:VALIDATION_ERROR_22805601 -VALIDATION_ERROR_01944:VALIDATION_ERROR_22812001 -VALIDATION_ERROR_01945:VALIDATION_ERROR_2280ec01 -VALIDATION_ERROR_01946:VALIDATION_ERROR_22825801 -VALIDATION_ERROR_01947:VALIDATION_ERROR_2282f21b -VALIDATION_ERROR_01948:VALIDATION_ERROR_30805601 -VALIDATION_ERROR_01949:VALIDATION_ERROR_3082f001 -VALIDATION_ERROR_01950:VALIDATION_ERROR_30825401 -VALIDATION_ERROR_01951:VALIDATION_ERROR_30825601 -VALIDATION_ERROR_01952:VALIDATION_ERROR_16400a0c -VALIDATION_ERROR_01953:VALIDATION_ERROR_16400a0e -VALIDATION_ERROR_01954:VALIDATION_ERROR_16405601 -VALIDATION_ERROR_01955:VALIDATION_ERROR_1642f001 -VALIDATION_ERROR_01956:VALIDATION_ERROR_1642b801 -VALIDATION_ERROR_01957:VALIDATION_ERROR_16408801 -VALIDATION_ERROR_01958:VALIDATION_ERROR_16418601 -VALIDATION_ERROR_01959:VALIDATION_ERROR_1642b807 -VALIDATION_ERROR_01960:VALIDATION_ERROR_16408807 -VALIDATION_ERROR_01961:VALIDATION_ERROR_31800a18 -VALIDATION_ERROR_01962:VALIDATION_ERROR_31829c01 -VALIDATION_ERROR_01963:VALIDATION_ERROR_3181e601 -VALIDATION_ERROR_01964:VALIDATION_ERROR_11200a20 -VALIDATION_ERROR_01965:VALIDATION_ERROR_31800a1c -VALIDATION_ERROR_01966:VALIDATION_ERROR_1122b00b -VALIDATION_ERROR_01968:VALIDATION_ERROR_11227601 -VALIDATION_ERROR_01969:VALIDATION_ERROR_11225801 -VALIDATION_ERROR_01970:VALIDATION_ERROR_11218801 -VALIDATION_ERROR_01971:VALIDATION_ERROR_11221e01 -VALIDATION_ERROR_01972:VALIDATION_ERROR_1122f21b -VALIDATION_ERROR_01973:VALIDATION_ERROR_076009d2 -VALIDATION_ERROR_01974:VALIDATION_ERROR_076009d4 -VALIDATION_ERROR_01975:VALIDATION_ERROR_076009d6 -VALIDATION_ERROR_01976:VALIDATION_ERROR_0762b00b -VALIDATION_ERROR_01978:VALIDATION_ERROR_27a1f401 -VALIDATION_ERROR_01979:VALIDATION_ERROR_2c027a01 -VALIDATION_ERROR_01980:VALIDATION_ERROR_2bc27a01 -VALIDATION_ERROR_01981:VALIDATION_ERROR_2bc09201 -VALIDATION_ERROR_01982:VALIDATION_ERROR_2bc30401 -VALIDATION_ERROR_01983:VALIDATION_ERROR_2bc2fa01 -VALIDATION_ERROR_01984:VALIDATION_ERROR_2bc30601 -VALIDATION_ERROR_01985:VALIDATION_ERROR_2bc30603 -VALIDATION_ERROR_01986:VALIDATION_ERROR_2bc09001 -VALIDATION_ERROR_01988:VALIDATION_ERROR_2bc08201 -VALIDATION_ERROR_01990:VALIDATION_ERROR_2bc16601 -VALIDATION_ERROR_01998:VALIDATION_ERROR_236009a8 -VALIDATION_ERROR_01999:VALIDATION_ERROR_23605601 -VALIDATION_ERROR_02000:VALIDATION_ERROR_2361c201 -VALIDATION_ERROR_02001:VALIDATION_ERROR_0382b00b -VALIDATION_ERROR_02002:VALIDATION_ERROR_0381c40d -VALIDATION_ERROR_02003:VALIDATION_ERROR_0380da01 -VALIDATION_ERROR_02004:VALIDATION_ERROR_0381ce01 -VALIDATION_ERROR_02005:VALIDATION_ERROR_238009aa -VALIDATION_ERROR_02006:VALIDATION_ERROR_238009ac -VALIDATION_ERROR_02007:VALIDATION_ERROR_23805601 -VALIDATION_ERROR_02008:VALIDATION_ERROR_23825c01 -VALIDATION_ERROR_02009:VALIDATION_ERROR_03a2b00b -VALIDATION_ERROR_02010:VALIDATION_ERROR_03a1c40d -VALIDATION_ERROR_02011:VALIDATION_ERROR_03a0da01 -VALIDATION_ERROR_02012:VALIDATION_ERROR_03a25a01 -VALIDATION_ERROR_02013:VALIDATION_ERROR_03a2f41b -VALIDATION_ERROR_02014:VALIDATION_ERROR_19602401 -VALIDATION_ERROR_02015:VALIDATION_ERROR_1961a601 -VALIDATION_ERROR_02016:VALIDATION_ERROR_19602413 -VALIDATION_ERROR_02017:VALIDATION_ERROR_19602415 -VALIDATION_ERROR_02018:VALIDATION_ERROR_0362b00b -VALIDATION_ERROR_02019:VALIDATION_ERROR_0361c40d -VALIDATION_ERROR_02020:VALIDATION_ERROR_0361a801 -VALIDATION_ERROR_02021:VALIDATION_ERROR_198009ae -VALIDATION_ERROR_02022:VALIDATION_ERROR_19802401 -VALIDATION_ERROR_02023:VALIDATION_ERROR_19802413 -VALIDATION_ERROR_02024:VALIDATION_ERROR_19802415 -VALIDATION_ERROR_02025:VALIDATION_ERROR_19a02401 -VALIDATION_ERROR_02026:VALIDATION_ERROR_19a1a601 -VALIDATION_ERROR_02027:VALIDATION_ERROR_19a02413 -VALIDATION_ERROR_02028:VALIDATION_ERROR_19a02415 -VALIDATION_ERROR_02029:VALIDATION_ERROR_1f40bc01 -VALIDATION_ERROR_02030:VALIDATION_ERROR_1f411e01 -VALIDATION_ERROR_02031:VALIDATION_ERROR_1f40ec01 -VALIDATION_ERROR_02032:VALIDATION_ERROR_1f410801 -VALIDATION_ERROR_02033:VALIDATION_ERROR_03c2b00b -VALIDATION_ERROR_02034:VALIDATION_ERROR_03c1c40d -VALIDATION_ERROR_02035:VALIDATION_ERROR_03c09001 -VALIDATION_ERROR_02040:VALIDATION_ERROR_23a009b2 -VALIDATION_ERROR_02043:VALIDATION_ERROR_23a0bc01 -VALIDATION_ERROR_02044:VALIDATION_ERROR_23a09001 -VALIDATION_ERROR_02045:VALIDATION_ERROR_23a09003 -VALIDATION_ERROR_02046:VALIDATION_ERROR_23a0da01 -VALIDATION_ERROR_02047:VALIDATION_ERROR_23a1a001 -VALIDATION_ERROR_02048:VALIDATION_ERROR_23a1b801 -VALIDATION_ERROR_02049:VALIDATION_ERROR_242009b4 -VALIDATION_ERROR_02050:VALIDATION_ERROR_242009b6 -VALIDATION_ERROR_02051:VALIDATION_ERROR_2420bc01 -VALIDATION_ERROR_02052:VALIDATION_ERROR_24201e01 -VALIDATION_ERROR_02053:VALIDATION_ERROR_2420ec01 -VALIDATION_ERROR_02054:VALIDATION_ERROR_24201e07 -VALIDATION_ERROR_02055:VALIDATION_ERROR_06c002fc -VALIDATION_ERROR_02056:VALIDATION_ERROR_06c002fe -VALIDATION_ERROR_02057:VALIDATION_ERROR_1b2000c0 -VALIDATION_ERROR_02058:VALIDATION_ERROR_1b2000c2 -VALIDATION_ERROR_02059:VALIDATION_ERROR_1b2000c4 -VALIDATION_ERROR_02060:VALIDATION_ERROR_1b2000c6 -VALIDATION_ERROR_02061:VALIDATION_ERROR_1b2000c8 -VALIDATION_ERROR_02062:VALIDATION_ERROR_1b2000ca -VALIDATION_ERROR_02063:VALIDATION_ERROR_1b2000cc -VALIDATION_ERROR_02064:VALIDATION_ERROR_1b2000ce -VALIDATION_ERROR_02065:VALIDATION_ERROR_1b2000d0 -VALIDATION_ERROR_02066:VALIDATION_ERROR_1b2000d2 -VALIDATION_ERROR_02067:VALIDATION_ERROR_1e60090e -VALIDATION_ERROR_02068:VALIDATION_ERROR_1e600910 -VALIDATION_ERROR_02069:VALIDATION_ERROR_1e600912 -VALIDATION_ERROR_02070:VALIDATION_ERROR_1e600914 -VALIDATION_ERROR_02071:VALIDATION_ERROR_1e600916 -VALIDATION_ERROR_02072:VALIDATION_ERROR_1b80092a -VALIDATION_ERROR_02073:VALIDATION_ERROR_1b80092c -VALIDATION_ERROR_02074:VALIDATION_ERROR_1b80092e -VALIDATION_ERROR_02075:VALIDATION_ERROR_1b800930 -VALIDATION_ERROR_02076:VALIDATION_ERROR_1b800932 -VALIDATION_ERROR_02077:VALIDATION_ERROR_1b800934 -VALIDATION_ERROR_02078:VALIDATION_ERROR_1b800936 -VALIDATION_ERROR_02079:VALIDATION_ERROR_1b800938 -VALIDATION_ERROR_02080:VALIDATION_ERROR_1b80093a -VALIDATION_ERROR_02081:VALIDATION_ERROR_1b80093c -VALIDATION_ERROR_02082:VALIDATION_ERROR_12a00884 -VALIDATION_ERROR_02083:VALIDATION_ERROR_12a00886 -VALIDATION_ERROR_02084:VALIDATION_ERROR_10600588 -VALIDATION_ERROR_02085:VALIDATION_ERROR_1060058a -VALIDATION_ERROR_02086:VALIDATION_ERROR_1060058c -VALIDATION_ERROR_02087:VALIDATION_ERROR_1060058e -VALIDATION_ERROR_02088:VALIDATION_ERROR_10600590 -VALIDATION_ERROR_02089:VALIDATION_ERROR_10600592 -VALIDATION_ERROR_02090:VALIDATION_ERROR_10600594 -VALIDATION_ERROR_02091:VALIDATION_ERROR_10600596 -VALIDATION_ERROR_02092:VALIDATION_ERROR_10600598 -VALIDATION_ERROR_02093:VALIDATION_ERROR_1060059a -VALIDATION_ERROR_02094:VALIDATION_ERROR_1060059c -VALIDATION_ERROR_02095:VALIDATION_ERROR_1060059e -VALIDATION_ERROR_02096:VALIDATION_ERROR_096005ba -VALIDATION_ERROR_02097:VALIDATION_ERROR_096005bc -VALIDATION_ERROR_02098:VALIDATION_ERROR_096005be -VALIDATION_ERROR_02099:VALIDATION_ERROR_096005c0 -VALIDATION_ERROR_02100:VALIDATION_ERROR_096005c2 -VALIDATION_ERROR_02101:VALIDATION_ERROR_096005c4 -VALIDATION_ERROR_02102:VALIDATION_ERROR_096005c6 -VALIDATION_ERROR_02103:VALIDATION_ERROR_096005c8 -VALIDATION_ERROR_02104:VALIDATION_ERROR_096005ca -VALIDATION_ERROR_02105:VALIDATION_ERROR_096005cc -VALIDATION_ERROR_02106:VALIDATION_ERROR_096005ce -VALIDATION_ERROR_02107:VALIDATION_ERROR_096005d0 -VALIDATION_ERROR_02108:VALIDATION_ERROR_096005d2 -VALIDATION_ERROR_02109:VALIDATION_ERROR_096005d4 -VALIDATION_ERROR_02110:VALIDATION_ERROR_096005d6 -VALIDATION_ERROR_02111:VALIDATION_ERROR_096005d8 -VALIDATION_ERROR_02112:VALIDATION_ERROR_096005da -VALIDATION_ERROR_02113:VALIDATION_ERROR_096005dc -VALIDATION_ERROR_02114:VALIDATION_ERROR_096005de -VALIDATION_ERROR_02115:VALIDATION_ERROR_096005e0 -VALIDATION_ERROR_02116:VALIDATION_ERROR_096005e2 -VALIDATION_ERROR_02117:VALIDATION_ERROR_096005e4 -VALIDATION_ERROR_02118:VALIDATION_ERROR_096005e6 -VALIDATION_ERROR_02119:VALIDATION_ERROR_096005e8 -VALIDATION_ERROR_02120:VALIDATION_ERROR_096005ea -VALIDATION_ERROR_02121:VALIDATION_ERROR_096005ec -VALIDATION_ERROR_02122:VALIDATION_ERROR_096005ee -VALIDATION_ERROR_02123:VALIDATION_ERROR_0f000602 -VALIDATION_ERROR_02124:VALIDATION_ERROR_01a0074c -VALIDATION_ERROR_02125:VALIDATION_ERROR_09e00770 -VALIDATION_ERROR_02126:VALIDATION_ERROR_09e00772 -VALIDATION_ERROR_02127:VALIDATION_ERROR_09e00774 -VALIDATION_ERROR_02128:VALIDATION_ERROR_09e00776 -VALIDATION_ERROR_02129:VALIDATION_ERROR_09e00778 -VALIDATION_ERROR_02130:VALIDATION_ERROR_09e0077a -VALIDATION_ERROR_02131:VALIDATION_ERROR_09e0077c -VALIDATION_ERROR_02132:VALIDATION_ERROR_09e0077e -VALIDATION_ERROR_02133:VALIDATION_ERROR_09e00780 -VALIDATION_ERROR_02134:VALIDATION_ERROR_09e00784 -VALIDATION_ERROR_02135:VALIDATION_ERROR_09e00786 -VALIDATION_ERROR_02136:VALIDATION_ERROR_09e00788 -VALIDATION_ERROR_02137:VALIDATION_ERROR_09e0078a -VALIDATION_ERROR_02138:VALIDATION_ERROR_09e0078e -VALIDATION_ERROR_02142:VALIDATION_ERROR_09e00790 -VALIDATION_ERROR_02143:VALIDATION_ERROR_09e00792 -VALIDATION_ERROR_02144:VALIDATION_ERROR_09e00796 -VALIDATION_ERROR_02145:VALIDATION_ERROR_09e00798 -VALIDATION_ERROR_02146:VALIDATION_ERROR_09e0079a -VALIDATION_ERROR_02147:VALIDATION_ERROR_09e0079c -VALIDATION_ERROR_02148:VALIDATION_ERROR_09e0079e -VALIDATION_ERROR_02149:VALIDATION_ERROR_09e007a0 -VALIDATION_ERROR_02150:VALIDATION_ERROR_09e007a2 -VALIDATION_ERROR_02151:VALIDATION_ERROR_09e007a4 -VALIDATION_ERROR_02152:VALIDATION_ERROR_09e007a6 -VALIDATION_ERROR_02153:VALIDATION_ERROR_09e007a8 -VALIDATION_ERROR_02154:VALIDATION_ERROR_09e007aa -VALIDATION_ERROR_02155:VALIDATION_ERROR_09e007ac -VALIDATION_ERROR_02156:VALIDATION_ERROR_09e007ae -VALIDATION_ERROR_02157:VALIDATION_ERROR_09e007b0 -VALIDATION_ERROR_02158:VALIDATION_ERROR_09e007b2 -VALIDATION_ERROR_02159:VALIDATION_ERROR_09e007b4 -VALIDATION_ERROR_02160:VALIDATION_ERROR_09e007b6 -VALIDATION_ERROR_02161:VALIDATION_ERROR_0ac007e0 -VALIDATION_ERROR_02162:VALIDATION_ERROR_0ac007e2 -VALIDATION_ERROR_02163:VALIDATION_ERROR_0ac007e4 -VALIDATION_ERROR_02164:VALIDATION_ERROR_0ac007e6 -VALIDATION_ERROR_02165:VALIDATION_ERROR_0ac007e8 -VALIDATION_ERROR_02166:VALIDATION_ERROR_0ac007ea -VALIDATION_ERROR_02167:VALIDATION_ERROR_0ac007ec -VALIDATION_ERROR_02168:VALIDATION_ERROR_0ac007ee -VALIDATION_ERROR_02169:VALIDATION_ERROR_0ac007f0 -VALIDATION_ERROR_02171:VALIDATION_ERROR_0ac007f4 -VALIDATION_ERROR_02172:VALIDATION_ERROR_0ac007f6 -VALIDATION_ERROR_02173:VALIDATION_ERROR_0ac007fa -VALIDATION_ERROR_02174:VALIDATION_ERROR_17000818 -VALIDATION_ERROR_02175:VALIDATION_ERROR_1700081a -VALIDATION_ERROR_02176:VALIDATION_ERROR_1700081c -VALIDATION_ERROR_02177:VALIDATION_ERROR_1700081e -VALIDATION_ERROR_02178:VALIDATION_ERROR_17400830 -VALIDATION_ERROR_02179:VALIDATION_ERROR_17400832 -VALIDATION_ERROR_02180:VALIDATION_ERROR_17400834 -VALIDATION_ERROR_02181:VALIDATION_ERROR_17400836 -VALIDATION_ERROR_02182:VALIDATION_ERROR_184001b6 -VALIDATION_ERROR_02183:VALIDATION_ERROR_184001ba -VALIDATION_ERROR_02186:VALIDATION_ERROR_184001c0 -VALIDATION_ERROR_02187:VALIDATION_ERROR_184001c4 -VALIDATION_ERROR_02189:VALIDATION_ERROR_184001c8 -VALIDATION_ERROR_02190:VALIDATION_ERROR_184001ca -VALIDATION_ERROR_02191:VALIDATION_ERROR_184001cc -VALIDATION_ERROR_02192:VALIDATION_ERROR_184001ce -VALIDATION_ERROR_02193:VALIDATION_ERROR_184001d0 -VALIDATION_ERROR_02194:VALIDATION_ERROR_184001d2 -VALIDATION_ERROR_02195:VALIDATION_ERROR_184001d4 -VALIDATION_ERROR_02196:VALIDATION_ERROR_184001d6 -VALIDATION_ERROR_02197:VALIDATION_ERROR_184001d8 -VALIDATION_ERROR_02198:VALIDATION_ERROR_184001da -VALIDATION_ERROR_02199:VALIDATION_ERROR_1c800212 -VALIDATION_ERROR_02200:VALIDATION_ERROR_1a200370 -VALIDATION_ERROR_02202:VALIDATION_ERROR_1a200374 -VALIDATION_ERROR_02203:VALIDATION_ERROR_1a200376 -VALIDATION_ERROR_02204:VALIDATION_ERROR_1a200378 -VALIDATION_ERROR_02205:VALIDATION_ERROR_1a20037a -VALIDATION_ERROR_02206:VALIDATION_ERROR_1a20037c -VALIDATION_ERROR_02207:VALIDATION_ERROR_1a20037e -VALIDATION_ERROR_02208:VALIDATION_ERROR_1a200380 -VALIDATION_ERROR_02209:VALIDATION_ERROR_1a200382 -VALIDATION_ERROR_02210:VALIDATION_ERROR_1a200384 -VALIDATION_ERROR_02211:VALIDATION_ERROR_1a200386 -VALIDATION_ERROR_02212:VALIDATION_ERROR_1a200388 -VALIDATION_ERROR_02213:VALIDATION_ERROR_1a400396 -VALIDATION_ERROR_02215:VALIDATION_ERROR_1a40039a -VALIDATION_ERROR_02216:VALIDATION_ERROR_1a40039c -VALIDATION_ERROR_02217:VALIDATION_ERROR_1a40039e -VALIDATION_ERROR_02218:VALIDATION_ERROR_1a4003a0 -VALIDATION_ERROR_02219:VALIDATION_ERROR_1a4003a2 -VALIDATION_ERROR_02220:VALIDATION_ERROR_1a4003a4 -VALIDATION_ERROR_02221:VALIDATION_ERROR_1a4003a6 -VALIDATION_ERROR_02222:VALIDATION_ERROR_1a4003a8 -VALIDATION_ERROR_02223:VALIDATION_ERROR_1a4003aa -VALIDATION_ERROR_02224:VALIDATION_ERROR_1a4003ac -VALIDATION_ERROR_02225:VALIDATION_ERROR_1a4003ae -VALIDATION_ERROR_02226:VALIDATION_ERROR_1a4003b0 -VALIDATION_ERROR_02227:VALIDATION_ERROR_1aa003be -VALIDATION_ERROR_02228:VALIDATION_ERROR_1aa003c0 -VALIDATION_ERROR_02231:VALIDATION_ERROR_1aa003c6 -VALIDATION_ERROR_02232:VALIDATION_ERROR_1aa003c8 -VALIDATION_ERROR_02233:VALIDATION_ERROR_1aa003ca -VALIDATION_ERROR_02234:VALIDATION_ERROR_1aa003cc -VALIDATION_ERROR_02237:VALIDATION_ERROR_1aa003d2 -VALIDATION_ERROR_02238:VALIDATION_ERROR_1aa003d4 -VALIDATION_ERROR_02239:VALIDATION_ERROR_1aa003d6 -VALIDATION_ERROR_02240:VALIDATION_ERROR_1aa003d8 -VALIDATION_ERROR_02241:VALIDATION_ERROR_1aa003da -VALIDATION_ERROR_02242:VALIDATION_ERROR_1aa003dc -VALIDATION_ERROR_02243:VALIDATION_ERROR_1aa003de -VALIDATION_ERROR_02244:VALIDATION_ERROR_1aa003e0 -VALIDATION_ERROR_02245:VALIDATION_ERROR_1aa003e2 -VALIDATION_ERROR_02246:VALIDATION_ERROR_1aa003e4 -VALIDATION_ERROR_02247:VALIDATION_ERROR_1ac003f6 -VALIDATION_ERROR_02248:VALIDATION_ERROR_1ac003f8 -VALIDATION_ERROR_02251:VALIDATION_ERROR_1ac003fe -VALIDATION_ERROR_02252:VALIDATION_ERROR_1ac00400 -VALIDATION_ERROR_02253:VALIDATION_ERROR_1ac00402 -VALIDATION_ERROR_02254:VALIDATION_ERROR_1ac00404 -VALIDATION_ERROR_02255:VALIDATION_ERROR_1ac00406 -VALIDATION_ERROR_02257:VALIDATION_ERROR_1ac0040a -VALIDATION_ERROR_02258:VALIDATION_ERROR_1ac0040c -VALIDATION_ERROR_02259:VALIDATION_ERROR_1ac0040e -VALIDATION_ERROR_02260:VALIDATION_ERROR_1ac00410 -VALIDATION_ERROR_02261:VALIDATION_ERROR_1ac00412 -VALIDATION_ERROR_02262:VALIDATION_ERROR_1ac00414 -VALIDATION_ERROR_02263:VALIDATION_ERROR_1ac00416 -VALIDATION_ERROR_02264:VALIDATION_ERROR_1ac00418 -VALIDATION_ERROR_02265:VALIDATION_ERROR_1a600426 -VALIDATION_ERROR_02266:VALIDATION_ERROR_1a600428 -VALIDATION_ERROR_02269:VALIDATION_ERROR_1a60042e -VALIDATION_ERROR_02270:VALIDATION_ERROR_1a600430 -VALIDATION_ERROR_02271:VALIDATION_ERROR_1a600432 -VALIDATION_ERROR_02272:VALIDATION_ERROR_1a600434 -VALIDATION_ERROR_02275:VALIDATION_ERROR_1a60043a -VALIDATION_ERROR_02276:VALIDATION_ERROR_1a60043c -VALIDATION_ERROR_02277:VALIDATION_ERROR_1a60043e -VALIDATION_ERROR_02278:VALIDATION_ERROR_1a600440 -VALIDATION_ERROR_02279:VALIDATION_ERROR_1a600442 -VALIDATION_ERROR_02280:VALIDATION_ERROR_1a600444 -VALIDATION_ERROR_02281:VALIDATION_ERROR_1a600446 -VALIDATION_ERROR_02282:VALIDATION_ERROR_1a600448 -VALIDATION_ERROR_02283:VALIDATION_ERROR_1a60044a -VALIDATION_ERROR_02284:VALIDATION_ERROR_1a60044c -VALIDATION_ERROR_02285:VALIDATION_ERROR_07a00454 -VALIDATION_ERROR_02286:VALIDATION_ERROR_1a800460 -VALIDATION_ERROR_02287:VALIDATION_ERROR_1a800462 -VALIDATION_ERROR_02290:VALIDATION_ERROR_1a800468 -VALIDATION_ERROR_02291:VALIDATION_ERROR_1a80046a -VALIDATION_ERROR_02292:VALIDATION_ERROR_1a80046c -VALIDATION_ERROR_02293:VALIDATION_ERROR_1a80046e -VALIDATION_ERROR_02294:VALIDATION_ERROR_1a800470 -VALIDATION_ERROR_02296:VALIDATION_ERROR_1a800474 -VALIDATION_ERROR_02297:VALIDATION_ERROR_1a800476 -VALIDATION_ERROR_02298:VALIDATION_ERROR_1a800478 -VALIDATION_ERROR_02299:VALIDATION_ERROR_1a80047a -VALIDATION_ERROR_02300:VALIDATION_ERROR_1a80047c -VALIDATION_ERROR_02301:VALIDATION_ERROR_1a80047e -VALIDATION_ERROR_02302:VALIDATION_ERROR_1a800480 -VALIDATION_ERROR_02303:VALIDATION_ERROR_1a800482 -VALIDATION_ERROR_02304:VALIDATION_ERROR_19c0030e -VALIDATION_ERROR_02306:VALIDATION_ERROR_19c00312 -VALIDATION_ERROR_02307:VALIDATION_ERROR_19c00314 -VALIDATION_ERROR_02308:VALIDATION_ERROR_19c00316 -VALIDATION_ERROR_02309:VALIDATION_ERROR_19c00318 -VALIDATION_ERROR_02313:VALIDATION_ERROR_19c0031e -VALIDATION_ERROR_02314:VALIDATION_ERROR_1a000328 -VALIDATION_ERROR_02315:VALIDATION_ERROR_1a00032a -VALIDATION_ERROR_02316:VALIDATION_ERROR_1a00032c -VALIDATION_ERROR_02317:VALIDATION_ERROR_1a00032e -VALIDATION_ERROR_02319:VALIDATION_ERROR_1a000332 -VALIDATION_ERROR_02320:VALIDATION_ERROR_1a000334 -VALIDATION_ERROR_02321:VALIDATION_ERROR_1a000336 -VALIDATION_ERROR_02322:VALIDATION_ERROR_1a000338 -VALIDATION_ERROR_02323:VALIDATION_ERROR_1a00033a -VALIDATION_ERROR_02324:VALIDATION_ERROR_1a00033c -VALIDATION_ERROR_02325:VALIDATION_ERROR_1a00033e -VALIDATION_ERROR_02326:VALIDATION_ERROR_1a000340 -VALIDATION_ERROR_02327:VALIDATION_ERROR_078009ca -VALIDATION_ERROR_02328:VALIDATION_ERROR_078009cc -VALIDATION_ERROR_02329:VALIDATION_ERROR_078009ce -VALIDATION_ERROR_02330:VALIDATION_ERROR_078009d0 -VALIDATION_ERROR_02331:VALIDATION_ERROR_146009ee -VALIDATION_ERROR_02332:VALIDATION_ERROR_146009f0 -VALIDATION_ERROR_02333:VALIDATION_ERROR_146009f2 -VALIDATION_ERROR_02334:VALIDATION_ERROR_146009f4 -VALIDATION_ERROR_02335:VALIDATION_ERROR_146009f6 -VALIDATION_ERROR_02336:VALIDATION_ERROR_146009f8 -VALIDATION_ERROR_02337:VALIDATION_ERROR_146009fa -VALIDATION_ERROR_02338:VALIDATION_ERROR_146009fc -VALIDATION_ERROR_02339:VALIDATION_ERROR_146009fe -VALIDATION_ERROR_02340:VALIDATION_ERROR_14600a00 -VALIDATION_ERROR_02341:VALIDATION_ERROR_14600a02 -VALIDATION_ERROR_02342:VALIDATION_ERROR_31800a1a -VALIDATION_ERROR_02344:VALIDATION_ERROR_09e00782 -VALIDATION_ERROR_02345:VALIDATION_ERROR_0500022e -VALIDATION_ERROR_02348:VALIDATION_ERROR_15c00278 -VALIDATION_ERROR_02349:VALIDATION_ERROR_31a00082 -VALIDATION_ERROR_02350:VALIDATION_ERROR_1e60090c -VALIDATION_ERROR_02351:VALIDATION_ERROR_12200688 -VALIDATION_ERROR_02352:VALIDATION_ERROR_09e00794 -VALIDATION_ERROR_02353:VALIDATION_ERROR_2c827a01 -VALIDATION_ERROR_02354:VALIDATION_ERROR_2c816e01 -VALIDATION_ERROR_02355:VALIDATION_ERROR_2c81a401 -VALIDATION_ERROR_02356:VALIDATION_ERROR_05a2b00b -VALIDATION_ERROR_02357:VALIDATION_ERROR_05a1c40d -VALIDATION_ERROR_02358:VALIDATION_ERROR_05c2b00b -VALIDATION_ERROR_02359:VALIDATION_ERROR_05c1c40d -VALIDATION_ERROR_02360:VALIDATION_ERROR_21805601 -VALIDATION_ERROR_02361:VALIDATION_ERROR_21811e01 -VALIDATION_ERROR_02362:VALIDATION_ERROR_2180ec01 -VALIDATION_ERROR_02363:VALIDATION_ERROR_2181d001 -VALIDATION_ERROR_02364:VALIDATION_ERROR_0cc0d61b -VALIDATION_ERROR_02365:VALIDATION_ERROR_0cc00a96 -VALIDATION_ERROR_02366:VALIDATION_ERROR_0cc00a98 -VALIDATION_ERROR_02367:VALIDATION_ERROR_0cc00a9a -VALIDATION_ERROR_02368:VALIDATION_ERROR_0cc00a9c -VALIDATION_ERROR_02369:VALIDATION_ERROR_0cc00a9e -VALIDATION_ERROR_02370:VALIDATION_ERROR_0cc00aa0 -VALIDATION_ERROR_02371:VALIDATION_ERROR_0cc2b00b -VALIDATION_ERROR_02372:VALIDATION_ERROR_0cc1c40d -VALIDATION_ERROR_02373:VALIDATION_ERROR_0cc1c801 -VALIDATION_ERROR_02374:VALIDATION_ERROR_0cc1c601 -VALIDATION_ERROR_02375:VALIDATION_ERROR_0cc1ca01 -VALIDATION_ERROR_02376:VALIDATION_ERROR_0cc1ca03 -VALIDATION_ERROR_02377:VALIDATION_ERROR_25a00aa2 -VALIDATION_ERROR_02378:VALIDATION_ERROR_25a00aa4 -VALIDATION_ERROR_02379:VALIDATION_ERROR_25a00aa6 -VALIDATION_ERROR_02380:VALIDATION_ERROR_25a05601 -VALIDATION_ERROR_02381:VALIDATION_ERROR_25a0d801 -VALIDATION_ERROR_02382:VALIDATION_ERROR_25a0ec01 -VALIDATION_ERROR_02383:VALIDATION_ERROR_25a0d807 -VALIDATION_ERROR_02384:VALIDATION_ERROR_32200aa8 -VALIDATION_ERROR_02385:VALIDATION_ERROR_32200aaa -VALIDATION_ERROR_02386:VALIDATION_ERROR_32200aac -VALIDATION_ERROR_02387:VALIDATION_ERROR_32205601 -VALIDATION_ERROR_02388:VALIDATION_ERROR_3220d801 -VALIDATION_ERROR_02389:VALIDATION_ERROR_32229201 -VALIDATION_ERROR_02390:VALIDATION_ERROR_3221cc01 -VALIDATION_ERROR_02391:VALIDATION_ERROR_3220d61b -VALIDATION_ERROR_02392:VALIDATION_ERROR_3220d807 -VALIDATION_ERROR_02393:VALIDATION_ERROR_0d000aae -VALIDATION_ERROR_02394:VALIDATION_ERROR_0d030401 -VALIDATION_ERROR_02395:VALIDATION_ERROR_0d009001 -VALIDATION_ERROR_02396:VALIDATION_ERROR_0d009003 -VALIDATION_ERROR_02397:VALIDATION_ERROR_0d400ab0 -VALIDATION_ERROR_02398:VALIDATION_ERROR_0d430401 -VALIDATION_ERROR_02399:VALIDATION_ERROR_0d409001 -VALIDATION_ERROR_02400:VALIDATION_ERROR_0d409003 -VALIDATION_ERROR_02401:VALIDATION_ERROR_0d427c01 -VALIDATION_ERROR_02402:VALIDATION_ERROR_0ce00ab2 -VALIDATION_ERROR_02403:VALIDATION_ERROR_0ce30401 -VALIDATION_ERROR_02404:VALIDATION_ERROR_0ce09001 -VALIDATION_ERROR_02405:VALIDATION_ERROR_0ce09003 -VALIDATION_ERROR_02406:VALIDATION_ERROR_0ce28201 -VALIDATION_ERROR_02407:VALIDATION_ERROR_0ce04801 -VALIDATION_ERROR_02408:VALIDATION_ERROR_0ce00009 -VALIDATION_ERROR_02409:VALIDATION_ERROR_0d800ab4 -VALIDATION_ERROR_02410:VALIDATION_ERROR_0d830401 -VALIDATION_ERROR_02411:VALIDATION_ERROR_0d809001 -VALIDATION_ERROR_02412:VALIDATION_ERROR_0d809003 -VALIDATION_ERROR_02413:VALIDATION_ERROR_0d801a01 -VALIDATION_ERROR_02414:VALIDATION_ERROR_0d200ab6 -VALIDATION_ERROR_02415:VALIDATION_ERROR_0d230401 -VALIDATION_ERROR_02416:VALIDATION_ERROR_0d209001 -VALIDATION_ERROR_02417:VALIDATION_ERROR_0d209003 -VALIDATION_ERROR_02418:VALIDATION_ERROR_0d201a01 -VALIDATION_ERROR_02419:VALIDATION_ERROR_0d600ab8 -VALIDATION_ERROR_02420:VALIDATION_ERROR_0d630401 -VALIDATION_ERROR_02421:VALIDATION_ERROR_0d609001 -VALIDATION_ERROR_02422:VALIDATION_ERROR_0d609003 -VALIDATION_ERROR_02423:VALIDATION_ERROR_0d628201 -VALIDATION_ERROR_02424:VALIDATION_ERROR_0d62dc01 -VALIDATION_ERROR_02425:VALIDATION_ERROR_0d62dc03 -VALIDATION_ERROR_02426:VALIDATION_ERROR_33800aba -VALIDATION_ERROR_02427:VALIDATION_ERROR_33800abc -VALIDATION_ERROR_02428:VALIDATION_ERROR_33800abe -VALIDATION_ERROR_02429:VALIDATION_ERROR_33805601 -VALIDATION_ERROR_02430:VALIDATION_ERROR_3380d801 -VALIDATION_ERROR_02431:VALIDATION_ERROR_3381c801 -VALIDATION_ERROR_02432:VALIDATION_ERROR_3381cc01 -VALIDATION_ERROR_02433:VALIDATION_ERROR_3380d61b -VALIDATION_ERROR_02434:VALIDATION_ERROR_3380d807 -VALIDATION_ERROR_02435:VALIDATION_ERROR_0ba00a7c -VALIDATION_ERROR_02436:VALIDATION_ERROR_0ba00a7e -VALIDATION_ERROR_02439:VALIDATION_ERROR_0bc00a82 -VALIDATION_ERROR_02440:VALIDATION_ERROR_0bc00a84 -VALIDATION_ERROR_02441:VALIDATION_ERROR_0bc2fe01 -VALIDATION_ERROR_02442:VALIDATION_ERROR_0bc01a01 -VALIDATION_ERROR_02443:VALIDATION_ERROR_21005601 -VALIDATION_ERROR_02444:VALIDATION_ERROR_21011e01 -VALIDATION_ERROR_02445:VALIDATION_ERROR_2100ec01 -VALIDATION_ERROR_02446:VALIDATION_ERROR_21019201 -VALIDATION_ERROR_02447:VALIDATION_ERROR_0b800a86 -VALIDATION_ERROR_02448:VALIDATION_ERROR_0b800a88 -VALIDATION_ERROR_02449:VALIDATION_ERROR_0b800a8a -VALIDATION_ERROR_02450:VALIDATION_ERROR_0b800a8c -VALIDATION_ERROR_02451:VALIDATION_ERROR_0b800a8e -VALIDATION_ERROR_02452:VALIDATION_ERROR_0b82b00b -VALIDATION_ERROR_02453:VALIDATION_ERROR_0b81c40d -VALIDATION_ERROR_02454:VALIDATION_ERROR_0b827e01 -VALIDATION_ERROR_02455:VALIDATION_ERROR_0b809001 -VALIDATION_ERROR_02456:VALIDATION_ERROR_0b809003 -VALIDATION_ERROR_02457:VALIDATION_ERROR_0b826001 -VALIDATION_ERROR_02458:VALIDATION_ERROR_0b82fc1b -VALIDATION_ERROR_02459:VALIDATION_ERROR_25600a90 -VALIDATION_ERROR_02460:VALIDATION_ERROR_25600a92 -VALIDATION_ERROR_02461:VALIDATION_ERROR_25600a94 -VALIDATION_ERROR_02462:VALIDATION_ERROR_25605601 -VALIDATION_ERROR_02463:VALIDATION_ERROR_2560b401 -VALIDATION_ERROR_02464:VALIDATION_ERROR_2560ec01 -VALIDATION_ERROR_02465:VALIDATION_ERROR_2560b407 -VALIDATION_ERROR_02466:VALIDATION_ERROR_1c200a62 -VALIDATION_ERROR_02467:VALIDATION_ERROR_1c200a64 -VALIDATION_ERROR_02468:VALIDATION_ERROR_1c202401 -VALIDATION_ERROR_02469:VALIDATION_ERROR_1c221a01 -VALIDATION_ERROR_02470:VALIDATION_ERROR_1c202413 -VALIDATION_ERROR_02471:VALIDATION_ERROR_1c202415 -VALIDATION_ERROR_02472:VALIDATION_ERROR_1c200017 -VALIDATION_ERROR_02473:VALIDATION_ERROR_1c200019 -VALIDATION_ERROR_02474:VALIDATION_ERROR_0242b00b -VALIDATION_ERROR_02475:VALIDATION_ERROR_0241c40d -VALIDATION_ERROR_02476:VALIDATION_ERROR_0240d801 -VALIDATION_ERROR_02477:VALIDATION_ERROR_0240b401 -VALIDATION_ERROR_02478:VALIDATION_ERROR_02400009 -VALIDATION_ERROR_02479:VALIDATION_ERROR_1ba02401 -VALIDATION_ERROR_02480:VALIDATION_ERROR_1ba1f201 -VALIDATION_ERROR_02481:VALIDATION_ERROR_1ba02413 -VALIDATION_ERROR_02482:VALIDATION_ERROR_1ba02415 -VALIDATION_ERROR_02483:VALIDATION_ERROR_1ba00017 -VALIDATION_ERROR_02484:VALIDATION_ERROR_02200a66 -VALIDATION_ERROR_02485:VALIDATION_ERROR_02200a68 -VALIDATION_ERROR_02486:VALIDATION_ERROR_02200a6a -VALIDATION_ERROR_02487:VALIDATION_ERROR_02200a6c -VALIDATION_ERROR_02488:VALIDATION_ERROR_02200a6e -VALIDATION_ERROR_02489:VALIDATION_ERROR_02200a70 -VALIDATION_ERROR_02490:VALIDATION_ERROR_02200a72 -VALIDATION_ERROR_02491:VALIDATION_ERROR_02200a74 -VALIDATION_ERROR_02492:VALIDATION_ERROR_02200a76 -VALIDATION_ERROR_02493:VALIDATION_ERROR_02200a78 -VALIDATION_ERROR_02494:VALIDATION_ERROR_02200a7a -VALIDATION_ERROR_02495:VALIDATION_ERROR_0222b00b -VALIDATION_ERROR_02496:VALIDATION_ERROR_0221c40d -VALIDATION_ERROR_02497:VALIDATION_ERROR_0220d801 -VALIDATION_ERROR_02498:VALIDATION_ERROR_0220b401 -VALIDATION_ERROR_02499:VALIDATION_ERROR_02219401 -VALIDATION_ERROR_02500:VALIDATION_ERROR_0222f601 -VALIDATION_ERROR_02501:VALIDATION_ERROR_0222ba01 -VALIDATION_ERROR_02502:VALIDATION_ERROR_0222bc01 -VALIDATION_ERROR_02503:VALIDATION_ERROR_02200009 -VALIDATION_ERROR_02504:VALIDATION_ERROR_15a00a36 -VALIDATION_ERROR_02505:VALIDATION_ERROR_15a00a38 -VALIDATION_ERROR_02506:VALIDATION_ERROR_15e00a3e -VALIDATION_ERROR_02507:VALIDATION_ERROR_16000a44 -VALIDATION_ERROR_02508:VALIDATION_ERROR_2761f401 -VALIDATION_ERROR_02509:VALIDATION_ERROR_31a00084 -VALIDATION_ERROR_02510:VALIDATION_ERROR_1e600918 -VALIDATION_ERROR_02511:VALIDATION_ERROR_1e60091a -VALIDATION_ERROR_02512:VALIDATION_ERROR_1e60091c -VALIDATION_ERROR_02513:VALIDATION_ERROR_1b80093e -VALIDATION_ERROR_02514:VALIDATION_ERROR_1b800940 -VALIDATION_ERROR_02515:VALIDATION_ERROR_1b800942 -VALIDATION_ERROR_02516:VALIDATION_ERROR_1220068a -VALIDATION_ERROR_02517:VALIDATION_ERROR_1220068c -VALIDATION_ERROR_02518:VALIDATION_ERROR_13e006c8 -VALIDATION_ERROR_02519:VALIDATION_ERROR_13e006ca -VALIDATION_ERROR_02520:VALIDATION_ERROR_17a0070a -VALIDATION_ERROR_02521:VALIDATION_ERROR_11a0024e -VALIDATION_ERROR_02522:VALIDATION_ERROR_01a0074e -VALIDATION_ERROR_02523:VALIDATION_ERROR_09e00758 -VALIDATION_ERROR_02524:VALIDATION_ERROR_0ac007f8 -VALIDATION_ERROR_02525:VALIDATION_ERROR_15c00294 -VALIDATION_ERROR_02526:VALIDATION_ERROR_19400674 -VALIDATION_ERROR_02527:VALIDATION_ERROR_18800006 -VALIDATION_ERROR_02528:VALIDATION_ERROR_18a00014 -VALIDATION_ERROR_02529:VALIDATION_ERROR_1b40003e -VALIDATION_ERROR_02530:VALIDATION_ERROR_1e400046 -VALIDATION_ERROR_02531:VALIDATION_ERROR_18c000ee -VALIDATION_ERROR_02532:VALIDATION_ERROR_18c000f2 -VALIDATION_ERROR_02533:VALIDATION_ERROR_190000fe -VALIDATION_ERROR_02534:VALIDATION_ERROR_19000108 -VALIDATION_ERROR_02535:VALIDATION_ERROR_18e00160 -VALIDATION_ERROR_02536:VALIDATION_ERROR_18e00164 -VALIDATION_ERROR_02537:VALIDATION_ERROR_19200176 -VALIDATION_ERROR_02538:VALIDATION_ERROR_19200180 -VALIDATION_ERROR_02539:VALIDATION_ERROR_184001b8 -VALIDATION_ERROR_02540:VALIDATION_ERROR_184001c2 -VALIDATION_ERROR_02541:VALIDATION_ERROR_1c800200 -VALIDATION_ERROR_02542:VALIDATION_ERROR_1c800204 -VALIDATION_ERROR_02543:VALIDATION_ERROR_17e00364 -VALIDATION_ERROR_02544:VALIDATION_ERROR_1aa003b4 -VALIDATION_ERROR_02545:VALIDATION_ERROR_1a60041c -VALIDATION_ERROR_02546:VALIDATION_ERROR_182004e8 -VALIDATION_ERROR_02547:VALIDATION_ERROR_1a000322 -VALIDATION_ERROR_02548:VALIDATION_ERROR_0220b61b -VALIDATION_ERROR_02549:VALIDATION_ERROR_31a0008a -VALIDATION_ERROR_02550:VALIDATION_ERROR_13c0009c -VALIDATION_ERROR_02551:VALIDATION_ERROR_1d4008fa -VALIDATION_ERROR_02552:VALIDATION_ERROR_1c400902 -VALIDATION_ERROR_02553:VALIDATION_ERROR_13e006b4 -VALIDATION_ERROR_02554:VALIDATION_ERROR_13e006b6 -VALIDATION_ERROR_02555:VALIDATION_ERROR_316008b6 -VALIDATION_ERROR_02556:VALIDATION_ERROR_316008b8 -VALIDATION_ERROR_02557:VALIDATION_ERROR_316008ba -VALIDATION_ERROR_02559:VALIDATION_ERROR_1482b00b -VALIDATION_ERROR_02560:VALIDATION_ERROR_1481c40d -VALIDATION_ERROR_02561:VALIDATION_ERROR_14814401 -VALIDATION_ERROR_02562:VALIDATION_ERROR_14805a1b -VALIDATION_ERROR_02563:VALIDATION_ERROR_2d827a01 -VALIDATION_ERROR_02564:VALIDATION_ERROR_2d81f401 -VALIDATION_ERROR_02565:VALIDATION_ERROR_2dc27a01 -VALIDATION_ERROR_02566:VALIDATION_ERROR_2dc20201 -VALIDATION_ERROR_02567:VALIDATION_ERROR_2dc20001 -VALIDATION_ERROR_02568:VALIDATION_ERROR_056002ea -VALIDATION_ERROR_02569:VALIDATION_ERROR_056002ec -VALIDATION_ERROR_02571:VALIDATION_ERROR_33405601 -VALIDATION_ERROR_02572:VALIDATION_ERROR_33402801 -VALIDATION_ERROR_02573:VALIDATION_ERROR_33409005 -VALIDATION_ERROR_02574:VALIDATION_ERROR_33402807 -VALIDATION_ERROR_02575:VALIDATION_ERROR_31e05601 -VALIDATION_ERROR_02576:VALIDATION_ERROR_31e13a01 -VALIDATION_ERROR_02577:VALIDATION_ERROR_31e0ec01 -VALIDATION_ERROR_02578:VALIDATION_ERROR_31e17001 -VALIDATION_ERROR_02579:VALIDATION_ERROR_0582b00b -VALIDATION_ERROR_02580:VALIDATION_ERROR_0581c40d -VALIDATION_ERROR_02581:VALIDATION_ERROR_05805801 -VALIDATION_ERROR_02582:VALIDATION_ERROR_32005601 -VALIDATION_ERROR_02583:VALIDATION_ERROR_32006001 -VALIDATION_ERROR_02584:VALIDATION_ERROR_32014c01 -VALIDATION_ERROR_02585:VALIDATION_ERROR_3200ec01 -VALIDATION_ERROR_02586:VALIDATION_ERROR_32017001 -VALIDATION_ERROR_02587:VALIDATION_ERROR_0702b00b -VALIDATION_ERROR_02588:VALIDATION_ERROR_0701c40d -VALIDATION_ERROR_02589:VALIDATION_ERROR_07006201 -VALIDATION_ERROR_02590:VALIDATION_ERROR_094006f6 -VALIDATION_ERROR_02591:VALIDATION_ERROR_1f200570 -VALIDATION_ERROR_02592:VALIDATION_ERROR_208005a2 -VALIDATION_ERROR_02593:VALIDATION_ERROR_2d027a01 -VALIDATION_ERROR_02594:VALIDATION_ERROR_2d01b001 -VALIDATION_ERROR_02595:VALIDATION_ERROR_09e0076c -VALIDATION_ERROR_02596:VALIDATION_ERROR_0ac007da -VALIDATION_ERROR_02597:VALIDATION_ERROR_0ac007de -VALIDATION_ERROR_02599:VALIDATION_ERROR_18800002 -VALIDATION_ERROR_02600:VALIDATION_ERROR_18a00010 -VALIDATION_ERROR_02601:VALIDATION_ERROR_190000fa -VALIDATION_ERROR_02602:VALIDATION_ERROR_19000104 -VALIDATION_ERROR_02603:VALIDATION_ERROR_09c0012a -VALIDATION_ERROR_02604:VALIDATION_ERROR_09c00136 -VALIDATION_ERROR_02605:VALIDATION_ERROR_18e0015e -VALIDATION_ERROR_02606:VALIDATION_ERROR_19200172 -VALIDATION_ERROR_02607:VALIDATION_ERROR_1e000990 -VALIDATION_ERROR_02608:VALIDATION_ERROR_1e000992 -VALIDATION_ERROR_02609:VALIDATION_ERROR_1d8004a2 -VALIDATION_ERROR_02610:VALIDATION_ERROR_1d8004a4 -VALIDATION_ERROR_02611:VALIDATION_ERROR_19c0031a -VALIDATION_ERROR_02612:VALIDATION_ERROR_19c0031c -VALIDATION_ERROR_02613:VALIDATION_ERROR_19c00320 -VALIDATION_ERROR_02614:VALIDATION_ERROR_0d20b201 -VALIDATION_ERROR_02615:VALIDATION_ERROR_0ec0088e -VALIDATION_ERROR_02616:VALIDATION_ERROR_2e027a01 -VALIDATION_ERROR_02617:VALIDATION_ERROR_2e017401 -VALIDATION_ERROR_02618:VALIDATION_ERROR_2e01f601 -VALIDATION_ERROR_02619:VALIDATION_ERROR_2e01f401 -VALIDATION_ERROR_02620:VALIDATION_ERROR_0ec2b00b -VALIDATION_ERROR_02621:VALIDATION_ERROR_0ec1c40d -VALIDATION_ERROR_02622:VALIDATION_ERROR_0ec09201 -VALIDATION_ERROR_02623:VALIDATION_ERROR_0ec30401 -VALIDATION_ERROR_02624:VALIDATION_ERROR_0ec2b401 -VALIDATION_ERROR_02625:VALIDATION_ERROR_0ec30601 -VALIDATION_ERROR_02626:VALIDATION_ERROR_0ec30603 -VALIDATION_ERROR_02627:VALIDATION_ERROR_0ec2fa01 -VALIDATION_ERROR_02628:VALIDATION_ERROR_22c0bc01 -VALIDATION_ERROR_02629:VALIDATION_ERROR_22c11e01 -VALIDATION_ERROR_02630:VALIDATION_ERROR_22c0ec01 -VALIDATION_ERROR_02631:VALIDATION_ERROR_22c24801 -VALIDATION_ERROR_02632:VALIDATION_ERROR_14e00a4c -VALIDATION_ERROR_02633:VALIDATION_ERROR_14e2b00b -VALIDATION_ERROR_02634:VALIDATION_ERROR_14e1c40d -VALIDATION_ERROR_02635:VALIDATION_ERROR_14e09005 -VALIDATION_ERROR_02636:VALIDATION_ERROR_14e30e01 -VALIDATION_ERROR_02637:VALIDATION_ERROR_16627a01 -VALIDATION_ERROR_02638:VALIDATION_ERROR_16606601 -VALIDATION_ERROR_02639:VALIDATION_ERROR_16606001 -VALIDATION_ERROR_02640:VALIDATION_ERROR_2fc27a01 -VALIDATION_ERROR_02641:VALIDATION_ERROR_2fc06601 -VALIDATION_ERROR_02642:VALIDATION_ERROR_2fc14801 -VALIDATION_ERROR_02643:VALIDATION_ERROR_32427a01 -VALIDATION_ERROR_02644:VALIDATION_ERROR_32406001 -VALIDATION_ERROR_02645:VALIDATION_ERROR_27205601 -VALIDATION_ERROR_02646:VALIDATION_ERROR_27206001 -VALIDATION_ERROR_02647:VALIDATION_ERROR_27214e01 -VALIDATION_ERROR_02648:VALIDATION_ERROR_0742b00b -VALIDATION_ERROR_02649:VALIDATION_ERROR_0741c40d -VALIDATION_ERROR_02650:VALIDATION_ERROR_07428a01 -VALIDATION_ERROR_02651:VALIDATION_ERROR_2e227a01 -VALIDATION_ERROR_02652:VALIDATION_ERROR_2e22ec01 -VALIDATION_ERROR_02653:VALIDATION_ERROR_2e224a01 -VALIDATION_ERROR_02654:VALIDATION_ERROR_142009bc -VALIDATION_ERROR_02655:VALIDATION_ERROR_144009b8 -VALIDATION_ERROR_02656:VALIDATION_ERROR_1442b00b -VALIDATION_ERROR_02657:VALIDATION_ERROR_1441c40d -VALIDATION_ERROR_02658:VALIDATION_ERROR_1442ee01 -VALIDATION_ERROR_02659:VALIDATION_ERROR_306009ba -VALIDATION_ERROR_02660:VALIDATION_ERROR_30605601 -VALIDATION_ERROR_02661:VALIDATION_ERROR_3062f001 -VALIDATION_ERROR_02662:VALIDATION_ERROR_30603601 -VALIDATION_ERROR_02663:VALIDATION_ERROR_30611c01 -VALIDATION_ERROR_02664:VALIDATION_ERROR_16400a0a -VALIDATION_ERROR_02666:VALIDATION_ERROR_2c227a01 -VALIDATION_ERROR_02667:VALIDATION_ERROR_2c216e01 -VALIDATION_ERROR_02670:VALIDATION_ERROR_2c627a01 -VALIDATION_ERROR_02671:VALIDATION_ERROR_2c609201 -VALIDATION_ERROR_02672:VALIDATION_ERROR_2c617601 -VALIDATION_ERROR_02673:VALIDATION_ERROR_2cc27a01 -VALIDATION_ERROR_02674:VALIDATION_ERROR_2cc18201 -VALIDATION_ERROR_02675:VALIDATION_ERROR_2cc18401 -VALIDATION_ERROR_02676:VALIDATION_ERROR_0e62b00b -VALIDATION_ERROR_02678:VALIDATION_ERROR_0e609201 -VALIDATION_ERROR_02679:VALIDATION_ERROR_0e630401 -VALIDATION_ERROR_02680:VALIDATION_ERROR_0e62fa01 -VALIDATION_ERROR_02681:VALIDATION_ERROR_0e630601 -VALIDATION_ERROR_02682:VALIDATION_ERROR_0e630603 -VALIDATION_ERROR_02683:VALIDATION_ERROR_0e609001 -VALIDATION_ERROR_02684:VALIDATION_ERROR_27e0bc01 -VALIDATION_ERROR_02685:VALIDATION_ERROR_27e1d801 -VALIDATION_ERROR_02686:VALIDATION_ERROR_27e1da01 -VALIDATION_ERROR_02687:VALIDATION_ERROR_0561c40d -VALIDATION_ERROR_02688:VALIDATION_ERROR_062002ee -VALIDATION_ERROR_02689:VALIDATION_ERROR_062002f0 -VALIDATION_ERROR_02690:VALIDATION_ERROR_062002f2 -VALIDATION_ERROR_02691:VALIDATION_ERROR_0622b00b -VALIDATION_ERROR_02692:VALIDATION_ERROR_0621dc01 -VALIDATION_ERROR_02693:VALIDATION_ERROR_2740007c -VALIDATION_ERROR_02694:VALIDATION_ERROR_31a0008c -VALIDATION_ERROR_02695:VALIDATION_ERROR_13c1c40d -VALIDATION_ERROR_02696:VALIDATION_ERROR_0340009e -VALIDATION_ERROR_02697:VALIDATION_ERROR_034000a0 -VALIDATION_ERROR_02698:VALIDATION_ERROR_0342b00b -VALIDATION_ERROR_02699:VALIDATION_ERROR_03427401 -VALIDATION_ERROR_02700:VALIDATION_ERROR_03423201 -VALIDATION_ERROR_02701:VALIDATION_ERROR_156000a2 -VALIDATION_ERROR_02702:VALIDATION_ERROR_1562b00b -VALIDATION_ERROR_02706:VALIDATION_ERROR_15821401 -VALIDATION_ERROR_02707:VALIDATION_ERROR_1580e401 -VALIDATION_ERROR_02708:VALIDATION_ERROR_1580e201 -VALIDATION_ERROR_02709:VALIDATION_ERROR_068000a4 -VALIDATION_ERROR_02710:VALIDATION_ERROR_068000a6 -VALIDATION_ERROR_02711:VALIDATION_ERROR_068000a8 -VALIDATION_ERROR_02712:VALIDATION_ERROR_068000aa -VALIDATION_ERROR_02713:VALIDATION_ERROR_068000ac -VALIDATION_ERROR_02714:VALIDATION_ERROR_0682b00b -VALIDATION_ERROR_02715:VALIDATION_ERROR_06827201 -VALIDATION_ERROR_02716:VALIDATION_ERROR_06811201 -VALIDATION_ERROR_02717:VALIDATION_ERROR_06823001 -VALIDATION_ERROR_02718:VALIDATION_ERROR_1b2000b6 -VALIDATION_ERROR_02719:VALIDATION_ERROR_1b2000b8 -VALIDATION_ERROR_02720:VALIDATION_ERROR_1b2000ba -VALIDATION_ERROR_02721:VALIDATION_ERROR_060000d4 -VALIDATION_ERROR_02722:VALIDATION_ERROR_060000d6 -VALIDATION_ERROR_02723:VALIDATION_ERROR_0602b00b -VALIDATION_ERROR_02724:VALIDATION_ERROR_1d0000d8 -VALIDATION_ERROR_02725:VALIDATION_ERROR_1d0000da -VALIDATION_ERROR_02726:VALIDATION_ERROR_1d0000dc -VALIDATION_ERROR_02727:VALIDATION_ERROR_1d0000de -VALIDATION_ERROR_02728:VALIDATION_ERROR_1d002401 -VALIDATION_ERROR_02729:VALIDATION_ERROR_1d002413 -VALIDATION_ERROR_02730:VALIDATION_ERROR_1d002415 -VALIDATION_ERROR_02731:VALIDATION_ERROR_088008c8 -VALIDATION_ERROR_02732:VALIDATION_ERROR_0882b00b -VALIDATION_ERROR_02733:VALIDATION_ERROR_0881c40d -VALIDATION_ERROR_02734:VALIDATION_ERROR_08809e01 -VALIDATION_ERROR_02735:VALIDATION_ERROR_08a008ca -VALIDATION_ERROR_02736:VALIDATION_ERROR_08a2b00b -VALIDATION_ERROR_02737:VALIDATION_ERROR_08a1c40d -VALIDATION_ERROR_02738:VALIDATION_ERROR_08a0f401 -VALIDATION_ERROR_02739:VALIDATION_ERROR_304008cc -VALIDATION_ERROR_02740:VALIDATION_ERROR_304008ce -VALIDATION_ERROR_02741:VALIDATION_ERROR_304008d0 -VALIDATION_ERROR_02742:VALIDATION_ERROR_304008d2 -VALIDATION_ERROR_02743:VALIDATION_ERROR_304008d4 -VALIDATION_ERROR_02744:VALIDATION_ERROR_304008d6 -VALIDATION_ERROR_02745:VALIDATION_ERROR_30405601 -VALIDATION_ERROR_02746:VALIDATION_ERROR_3042b801 -VALIDATION_ERROR_02747:VALIDATION_ERROR_30409c01 -VALIDATION_ERROR_02748:VALIDATION_ERROR_30417c01 -VALIDATION_ERROR_02749:VALIDATION_ERROR_3042b807 -VALIDATION_ERROR_02750:VALIDATION_ERROR_302008d8 -VALIDATION_ERROR_02751:VALIDATION_ERROR_302008da -VALIDATION_ERROR_02752:VALIDATION_ERROR_302008dc -VALIDATION_ERROR_02753:VALIDATION_ERROR_302008de -VALIDATION_ERROR_02754:VALIDATION_ERROR_302008e0 -VALIDATION_ERROR_02755:VALIDATION_ERROR_30205601 -VALIDATION_ERROR_02756:VALIDATION_ERROR_3022b801 -VALIDATION_ERROR_02757:VALIDATION_ERROR_30209c01 -VALIDATION_ERROR_02758:VALIDATION_ERROR_30216c01 -VALIDATION_ERROR_02759:VALIDATION_ERROR_3022b807 -VALIDATION_ERROR_02760:VALIDATION_ERROR_30e05601 -VALIDATION_ERROR_02761:VALIDATION_ERROR_30e19001 -VALIDATION_ERROR_02762:VALIDATION_ERROR_0b6008e8 -VALIDATION_ERROR_02763:VALIDATION_ERROR_0b6008ea -VALIDATION_ERROR_02764:VALIDATION_ERROR_0b62b00b -VALIDATION_ERROR_02765:VALIDATION_ERROR_0b61c40d -VALIDATION_ERROR_02766:VALIDATION_ERROR_0b62b801 -VALIDATION_ERROR_02767:VALIDATION_ERROR_0b609c01 -VALIDATION_ERROR_02768:VALIDATION_ERROR_0b609c03 -VALIDATION_ERROR_02769:VALIDATION_ERROR_30c008ec -VALIDATION_ERROR_02770:VALIDATION_ERROR_30c05601 -VALIDATION_ERROR_02771:VALIDATION_ERROR_30c18e01 -VALIDATION_ERROR_02772:VALIDATION_ERROR_0b4008ee -VALIDATION_ERROR_02773:VALIDATION_ERROR_0b4008f0 -VALIDATION_ERROR_02774:VALIDATION_ERROR_0b42b00b -VALIDATION_ERROR_02775:VALIDATION_ERROR_0b41c40d -VALIDATION_ERROR_02776:VALIDATION_ERROR_0b42b801 -VALIDATION_ERROR_02777:VALIDATION_ERROR_0b409c01 -VALIDATION_ERROR_02778:VALIDATION_ERROR_1d400900 -VALIDATION_ERROR_02779:VALIDATION_ERROR_1c40090a -VALIDATION_ERROR_02780:VALIDATION_ERROR_1e60091e -VALIDATION_ERROR_02781:VALIDATION_ERROR_1b800944 -VALIDATION_ERROR_02787:VALIDATION_ERROR_0a000962 -VALIDATION_ERROR_02788:VALIDATION_ERROR_0a000964 -VALIDATION_ERROR_02789:VALIDATION_ERROR_0a000966 -VALIDATION_ERROR_02791:VALIDATION_ERROR_0a00096c -VALIDATION_ERROR_02792:VALIDATION_ERROR_1240068e -VALIDATION_ERROR_02793:VALIDATION_ERROR_12400690 -VALIDATION_ERROR_02794:VALIDATION_ERROR_12400692 -VALIDATION_ERROR_02795:VALIDATION_ERROR_12400694 -VALIDATION_ERROR_02796:VALIDATION_ERROR_1242b00b -VALIDATION_ERROR_02797:VALIDATION_ERROR_1241c40d -VALIDATION_ERROR_02798:VALIDATION_ERROR_12426c01 -VALIDATION_ERROR_02799:VALIDATION_ERROR_12426e01 -VALIDATION_ERROR_02800:VALIDATION_ERROR_12411a01 -VALIDATION_ERROR_02801:VALIDATION_ERROR_140006b0 -VALIDATION_ERROR_02802:VALIDATION_ERROR_14009001 -VALIDATION_ERROR_02803:VALIDATION_ERROR_13e006cc -VALIDATION_ERROR_02804:VALIDATION_ERROR_13e006ce -VALIDATION_ERROR_02805:VALIDATION_ERROR_13e006d0 -VALIDATION_ERROR_02806:VALIDATION_ERROR_094006ea -VALIDATION_ERROR_02807:VALIDATION_ERROR_094006ee -VALIDATION_ERROR_02808:VALIDATION_ERROR_094006f2 -VALIDATION_ERROR_02809:VALIDATION_ERROR_1201c40d -VALIDATION_ERROR_02810:VALIDATION_ERROR_06600712 -VALIDATION_ERROR_02811:VALIDATION_ERROR_06600714 -VALIDATION_ERROR_02812:VALIDATION_ERROR_06600716 -VALIDATION_ERROR_02813:VALIDATION_ERROR_06600718 -VALIDATION_ERROR_02814:VALIDATION_ERROR_0662b00b -VALIDATION_ERROR_02815:VALIDATION_ERROR_06614201 -VALIDATION_ERROR_02816:VALIDATION_ERROR_12a00ac0 -VALIDATION_ERROR_02819:VALIDATION_ERROR_12a10c01 -VALIDATION_ERROR_02820:VALIDATION_ERROR_096005f0 -VALIDATION_ERROR_02821:VALIDATION_ERROR_096005f2 -VALIDATION_ERROR_02822:VALIDATION_ERROR_096005f4 -VALIDATION_ERROR_02823:VALIDATION_ERROR_096005f6 -VALIDATION_ERROR_02824:VALIDATION_ERROR_096005f8 -VALIDATION_ERROR_02825:VALIDATION_ERROR_0c6004fe -VALIDATION_ERROR_02826:VALIDATION_ERROR_0c600500 -VALIDATION_ERROR_02827:VALIDATION_ERROR_0c600502 -VALIDATION_ERROR_02828:VALIDATION_ERROR_0c600504 -VALIDATION_ERROR_02829:VALIDATION_ERROR_0c600506 -VALIDATION_ERROR_02830:VALIDATION_ERROR_0c600508 -VALIDATION_ERROR_02831:VALIDATION_ERROR_0c60050a -VALIDATION_ERROR_02832:VALIDATION_ERROR_0c60050c -VALIDATION_ERROR_02833:VALIDATION_ERROR_0c60050e -VALIDATION_ERROR_02834:VALIDATION_ERROR_0c600510 -VALIDATION_ERROR_02835:VALIDATION_ERROR_0c61c40d -VALIDATION_ERROR_02836:VALIDATION_ERROR_0420051c -VALIDATION_ERROR_02837:VALIDATION_ERROR_0420051e -VALIDATION_ERROR_02838:VALIDATION_ERROR_08000520 -VALIDATION_ERROR_02839:VALIDATION_ERROR_0802b00b -VALIDATION_ERROR_02840:VALIDATION_ERROR_0801c40d -VALIDATION_ERROR_02841:VALIDATION_ERROR_08009e01 -VALIDATION_ERROR_02842:VALIDATION_ERROR_08400522 -VALIDATION_ERROR_02843:VALIDATION_ERROR_0842b00b -VALIDATION_ERROR_02844:VALIDATION_ERROR_0841c40d -VALIDATION_ERROR_02845:VALIDATION_ERROR_0b000524 -VALIDATION_ERROR_02846:VALIDATION_ERROR_0b000526 -VALIDATION_ERROR_02847:VALIDATION_ERROR_0b000528 -VALIDATION_ERROR_02848:VALIDATION_ERROR_0b00052a -VALIDATION_ERROR_02849:VALIDATION_ERROR_0b02b00b -VALIDATION_ERROR_02850:VALIDATION_ERROR_0b01c40d -VALIDATION_ERROR_02851:VALIDATION_ERROR_0b009c01 -VALIDATION_ERROR_02852:VALIDATION_ERROR_2ae0052c -VALIDATION_ERROR_02853:VALIDATION_ERROR_2ae0052e -VALIDATION_ERROR_02854:VALIDATION_ERROR_2ae00530 -VALIDATION_ERROR_02855:VALIDATION_ERROR_2ae05601 -VALIDATION_ERROR_02856:VALIDATION_ERROR_2ae0c601 -VALIDATION_ERROR_02857:VALIDATION_ERROR_2ae09c01 -VALIDATION_ERROR_02858:VALIDATION_ERROR_2ae17c01 -VALIDATION_ERROR_02859:VALIDATION_ERROR_2ae0c607 -VALIDATION_ERROR_02860:VALIDATION_ERROR_2b200532 -VALIDATION_ERROR_02861:VALIDATION_ERROR_2b200534 -VALIDATION_ERROR_02862:VALIDATION_ERROR_2b205601 -VALIDATION_ERROR_02863:VALIDATION_ERROR_2b209c01 -VALIDATION_ERROR_02864:VALIDATION_ERROR_2b21b601 -VALIDATION_ERROR_02865:VALIDATION_ERROR_0ae00536 -VALIDATION_ERROR_02866:VALIDATION_ERROR_0ae00538 -VALIDATION_ERROR_02867:VALIDATION_ERROR_0ae0053a -VALIDATION_ERROR_02868:VALIDATION_ERROR_0ae0053c -VALIDATION_ERROR_02869:VALIDATION_ERROR_0ae2b00b -VALIDATION_ERROR_02870:VALIDATION_ERROR_0ae1c40d -VALIDATION_ERROR_02871:VALIDATION_ERROR_0ae09c01 -VALIDATION_ERROR_02872:VALIDATION_ERROR_2aa0053e -VALIDATION_ERROR_02873:VALIDATION_ERROR_2aa00540 -VALIDATION_ERROR_02874:VALIDATION_ERROR_2aa05601 -VALIDATION_ERROR_02875:VALIDATION_ERROR_2aa0c601 -VALIDATION_ERROR_02876:VALIDATION_ERROR_2aa09c01 -VALIDATION_ERROR_02877:VALIDATION_ERROR_2aa16c01 -VALIDATION_ERROR_02878:VALIDATION_ERROR_2aa0c607 -VALIDATION_ERROR_02879:VALIDATION_ERROR_2ac00542 -VALIDATION_ERROR_02880:VALIDATION_ERROR_2ac00544 -VALIDATION_ERROR_02881:VALIDATION_ERROR_2ac05601 -VALIDATION_ERROR_02882:VALIDATION_ERROR_2ac09c01 -VALIDATION_ERROR_02883:VALIDATION_ERROR_2ac1ae01 -VALIDATION_ERROR_02884:VALIDATION_ERROR_0822b00b -VALIDATION_ERROR_02885:VALIDATION_ERROR_0821c40d -VALIDATION_ERROR_02886:VALIDATION_ERROR_08209e01 -VALIDATION_ERROR_02887:VALIDATION_ERROR_0862b00b -VALIDATION_ERROR_02888:VALIDATION_ERROR_0861c40d -VALIDATION_ERROR_02889:VALIDATION_ERROR_0860f401 -VALIDATION_ERROR_02890:VALIDATION_ERROR_0b200a5e -VALIDATION_ERROR_02891:VALIDATION_ERROR_0b200a60 -VALIDATION_ERROR_02892:VALIDATION_ERROR_0b22b00b -VALIDATION_ERROR_02893:VALIDATION_ERROR_0b21c40d -VALIDATION_ERROR_02894:VALIDATION_ERROR_0b209c01 -VALIDATION_ERROR_02895:VALIDATION_ERROR_0c400546 -VALIDATION_ERROR_02896:VALIDATION_ERROR_0c400548 -VALIDATION_ERROR_02897:VALIDATION_ERROR_0c42b00b -VALIDATION_ERROR_02898:VALIDATION_ERROR_0c409001 -VALIDATION_ERROR_02899:VALIDATION_ERROR_31200556 -VALIDATION_ERROR_02900:VALIDATION_ERROR_28c00566 -VALIDATION_ERROR_02901:VALIDATION_ERROR_28c00568 -VALIDATION_ERROR_02902:VALIDATION_ERROR_28c0056a -VALIDATION_ERROR_02903:VALIDATION_ERROR_28c0056c -VALIDATION_ERROR_02904:VALIDATION_ERROR_28c05601 -VALIDATION_ERROR_02905:VALIDATION_ERROR_28c1d401 -VALIDATION_ERROR_02906:VALIDATION_ERROR_28c1d403 -VALIDATION_ERROR_02907:VALIDATION_ERROR_0140072e -VALIDATION_ERROR_02908:VALIDATION_ERROR_01400730 -VALIDATION_ERROR_02909:VALIDATION_ERROR_0141c40d -VALIDATION_ERROR_02910:VALIDATION_ERROR_08c2b00b -VALIDATION_ERROR_02911:VALIDATION_ERROR_08c09e01 -VALIDATION_ERROR_02912:VALIDATION_ERROR_01a00740 -VALIDATION_ERROR_02913:VALIDATION_ERROR_09e00760 -VALIDATION_ERROR_02914:VALIDATION_ERROR_09e00762 -VALIDATION_ERROR_02915:VALIDATION_ERROR_09e00764 -VALIDATION_ERROR_02916:VALIDATION_ERROR_09e0078c -VALIDATION_ERROR_02917:VALIDATION_ERROR_09e007b8 -VALIDATION_ERROR_02918:VALIDATION_ERROR_09e007ba -VALIDATION_ERROR_02919:VALIDATION_ERROR_09e007bc -VALIDATION_ERROR_02920:VALIDATION_ERROR_09e007be -VALIDATION_ERROR_02921:VALIDATION_ERROR_09e007c0 -VALIDATION_ERROR_02922:VALIDATION_ERROR_09e007c2 -VALIDATION_ERROR_02923:VALIDATION_ERROR_09e1c40d -VALIDATION_ERROR_02924:VALIDATION_ERROR_08e2b00b -VALIDATION_ERROR_02925:VALIDATION_ERROR_08e09e01 -VALIDATION_ERROR_02926:VALIDATION_ERROR_08e09e03 -VALIDATION_ERROR_02927:VALIDATION_ERROR_0aa007c6 -VALIDATION_ERROR_02928:VALIDATION_ERROR_0aa2b00b -VALIDATION_ERROR_02929:VALIDATION_ERROR_0aa2f001 -VALIDATION_ERROR_02930:VALIDATION_ERROR_0ac007f2 -VALIDATION_ERROR_02931:VALIDATION_ERROR_0a800802 -VALIDATION_ERROR_02932:VALIDATION_ERROR_17205601 -VALIDATION_ERROR_02933:VALIDATION_ERROR_1720fa01 -VALIDATION_ERROR_02934:VALIDATION_ERROR_1720161b -VALIDATION_ERROR_02935:VALIDATION_ERROR_00c00820 -VALIDATION_ERROR_02936:VALIDATION_ERROR_00c00822 -VALIDATION_ERROR_02937:VALIDATION_ERROR_00c00824 -VALIDATION_ERROR_02938:VALIDATION_ERROR_00c00826 -VALIDATION_ERROR_02939:VALIDATION_ERROR_00c2b00b -VALIDATION_ERROR_02940:VALIDATION_ERROR_00c1c40d -VALIDATION_ERROR_02941:VALIDATION_ERROR_00c01a01 -VALIDATION_ERROR_02942:VALIDATION_ERROR_00c0c601 -VALIDATION_ERROR_02943:VALIDATION_ERROR_00c13e01 -VALIDATION_ERROR_02944:VALIDATION_ERROR_00c00009 -VALIDATION_ERROR_02945:VALIDATION_ERROR_17605601 -VALIDATION_ERROR_02946:VALIDATION_ERROR_1760fa01 -VALIDATION_ERROR_02947:VALIDATION_ERROR_1760161b -VALIDATION_ERROR_02948:VALIDATION_ERROR_00e00838 -VALIDATION_ERROR_02949:VALIDATION_ERROR_00e0083a -VALIDATION_ERROR_02950:VALIDATION_ERROR_00e0083c -VALIDATION_ERROR_02951:VALIDATION_ERROR_00e0083e -VALIDATION_ERROR_02952:VALIDATION_ERROR_00e00840 -VALIDATION_ERROR_02953:VALIDATION_ERROR_00e00842 -VALIDATION_ERROR_02954:VALIDATION_ERROR_00e00844 -VALIDATION_ERROR_02955:VALIDATION_ERROR_00e00846 -VALIDATION_ERROR_02957:VALIDATION_ERROR_00e0084a -VALIDATION_ERROR_02958:VALIDATION_ERROR_00e0084c -VALIDATION_ERROR_02959:VALIDATION_ERROR_00e0084e -VALIDATION_ERROR_02960:VALIDATION_ERROR_00e00850 -VALIDATION_ERROR_02961:VALIDATION_ERROR_00e00852 -VALIDATION_ERROR_02962:VALIDATION_ERROR_00e00854 -VALIDATION_ERROR_02963:VALIDATION_ERROR_00e2b00b -VALIDATION_ERROR_02964:VALIDATION_ERROR_00e1c40d -VALIDATION_ERROR_02965:VALIDATION_ERROR_00e0a001 -VALIDATION_ERROR_02966:VALIDATION_ERROR_00e0c601 -VALIDATION_ERROR_02967:VALIDATION_ERROR_00e13e01 -VALIDATION_ERROR_02968:VALIDATION_ERROR_00e22001 -VALIDATION_ERROR_02969:VALIDATION_ERROR_00e00009 -VALIDATION_ERROR_02970:VALIDATION_ERROR_01000856 -VALIDATION_ERROR_02971:VALIDATION_ERROR_01000858 -VALIDATION_ERROR_02972:VALIDATION_ERROR_0102b00b -VALIDATION_ERROR_02973:VALIDATION_ERROR_0102f001 -VALIDATION_ERROR_02974:VALIDATION_ERROR_05000230 -VALIDATION_ERROR_02975:VALIDATION_ERROR_05000232 -VALIDATION_ERROR_02976:VALIDATION_ERROR_05009001 -VALIDATION_ERROR_02977:VALIDATION_ERROR_0fe0024a -VALIDATION_ERROR_02978:VALIDATION_ERROR_33c00274 -VALIDATION_ERROR_02979:VALIDATION_ERROR_15c0027a -VALIDATION_ERROR_02980:VALIDATION_ERROR_15c0027c -VALIDATION_ERROR_02981:VALIDATION_ERROR_046002ae -VALIDATION_ERROR_02982:VALIDATION_ERROR_1fa05601 -VALIDATION_ERROR_02983:VALIDATION_ERROR_1fa11e01 -VALIDATION_ERROR_02984:VALIDATION_ERROR_1fa0ec01 -VALIDATION_ERROR_02985:VALIDATION_ERROR_1fa13401 -VALIDATION_ERROR_02986:VALIDATION_ERROR_052002bc -VALIDATION_ERROR_02987:VALIDATION_ERROR_052002be -VALIDATION_ERROR_02988:VALIDATION_ERROR_052002c0 -VALIDATION_ERROR_02989:VALIDATION_ERROR_052002c2 -VALIDATION_ERROR_02990:VALIDATION_ERROR_0522b00b -VALIDATION_ERROR_02991:VALIDATION_ERROR_0521c40d -VALIDATION_ERROR_02992:VALIDATION_ERROR_05209005 -VALIDATION_ERROR_02993:VALIDATION_ERROR_05213201 -VALIDATION_ERROR_02994:VALIDATION_ERROR_0522f801 -VALIDATION_ERROR_02995:VALIDATION_ERROR_05204c01 -VALIDATION_ERROR_02996:VALIDATION_ERROR_05227e01 -VALIDATION_ERROR_02997:VALIDATION_ERROR_05228201 -VALIDATION_ERROR_02998:VALIDATION_ERROR_0520501b -VALIDATION_ERROR_02999:VALIDATION_ERROR_05200009 -VALIDATION_ERROR_03000:VALIDATION_ERROR_054002c4 -VALIDATION_ERROR_03001:VALIDATION_ERROR_054002c6 -VALIDATION_ERROR_03002:VALIDATION_ERROR_05404e01 -VALIDATION_ERROR_03003:VALIDATION_ERROR_248002c8 -VALIDATION_ERROR_03004:VALIDATION_ERROR_248002ca -VALIDATION_ERROR_03005:VALIDATION_ERROR_24805601 -VALIDATION_ERROR_03006:VALIDATION_ERROR_24805201 -VALIDATION_ERROR_03007:VALIDATION_ERROR_2480ec01 -VALIDATION_ERROR_03008:VALIDATION_ERROR_24805207 -VALIDATION_ERROR_03009:VALIDATION_ERROR_33a05601 -VALIDATION_ERROR_03010:VALIDATION_ERROR_33a04801 -VALIDATION_ERROR_03011:VALIDATION_ERROR_33a05201 -VALIDATION_ERROR_03012:VALIDATION_ERROR_33a12201 -VALIDATION_ERROR_03013:VALIDATION_ERROR_33a05207 -VALIDATION_ERROR_03014:VALIDATION_ERROR_1be002d6 -VALIDATION_ERROR_03015:VALIDATION_ERROR_1be002d8 -VALIDATION_ERROR_03016:VALIDATION_ERROR_1be002da -VALIDATION_ERROR_03017:VALIDATION_ERROR_1be02401 -VALIDATION_ERROR_03018:VALIDATION_ERROR_1be27e01 -VALIDATION_ERROR_03019:VALIDATION_ERROR_1be0be01 -VALIDATION_ERROR_03020:VALIDATION_ERROR_1be13601 -VALIDATION_ERROR_03021:VALIDATION_ERROR_1be02413 -VALIDATION_ERROR_03022:VALIDATION_ERROR_1be02415 -VALIDATION_ERROR_03023:VALIDATION_ERROR_1be0541b -VALIDATION_ERROR_03024:VALIDATION_ERROR_1be00009 -VALIDATION_ERROR_03025:VALIDATION_ERROR_1c0002dc -VALIDATION_ERROR_03026:VALIDATION_ERROR_1c002401 -VALIDATION_ERROR_03027:VALIDATION_ERROR_1c005201 -VALIDATION_ERROR_03028:VALIDATION_ERROR_1c00be01 -VALIDATION_ERROR_03029:VALIDATION_ERROR_1c012201 -VALIDATION_ERROR_03030:VALIDATION_ERROR_1c002413 -VALIDATION_ERROR_03031:VALIDATION_ERROR_1c002415 -VALIDATION_ERROR_03032:VALIDATION_ERROR_1c000009 -VALIDATION_ERROR_03033:VALIDATION_ERROR_1780064c -VALIDATION_ERROR_03034:VALIDATION_ERROR_1780064e -VALIDATION_ERROR_03035:VALIDATION_ERROR_17800650 -VALIDATION_ERROR_03036:VALIDATION_ERROR_1ae00656 -VALIDATION_ERROR_03037:VALIDATION_ERROR_1ae00658 -VALIDATION_ERROR_03038:VALIDATION_ERROR_1e80067c -VALIDATION_ERROR_03039:VALIDATION_ERROR_1e80067e -VALIDATION_ERROR_03040:VALIDATION_ERROR_18600024 -VALIDATION_ERROR_03044:VALIDATION_ERROR_184001b4 -VALIDATION_ERROR_03046:VALIDATION_ERROR_184001be -VALIDATION_ERROR_03050:VALIDATION_ERROR_1a20036a -VALIDATION_ERROR_03051:VALIDATION_ERROR_1a20036c -VALIDATION_ERROR_03052:VALIDATION_ERROR_1a200372 -VALIDATION_ERROR_03053:VALIDATION_ERROR_1a20038a -VALIDATION_ERROR_03054:VALIDATION_ERROR_1a400390 -VALIDATION_ERROR_03055:VALIDATION_ERROR_1a400392 -VALIDATION_ERROR_03056:VALIDATION_ERROR_1a400398 -VALIDATION_ERROR_03057:VALIDATION_ERROR_1a4003b2 -VALIDATION_ERROR_03058:VALIDATION_ERROR_1aa003c2 -VALIDATION_ERROR_03059:VALIDATION_ERROR_1aa003c4 -VALIDATION_ERROR_03060:VALIDATION_ERROR_1aa003ce -VALIDATION_ERROR_03061:VALIDATION_ERROR_1aa003d0 -VALIDATION_ERROR_03062:VALIDATION_ERROR_1aa003e6 -VALIDATION_ERROR_03063:VALIDATION_ERROR_07c003e8 -VALIDATION_ERROR_03064:VALIDATION_ERROR_1ac003fa -VALIDATION_ERROR_03065:VALIDATION_ERROR_1ac003fc -VALIDATION_ERROR_03066:VALIDATION_ERROR_1ac00408 -VALIDATION_ERROR_03067:VALIDATION_ERROR_1ac0041a -VALIDATION_ERROR_03068:VALIDATION_ERROR_1a60042a -VALIDATION_ERROR_03069:VALIDATION_ERROR_1a60042c -VALIDATION_ERROR_03070:VALIDATION_ERROR_1a600436 -VALIDATION_ERROR_03071:VALIDATION_ERROR_1a600438 -VALIDATION_ERROR_03072:VALIDATION_ERROR_1a60044e -VALIDATION_ERROR_03073:VALIDATION_ERROR_07a00450 -VALIDATION_ERROR_03074:VALIDATION_ERROR_1a800464 -VALIDATION_ERROR_03075:VALIDATION_ERROR_1a800466 -VALIDATION_ERROR_03076:VALIDATION_ERROR_1a800472 -VALIDATION_ERROR_03077:VALIDATION_ERROR_1a800484 -VALIDATION_ERROR_03078:VALIDATION_ERROR_10e0097e -VALIDATION_ERROR_03079:VALIDATION_ERROR_10e2b00b -VALIDATION_ERROR_03080:VALIDATION_ERROR_15231001 -VALIDATION_ERROR_03081:VALIDATION_ERROR_15231201 -VALIDATION_ERROR_03082:VALIDATION_ERROR_15231401 -VALIDATION_ERROR_03083:VALIDATION_ERROR_15230c01 -VALIDATION_ERROR_03084:VALIDATION_ERROR_11000a4e -VALIDATION_ERROR_03085:VALIDATION_ERROR_11000a50 -VALIDATION_ERROR_03086:VALIDATION_ERROR_11000a52 -VALIDATION_ERROR_03087:VALIDATION_ERROR_1102b00b -VALIDATION_ERROR_03088:VALIDATION_ERROR_11030a1b -VALIDATION_ERROR_03089:VALIDATION_ERROR_1e200a54 -VALIDATION_ERROR_03090:VALIDATION_ERROR_1e200a56 -VALIDATION_ERROR_03091:VALIDATION_ERROR_1e200a58 -VALIDATION_ERROR_03092:VALIDATION_ERROR_1e200a5a -VALIDATION_ERROR_03093:VALIDATION_ERROR_1e202401 -VALIDATION_ERROR_03094:VALIDATION_ERROR_1e202413 -VALIDATION_ERROR_03095:VALIDATION_ERROR_1e202415 -VALIDATION_ERROR_03096:VALIDATION_ERROR_1e230a1b -VALIDATION_ERROR_03097:VALIDATION_ERROR_10c2b00b -VALIDATION_ERROR_03098:VALIDATION_ERROR_10c1c40d -VALIDATION_ERROR_03099:VALIDATION_ERROR_10c09005 -VALIDATION_ERROR_03100:VALIDATION_ERROR_10c30a1b -VALIDATION_ERROR_03101:VALIDATION_ERROR_10c2b61b -VALIDATION_ERROR_03102:VALIDATION_ERROR_1021c40d -VALIDATION_ERROR_03103:VALIDATION_ERROR_10209005 -VALIDATION_ERROR_03104:VALIDATION_ERROR_10022201 -VALIDATION_ERROR_03105:VALIDATION_ERROR_0f80048c -VALIDATION_ERROR_03106:VALIDATION_ERROR_0f82b00b -VALIDATION_ERROR_03107:VALIDATION_ERROR_0f81c40d -VALIDATION_ERROR_03108:VALIDATION_ERROR_0f809005 -VALIDATION_ERROR_03109:VALIDATION_ERROR_0f805e01 -VALIDATION_ERROR_03110:VALIDATION_ERROR_1d20048e -VALIDATION_ERROR_03111:VALIDATION_ERROR_1d200490 -VALIDATION_ERROR_03112:VALIDATION_ERROR_1d200492 -VALIDATION_ERROR_03113:VALIDATION_ERROR_1d200494 -VALIDATION_ERROR_03114:VALIDATION_ERROR_1d200496 -VALIDATION_ERROR_03115:VALIDATION_ERROR_1d200498 -VALIDATION_ERROR_03116:VALIDATION_ERROR_1d20049a -VALIDATION_ERROR_03117:VALIDATION_ERROR_1d202401 -VALIDATION_ERROR_03118:VALIDATION_ERROR_1d214601 -VALIDATION_ERROR_03119:VALIDATION_ERROR_1d202413 -VALIDATION_ERROR_03120:VALIDATION_ERROR_1d202415 -VALIDATION_ERROR_03121:VALIDATION_ERROR_1d205c1b -VALIDATION_ERROR_03122:VALIDATION_ERROR_19c00304 -VALIDATION_ERROR_03123:VALIDATION_ERROR_19c00306 -VALIDATION_ERROR_03124:VALIDATION_ERROR_19c00308 -VALIDATION_ERROR_03125:VALIDATION_ERROR_19c0030a -VALIDATION_ERROR_03126:VALIDATION_ERROR_19c00310 -VALIDATION_ERROR_03127:VALIDATION_ERROR_1a000324 -VALIDATION_ERROR_03128:VALIDATION_ERROR_1a000330 -VALIDATION_ERROR_03129:VALIDATION_ERROR_19e00348 -VALIDATION_ERROR_03130:VALIDATION_ERROR_19e0034a -VALIDATION_ERROR_03131:VALIDATION_ERROR_19e0034c -VALIDATION_ERROR_03132:VALIDATION_ERROR_19e0034e -VALIDATION_ERROR_03133:VALIDATION_ERROR_19e00350 -VALIDATION_ERROR_03134:VALIDATION_ERROR_19e00352 -VALIDATION_ERROR_03135:VALIDATION_ERROR_19e00354 -VALIDATION_ERROR_03136:VALIDATION_ERROR_19e00356 -VALIDATION_ERROR_03137:VALIDATION_ERROR_19e02401 -VALIDATION_ERROR_03138:VALIDATION_ERROR_19e02413 -VALIDATION_ERROR_03139:VALIDATION_ERROR_19e02415 -VALIDATION_ERROR_03140:VALIDATION_ERROR_19e00017 -VALIDATION_ERROR_03141:VALIDATION_ERROR_0ba00a80 -VALIDATION_ERROR_03142:VALIDATION_ERROR_0ba2fe01 -VALIDATION_ERROR_03143:VALIDATION_ERROR_13400890 -VALIDATION_ERROR_03144:VALIDATION_ERROR_12e008a2 -VALIDATION_ERROR_03145:VALIDATION_ERROR_12e008a4 -VALIDATION_ERROR_03146:VALIDATION_ERROR_0121c40d -VALIDATION_ERROR_03147:VALIDATION_ERROR_05e008bc -VALIDATION_ERROR_03148:VALIDATION_ERROR_05e008be -VALIDATION_ERROR_03149:VALIDATION_ERROR_05e2b00b -VALIDATION_ERROR_03150:VALIDATION_ERROR_20a0bc01 -VALIDATION_ERROR_03151:VALIDATION_ERROR_20a11e01 -VALIDATION_ERROR_03152:VALIDATION_ERROR_20a0ec01 -VALIDATION_ERROR_03153:VALIDATION_ERROR_20a24801 -VALIDATION_ERROR_03154:VALIDATION_ERROR_09800a48 -VALIDATION_ERROR_03155:VALIDATION_ERROR_0982b00b -VALIDATION_ERROR_03156:VALIDATION_ERROR_0981c40d -VALIDATION_ERROR_03157:VALIDATION_ERROR_09809005 -VALIDATION_ERROR_03158:VALIDATION_ERROR_09826a01 -VALIDATION_ERROR_03159:VALIDATION_ERROR_2140bc01 -VALIDATION_ERROR_03160:VALIDATION_ERROR_21411e01 -VALIDATION_ERROR_03161:VALIDATION_ERROR_2140ec01 -VALIDATION_ERROR_03162:VALIDATION_ERROR_21424801 -VALIDATION_ERROR_03163:VALIDATION_ERROR_0c000a4a -VALIDATION_ERROR_03164:VALIDATION_ERROR_0c02b00b -VALIDATION_ERROR_03165:VALIDATION_ERROR_0c01c40d -VALIDATION_ERROR_03166:VALIDATION_ERROR_0c009005 -VALIDATION_ERROR_03167:VALIDATION_ERROR_0c026a01 -VALIDATION_ERROR_03168:VALIDATION_ERROR_28e05601 -VALIDATION_ERROR_03169:VALIDATION_ERROR_28e13c01 -VALIDATION_ERROR_03170:VALIDATION_ERROR_29005601 -VALIDATION_ERROR_03171:VALIDATION_ERROR_2902ec01 -VALIDATION_ERROR_03172:VALIDATION_ERROR_2901be01 -VALIDATION_ERROR_03173:VALIDATION_ERROR_2901be03 -VALIDATION_ERROR_03174:VALIDATION_ERROR_2d427a01 -VALIDATION_ERROR_03175:VALIDATION_ERROR_2d42ec01 -VALIDATION_ERROR_03176:VALIDATION_ERROR_2d420a01 -VALIDATION_ERROR_03177:VALIDATION_ERROR_2d420e01 -VALIDATION_ERROR_03178:VALIDATION_ERROR_2fe05601 -VALIDATION_ERROR_03179:VALIDATION_ERROR_2fe2f001 -VALIDATION_ERROR_03180:VALIDATION_ERROR_2fe15001 -VALIDATION_ERROR_03181:VALIDATION_ERROR_2b405601 -VALIDATION_ERROR_03182:VALIDATION_ERROR_2b42f001 -VALIDATION_ERROR_03183:VALIDATION_ERROR_2b41ec01 -VALIDATION_ERROR_03184:VALIDATION_ERROR_2b41ee01 -VALIDATION_ERROR_03185:VALIDATION_ERROR_1461c40d -VALIDATION_ERROR_03186:VALIDATION_ERROR_14609001 -VALIDATION_ERROR_03187:VALIDATION_ERROR_06a2b00b -VALIDATION_ERROR_03188:VALIDATION_ERROR_06a0d001 -VALIDATION_ERROR_03189:VALIDATION_ERROR_06a0d003 -VALIDATION_ERROR_03190:VALIDATION_ERROR_16205601 -VALIDATION_ERROR_03191:VALIDATION_ERROR_1620e001 -VALIDATION_ERROR_03192:VALIDATION_ERROR_16218601 -VALIDATION_ERROR_03193:VALIDATION_ERROR_00000a10 -VALIDATION_ERROR_03194:VALIDATION_ERROR_00000a12 -VALIDATION_ERROR_03195:VALIDATION_ERROR_00000a14 -VALIDATION_ERROR_03196:VALIDATION_ERROR_00000a16 -VALIDATION_ERROR_03197:VALIDATION_ERROR_0002b00b -VALIDATION_ERROR_03198:VALIDATION_ERROR_0001c40d -VALIDATION_ERROR_03199:VALIDATION_ERROR_0002f001 -VALIDATION_ERROR_03200:VALIDATION_ERROR_0002b801 -VALIDATION_ERROR_03201:VALIDATION_ERROR_00008801 -VALIDATION_ERROR_03202:VALIDATION_ERROR_31800a1e -VALIDATION_ERROR_03203:VALIDATION_ERROR_1121c40d -VALIDATION_ERROR_03204:VALIDATION_ERROR_06400a22 -VALIDATION_ERROR_03205:VALIDATION_ERROR_06400a24 -VALIDATION_ERROR_03206:VALIDATION_ERROR_06400a26 -VALIDATION_ERROR_03207:VALIDATION_ERROR_06400a28 -VALIDATION_ERROR_03208:VALIDATION_ERROR_06400a2a -VALIDATION_ERROR_03209:VALIDATION_ERROR_06400a2c -VALIDATION_ERROR_03210:VALIDATION_ERROR_06400a2e -VALIDATION_ERROR_03211:VALIDATION_ERROR_0642b00b -VALIDATION_ERROR_03212:VALIDATION_ERROR_06414001 -VALIDATION_ERROR_03213:VALIDATION_ERROR_0640ce01 -VALIDATION_ERROR_03214:VALIDATION_ERROR_118009be -VALIDATION_ERROR_03215:VALIDATION_ERROR_1182b00b -VALIDATION_ERROR_03216:VALIDATION_ERROR_11825e01 -VALIDATION_ERROR_03217:VALIDATION_ERROR_1182f21b -VALIDATION_ERROR_03218:VALIDATION_ERROR_33205601 -VALIDATION_ERROR_03219:VALIDATION_ERROR_33225801 -VALIDATION_ERROR_03220:VALIDATION_ERROR_3321ba01 -VALIDATION_ERROR_03221:VALIDATION_ERROR_3322f21b -VALIDATION_ERROR_03222:VALIDATION_ERROR_0e42b00b -VALIDATION_ERROR_03223:VALIDATION_ERROR_0e41c40d -VALIDATION_ERROR_03224:VALIDATION_ERROR_0e800488 -VALIDATION_ERROR_03225:VALIDATION_ERROR_0e80048a -VALIDATION_ERROR_03226:VALIDATION_ERROR_0e82b00b -VALIDATION_ERROR_03227:VALIDATION_ERROR_0ea2b00b -VALIDATION_ERROR_03228:VALIDATION_ERROR_0da2b00b -VALIDATION_ERROR_03229:VALIDATION_ERROR_0da1c40d -VALIDATION_ERROR_03230:VALIDATION_ERROR_0e61c40d -VALIDATION_ERROR_03231:VALIDATION_ERROR_0de2b00b -VALIDATION_ERROR_03232:VALIDATION_ERROR_0de09c01 -VALIDATION_ERROR_03233:VALIDATION_ERROR_2ba27a01 -VALIDATION_ERROR_03234:VALIDATION_ERROR_2ba16201 -VALIDATION_ERROR_03235:VALIDATION_ERROR_2ba16401 -VALIDATION_ERROR_03236:VALIDATION_ERROR_0dc2b00b -VALIDATION_ERROR_03237:VALIDATION_ERROR_0dc1c40d -VALIDATION_ERROR_03238:VALIDATION_ERROR_0dc09001 -VALIDATION_ERROR_03239:VALIDATION_ERROR_0dc30601 -VALIDATION_ERROR_03240:VALIDATION_ERROR_0dc30603 -VALIDATION_ERROR_03241:VALIDATION_ERROR_0dc09c01 -VALIDATION_ERROR_03242:VALIDATION_ERROR_2be27a01 -VALIDATION_ERROR_03243:VALIDATION_ERROR_2be16801 -VALIDATION_ERROR_03244:VALIDATION_ERROR_2be16a01 -VALIDATION_ERROR_03245:VALIDATION_ERROR_0e02b00b -VALIDATION_ERROR_03246:VALIDATION_ERROR_0e01c40d -VALIDATION_ERROR_03247:VALIDATION_ERROR_0e009c01 -VALIDATION_ERROR_03248:VALIDATION_ERROR_198009b0 -VALIDATION_ERROR_03249:VALIDATION_ERROR_0562b00f -VALIDATION_ERROR_03250:VALIDATION_ERROR_13c2b00f -VALIDATION_ERROR_03251:VALIDATION_ERROR_0c62b00f -VALIDATION_ERROR_03252:VALIDATION_ERROR_09e2b00f -VALIDATION_ERROR_03253:VALIDATION_ERROR_15c002a2 -VALIDATION_ERROR_03254:VALIDATION_ERROR_15c002a4 -VALIDATION_ERROR_03255:VALIDATION_ERROR_15c002a6 -VALIDATION_ERROR_03256:VALIDATION_ERROR_1122b00f -VALIDATION_ERROR_03257:VALIDATION_ERROR_116009d8 -VALIDATION_ERROR_03258:VALIDATION_ERROR_1162b00b -VALIDATION_ERROR_03259:VALIDATION_ERROR_11621001 -VALIDATION_ERROR_03260:VALIDATION_ERROR_11420c01 -VALIDATION_ERROR_03261:VALIDATION_ERROR_11e009da -VALIDATION_ERROR_03262:VALIDATION_ERROR_11e009dc -VALIDATION_ERROR_03263:VALIDATION_ERROR_06c2b00b -VALIDATION_ERROR_03264:VALIDATION_ERROR_06c1c40d -VALIDATION_ERROR_03265:VALIDATION_ERROR_06c09005 -VALIDATION_ERROR_03266:VALIDATION_ERROR_06c20401 -VALIDATION_ERROR_03267:VALIDATION_ERROR_06c29e1b -VALIDATION_ERROR_03268:VALIDATION_ERROR_0180094e -VALIDATION_ERROR_03269:VALIDATION_ERROR_01800ac8 -VALIDATION_ERROR_03270:VALIDATION_ERROR_01800952 -VALIDATION_ERROR_03271:VALIDATION_ERROR_01800954 -VALIDATION_ERROR_03272:VALIDATION_ERROR_01800956 -VALIDATION_ERROR_03273:VALIDATION_ERROR_0a000aca -VALIDATION_ERROR_03274:VALIDATION_ERROR_0a000acc -VALIDATION_ERROR_03275:VALIDATION_ERROR_12a00ac2 -VALIDATION_ERROR_03276:VALIDATION_ERROR_12a00ac4 -VALIDATION_ERROR_03277:VALIDATION_ERROR_12a00ac6 -VALIDATION_ERROR_03278:VALIDATION_ERROR_046002b0 -VALIDATION_ERROR_03279:VALIDATION_ERROR_184001bc -VALIDATION_ERROR_03280:VALIDATION_ERROR_184001c6 -VALIDATION_ERROR_03281:VALIDATION_ERROR_1c80020a -VALIDATION_ERROR_03282:VALIDATION_ERROR_1c80020e -VALIDATION_ERROR_03283:VALIDATION_ERROR_2e427a01 -VALIDATION_ERROR_03284:VALIDATION_ERROR_2e425001 -VALIDATION_ERROR_03285:VALIDATION_ERROR_2e424a01 -VALIDATION_ERROR_03286:VALIDATION_ERROR_0ee2b00b -VALIDATION_ERROR_03287:VALIDATION_ERROR_0ee1c40d -VALIDATION_ERROR_03288:VALIDATION_ERROR_0ee2ec01 -VALIDATION_ERROR_03289:VALIDATION_ERROR_2e827a01 -VALIDATION_ERROR_03290:VALIDATION_ERROR_2e825001 -VALIDATION_ERROR_03291:VALIDATION_ERROR_2e824c01 -VALIDATION_ERROR_03292:VALIDATION_ERROR_2e824e01 -VALIDATION_ERROR_03293:VALIDATION_ERROR_30a05601 -VALIDATION_ERROR_03294:VALIDATION_ERROR_30a2f001 -VALIDATION_ERROR_03295:VALIDATION_ERROR_14600ace -VALIDATION_ERROR_03296:VALIDATION_ERROR_14600ad0 -VALIDATION_ERROR_03297:VALIDATION_ERROR_1162f21b -VALIDATION_ERROR_03298:VALIDATION_ERROR_0be1c40d -VALIDATION_ERROR_03299:VALIDATION_ERROR_03c00ad2 -VALIDATION_ERROR_03300:VALIDATION_ERROR_1580e601 -VALIDATION_ERROR_03301:VALIDATION_ERROR_15821201 -VALIDATION_ERROR_03302:VALIDATION_ERROR_15800009 -VALIDATION_ERROR_03303:VALIDATION_ERROR_08e1c40d -VALIDATION_ERROR_03305:VALIDATION_ERROR_0ea1c40d -VALIDATION_ERROR_163578132:VALIDATION_ERROR_09c00114 -VALIDATION_ERROR_163578134:VALIDATION_ERROR_09c00116 -VALIDATION_ERROR_167774558:VALIDATION_ERROR_0a00095e -VALIDATION_ERROR_167774560:VALIDATION_ERROR_0a000960 -VALIDATION_ERROR_176162814:VALIDATION_ERROR_0a8007fe -VALIDATION_ERROR_25168204:VALIDATION_ERROR_0180094c -VALIDATION_ERROR_25168208:VALIDATION_ERROR_01800950 -VALIDATION_ERROR_312477820:VALIDATION_ERROR_12a0087c -VALIDATION_ERROR_312477822:VALIDATION_ERROR_12a0087e -VALIDATION_ERROR_312477824:VALIDATION_ERROR_12a00880 -VALIDATION_ERROR_352323992:VALIDATION_ERROR_15000998 -VALIDATION_ERROR_457179196:VALIDATION_ERROR_1b40003c diff --git a/layers/parameter_name.h b/layers/parameter_name.h deleted file mode 100644 index 05a1d89e..00000000 --- a/layers/parameter_name.h +++ /dev/null @@ -1,148 +0,0 @@ -/* Copyright (c) 2016 The Khronos Group Inc. - * Copyright (c) 2016 Valve Corporation - * Copyright (c) 2016 LunarG, Inc. - * Copyright (c) 2016 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. - */ -#ifndef PARAMETER_NAME_H -#define PARAMETER_NAME_H - -#include -#include -#include -#include - -/** - * Parameter name string supporting deferred formatting for array subscripts. - * - * Custom parameter name class with support for deferred formatting of names containing array subscripts. The class stores - * a format string and a vector of index values, and performs string formatting when an accessor function is called to - * retrieve the name string. This class was primarily designed to be used with validation functions that receive a parameter name - * string and value as arguments, and print an error message that includes the parameter name when the value fails a validation - * test. Using standard strings with these validation functions requires that parameter names containing array subscripts be - * formatted before each validation function is called, performing the string formatting even when the value passes validation - * and the string is not used: - * sprintf(name, "pCreateInfo[%d].sType", i); - * validate_stype(name, pCreateInfo[i].sType); - * - * With the ParameterName class, a format string and a vector of format values are stored by the ParameterName object that is - * provided to the validation function. String formatting is then performed only when the validation function retrieves the - * name string from the ParameterName object: - * validate_stype(ParameterName("pCreateInfo[%i].sType", IndexVector{ i }), pCreateInfo[i].sType); - */ -class ParameterName { - public: - /// Container for index values to be used with parameter name string formatting. - typedef std::vector IndexVector; - - /// Format specifier for the parameter name string, to be replaced by an index value. The parameter name string must contain - /// one format specifier for each index value specified. - const std::string IndexFormatSpecifier = "%i"; - - public: - /** - * Construct a ParameterName object from a string literal, without formatting. - * - * @param source Paramater name string without format specifiers. - * - * @pre The source string must not contain the %i format specifier. - */ - ParameterName(const char *source) : source_(source) { assert(IsValid()); } - - /** - * Construct a ParameterName object from a std::string object, without formatting. - * - * @param source Paramater name string without format specifiers. - * - * @pre The source string must not contain the %i format specifier. - */ - ParameterName(const std::string &source) : source_(source) { assert(IsValid()); } - - /** - * Construct a ParameterName object from a std::string object, without formatting. - * - * @param source Paramater name string without format specifiers. - * - * @pre The source string must not contain the %i format specifier. - */ - ParameterName(const std::string &&source) : source_(std::move(source)) { assert(IsValid()); } - - /** - * Construct a ParameterName object from a std::string object, with formatting. - * - * @param source Paramater name string with format specifiers. - * @param args Array index values to be used for formatting. - * - * @pre The number of %i format specifiers contained by the source string must match the number of elements contained - * by the index vector. - */ - ParameterName(const std::string &source, const IndexVector &args) : source_(source), args_(args) { assert(IsValid()); } - - /** - * Construct a ParameterName object from a std::string object, with formatting. - * - * @param source Paramater name string with format specifiers. - * @param args Array index values to be used for formatting. - * - * @pre The number of %i format specifiers contained by the source string must match the number of elements contained - * by the index vector. - */ - ParameterName(const std::string &&source, const IndexVector &&args) : source_(std::move(source)), args_(std::move(args)) { - assert(IsValid()); - } - - /// Retrive the formatted name string. - std::string get_name() const { return (args_.empty()) ? source_ : Format(); } - - private: - /// Replace the %i format specifiers in the source string with the values from the index vector. - std::string Format() const { - std::string::size_type current = 0; - std::string::size_type last = 0; - std::stringstream format; - - for (size_t index : args_) { - current = source_.find(IndexFormatSpecifier, last); - if (current == std::string::npos) { - break; - } - format << source_.substr(last, (current - last)) << index; - last = current + IndexFormatSpecifier.length(); - } - - format << source_.substr(last, std::string::npos); - - return format.str(); - } - - /// Check that the number of %i format specifiers in the source string matches the number of elements in the index vector. - bool IsValid() { - // Count the number of occurances of the format specifier - uint32_t count = 0; - std::string::size_type pos = source_.find(IndexFormatSpecifier); - - while (pos != std::string::npos) { - ++count; - pos = source_.find(IndexFormatSpecifier, pos + 1); - } - - return (count == args_.size()); - } - - private: - std::string source_; ///< Format string. - IndexVector args_; ///< Array index values for formatting. -}; - -#endif // PARAMETER_NAME_H diff --git a/layers/parameter_validation.h b/layers/parameter_validation.h deleted file mode 100644 index d04b6764..00000000 --- a/layers/parameter_validation.h +++ /dev/null @@ -1,912 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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: Dustin Graves - */ - -#ifndef PARAMETER_VALIDATION_UTILS_H -#define PARAMETER_VALIDATION_UTILS_H - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "vulkan/vulkan.h" -#include "vk_enum_string_helper.h" -#include "vk_layer_logging.h" -#include "vk_validation_error_messages.h" -#include "vk_extension_helper.h" - -#include "parameter_name.h" - -namespace parameter_validation { - -extern const uint32_t GeneratedHeaderVersion; -extern const std::unordered_map name_to_funcptr_map; - -extern const VkQueryPipelineStatisticFlags AllVkQueryPipelineStatisticFlagBits; -extern const VkColorComponentFlags AllVkColorComponentFlagBits; -extern const VkShaderStageFlags AllVkShaderStageFlagBits; -extern const VkQueryControlFlags AllVkQueryControlFlagBits; -extern const VkImageUsageFlags AllVkImageUsageFlagBits; - -extern const std::vector AllVkCompareOpEnums; -extern const std::vector AllVkStencilOpEnums; -extern const std::vector AllVkBlendFactorEnums; -extern const std::vector AllVkBlendOpEnums; -extern const std::vector AllVkLogicOpEnums; -extern const std::vector AllVkBorderColorEnums; -extern const std::vector AllVkImageLayoutEnums; - -struct instance_layer_data { - VkInstance instance = VK_NULL_HANDLE; - - debug_report_data *report_data = nullptr; - std::vector logging_callback; - std::vector logging_messenger; - - // The following are for keeping track of the temporary callbacks that can - // be used in vkCreateInstance and vkDestroyInstance: - uint32_t num_tmp_report_callbacks = 0; - VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos = nullptr; - VkDebugReportCallbackEXT *tmp_report_callbacks = nullptr; - uint32_t num_tmp_debug_messengers = 0; - VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos = nullptr; - VkDebugUtilsMessengerEXT *tmp_debug_messengers = nullptr; - - InstanceExtensions extensions = {}; - VkLayerInstanceDispatchTable dispatch_table = {}; - uint32_t api_version; -}; - -struct layer_data { - debug_report_data *report_data = nullptr; - // Map for queue family index to queue count - std::unordered_map queueFamilyIndexMap; - VkPhysicalDeviceLimits device_limits = {}; - VkPhysicalDeviceFeatures physical_device_features = {}; - VkPhysicalDevice physical_device = VK_NULL_HANDLE; - VkDevice device = VK_NULL_HANDLE; - DeviceExtensions extensions; - uint32_t api_version; - - struct SubpassesUsageStates { - std::unordered_set subpasses_using_color_attachment; - std::unordered_set subpasses_using_depthstencil_attachment; - }; - - std::unordered_map renderpasses_states; - - VkLayerDispatchTable dispatch_table = {}; -}; - -enum ErrorCode { - NONE, // Used for INFO & other non-error messages - INVALID_USAGE, // The value of a parameter is not consistent - // with the valid usage criteria defined in - // the Vulkan specification. - INVALID_STRUCT_STYPE, // The sType field of a Vulkan structure does - // not contain the value expected for a structure - // of that type. - INVALID_STRUCT_PNEXT, // The pNext field of a Vulkan structure references - // a value that is not compatible with a structure of - // that type or is not NULL when a structure of that - // type has no compatible pNext values. - REQUIRED_PARAMETER, // A required parameter was specified as 0 or NULL. - RESERVED_PARAMETER, // A parameter reserved for future use was not - // specified as 0 or NULL. - UNRECOGNIZED_VALUE, // A Vulkan enumeration, VkFlags, or VkBool32 parameter - // contains a value that is not recognized as valid for - // that type. - DEVICE_LIMIT, // A specified parameter exceeds the limits returned - // by the physical device - DEVICE_FEATURE, // Use of a requested feature is not supported by - // the device - FAILURE_RETURN_CODE, // A Vulkan return code indicating a failure condition - // was encountered. - EXTENSION_NOT_ENABLED, // An extension entrypoint was called, but the required - // extension was not enabled at CreateInstance or - // CreateDevice time. -}; - -struct GenericHeader { - VkStructureType sType; - const void *pNext; -}; - -// String returned by string_VkStructureType for an unrecognized type. -const std::string UnsupportedStructureTypeString = "Unhandled VkStructureType"; - -// String returned by string_VkResult for an unrecognized type. -const std::string UnsupportedResultString = "Unhandled VkResult"; - -// The base value used when computing the offset for an enumeration token value that is added by an extension. -// When validating enumeration tokens, any value >= to this value is considered to be provided by an extension. -// See Appendix C.10 "Assigning Extension Token Values" from the Vulkan specification -const uint32_t ExtEnumBaseValue = 1000000000; - -// The value of all VK_xxx_MAX_ENUM tokens -const uint32_t MaxEnumValue = 0x7FFFFFFF; - -// Misc parameters of log_msg that are likely constant per command (or low frequency change) -struct LogMiscParams { - const debug_report_data *debug_data; - VkDebugReportObjectTypeEXT objectType; - uint64_t srcObject; - const char *api_name; -}; - -/** - * Validate a minimum value. - * - * Verify that the specified value is greater than the specified lower bound. - * - * @param report_data debug_report_data object for routing validation messages. - * @param api_name Name of API call being validated. - * @param parameter_name Name of parameter being validated. - * @param value Value to validate. - * @param lower_bound Lower bound value to use for validation. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool ValidateGreaterThan(const T value, const T lower_bound, const ParameterName ¶meter_name, - const UNIQUE_VALIDATION_ERROR_CODE vuid, const LogMiscParams &misc) { - bool skip_call = false; - - if (value <= lower_bound) { - std::ostringstream ss; - ss << misc.api_name << ": parameter " << parameter_name.get_name() << " (= " << value << ") is greater than " - << lower_bound; - skip_call |= - log_msg(misc.debug_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, misc.objectType, misc.srcObject, vuid, "%s", ss.str().c_str()); - } - - return skip_call; -} - -template -bool ValidateGreaterThanZero(const T value, const ParameterName ¶meter_name, const UNIQUE_VALIDATION_ERROR_CODE vuid, - const LogMiscParams &misc) { - return ValidateGreaterThan(value, T{0}, parameter_name, vuid, misc); -} -/** - * Validate a required pointer. - * - * Verify that a required pointer is not NULL. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param parameterName Name of parameter being validated. - * @param value Pointer to validate. - * @return Boolean value indicating that the call should be skipped. - */ -static bool validate_required_pointer(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName, - const void *value, UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip_call = false; - - if (value == NULL) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid, - "%s: required parameter %s specified as NULL.", apiName, parameterName.get_name().c_str()); - } - - return skip_call; -} - -/** - * Validate array count and pointer to array. - * - * Verify that required count and array parameters are not 0 or NULL. If the - * count parameter is not optional, verify that it is not 0. If the array - * parameter is NULL, and it is not optional, verify that count is 0. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param countName Name of count parameter. - * @param arrayName Name of array parameter. - * @param count Number of elements in the array. - * @param array Array to validate. - * @param countRequired The 'count' parameter may not be 0 when true. - * @param arrayRequired The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName, - const ParameterName &arrayName, T1 count, const T2 *array, bool countRequired, bool arrayRequired, - UNIQUE_VALIDATION_ERROR_CODE count_required_vuid, UNIQUE_VALIDATION_ERROR_CODE array_required_vuid) { - bool skip_call = false; - - // Count parameters not tagged as optional cannot be 0 - if (countRequired && (count == 0)) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, count_required_vuid, - "%s: parameter %s must be greater than 0.", apiName, countName.get_name().c_str()); - } - - // Array parameters not tagged as optional cannot be NULL, unless the count is 0 - if (arrayRequired && (count != 0) && (*array == NULL)) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, array_required_vuid, - "%s: required parameter %s specified as NULL.", apiName, arrayName.get_name().c_str()); - } - - return skip_call; -} - -/** - * Validate pointer to array count and pointer to array. - * - * Verify that required count and array parameters are not NULL. If count - * is not NULL and its value is not optional, verify that it is not 0. If the - * array parameter is NULL, and it is not optional, verify that count is 0. - * The array parameter will typically be optional for this case (where count is - * a pointer), allowing the caller to retrieve the available count. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param countName Name of count parameter. - * @param arrayName Name of array parameter. - * @param count Pointer to the number of elements in the array. - * @param array Array to validate. - * @param countPtrRequired The 'count' parameter may not be NULL when true. - * @param countValueRequired The '*count' value may not be 0 when true. - * @param arrayRequired The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName, - const ParameterName &arrayName, const T1 *count, const T2 *array, bool countPtrRequired, - bool countValueRequired, bool arrayRequired, UNIQUE_VALIDATION_ERROR_CODE count_required_vuid, - UNIQUE_VALIDATION_ERROR_CODE array_required_vuid) { - bool skip_call = false; - - if (count == NULL) { - if (countPtrRequired) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, REQUIRED_PARAMETER, - "%s: required parameter %s specified as NULL", apiName, countName.get_name().c_str()); - } - } else { - skip_call |= validate_array(report_data, apiName, countName, arrayName, *array ? (*count) : 0, &array, countValueRequired, - arrayRequired, count_required_vuid, array_required_vuid); - } - - return skip_call; -} - -/** - * Validate a pointer to a Vulkan structure. - * - * Verify that a required pointer to a structure is not NULL. If the pointer is - * not NULL, verify that each structure's sType field is set to the correct - * VkStructureType value. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param parameterName Name of struct parameter being validated. - * @param sTypeName Name of expected VkStructureType value. - * @param value Pointer to the struct to validate. - * @param sType VkStructureType for structure validation. - * @param required The parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_struct_type(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName, - const char *sTypeName, const T *value, VkStructureType sType, bool required, - UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip_call = false; - - if (value == NULL) { - if (required) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, REQUIRED_PARAMETER, - "%s: required parameter %s specified as NULL", apiName, parameterName.get_name().c_str()); - } - } else if (value->sType != sType) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid, - "%s: parameter %s->sType must be %s.", apiName, parameterName.get_name().c_str(), sTypeName); - } - - return skip_call; -} - -/** - * Validate an array of Vulkan structures - * - * Verify that required count and array parameters are not 0 or NULL. If - * the array contains 1 or more structures, verify that each structure's - * sType field is set to the correct VkStructureType value. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param countName Name of count parameter. - * @param arrayName Name of array parameter. - * @param sTypeName Name of expected VkStructureType value. - * @param count Number of elements in the array. - * @param array Array to validate. - * @param sType VkStructureType for structure validation. - * @param countRequired The 'count' parameter may not be 0 when true. - * @param arrayRequired The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_struct_type_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName, - const ParameterName &arrayName, const char *sTypeName, uint32_t count, const T *array, - VkStructureType sType, bool countRequired, bool arrayRequired, UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip_call = false; - - if ((count == 0) || (array == NULL)) { - skip_call |= validate_array(report_data, apiName, countName, arrayName, count, &array, countRequired, arrayRequired, - VALIDATION_ERROR_UNDEFINED, vuid); - } else { - // Verify that all structs in the array have the correct type - for (uint32_t i = 0; i < count; ++i) { - if (array[i].sType != sType) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_STRUCT_STYPE, "%s: parameter %s[%d].sType must be %s", apiName, - arrayName.get_name().c_str(), i, sTypeName); - } - } - } - - return skip_call; -} - -/** - * Validate an array of Vulkan structures. - * - * Verify that required count and array parameters are not NULL. If count - * is not NULL and its value is not optional, verify that it is not 0. - * If the array contains 1 or more structures, verify that each structure's - * sType field is set to the correct VkStructureType value. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param countName Name of count parameter. - * @param arrayName Name of array parameter. - * @param sTypeName Name of expected VkStructureType value. - * @param count Pointer to the number of elements in the array. - * @param array Array to validate. - * @param sType VkStructureType for structure validation. - * @param countPtrRequired The 'count' parameter may not be NULL when true. - * @param countValueRequired The '*count' value may not be 0 when true. - * @param arrayRequired The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_struct_type_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName, - const ParameterName &arrayName, const char *sTypeName, uint32_t *count, const T *array, - VkStructureType sType, bool countPtrRequired, bool countValueRequired, bool arrayRequired, - UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip_call = false; - - if (count == NULL) { - if (countPtrRequired) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, REQUIRED_PARAMETER, - "%s: required parameter %s specified as NULL", apiName, countName.get_name().c_str()); - } - } else { - skip_call |= validate_struct_type_array(report_data, apiName, countName, arrayName, sTypeName, (*count), array, sType, - countValueRequired, arrayRequired, vuid); - } - - return skip_call; -} - -/** - * Validate a Vulkan handle. - * - * Verify that the specified handle is not VK_NULL_HANDLE. - * - * @param report_data debug_report_data object for routing validation messages. - * @param api_name Name of API call being validated. - * @param parameter_name Name of struct parameter being validated. - * @param value Handle to validate. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_required_handle(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name, T value) { - bool skip_call = false; - - if (value == VK_NULL_HANDLE) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, REQUIRED_PARAMETER, - "%s: required parameter %s specified as VK_NULL_HANDLE", api_name, parameter_name.get_name().c_str()); - } - - return skip_call; -} - -/** - * Validate an array of Vulkan handles. - * - * Verify that required count and array parameters are not NULL. If count - * is not NULL and its value is not optional, verify that it is not 0. - * If the array contains 1 or more handles, verify that no handle is set to - * VK_NULL_HANDLE. - * - * @note This function is only intended to validate arrays of handles when none - * of the handles are allowed to be VK_NULL_HANDLE. For arrays of handles - * that are allowed to contain VK_NULL_HANDLE, use validate_array() instead. - * - * @param report_data debug_report_data object for routing validation messages. - * @param api_name Name of API call being validated. - * @param count_name Name of count parameter. - * @param array_name Name of array parameter. - * @param count Number of elements in the array. - * @param array Array to validate. - * @param count_required The 'count' parameter may not be 0 when true. - * @param array_required The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_handle_array(debug_report_data *report_data, const char *api_name, const ParameterName &count_name, - const ParameterName &array_name, uint32_t count, const T *array, bool count_required, - bool array_required) { - bool skip_call = false; - - if ((count == 0) || (array == NULL)) { - skip_call |= validate_array(report_data, api_name, count_name, array_name, count, &array, count_required, array_required, - VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - } else { - // Verify that no handles in the array are VK_NULL_HANDLE - for (uint32_t i = 0; i < count; ++i) { - if (array[i] == VK_NULL_HANDLE) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - REQUIRED_PARAMETER, "%s: required parameter %s[%d] specified as VK_NULL_HANDLE", api_name, - array_name.get_name().c_str(), i); - } - } - } - - return skip_call; -} - -/** - * Validate string array count and content. - * - * Verify that required count and array parameters are not 0 or NULL. If the - * count parameter is not optional, verify that it is not 0. If the array - * parameter is NULL, and it is not optional, verify that count is 0. If the - * array parameter is not NULL, verify that none of the strings are NULL. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param countName Name of count parameter. - * @param arrayName Name of array parameter. - * @param count Number of strings in the array. - * @param array Array of strings to validate. - * @param countRequired The 'count' parameter may not be 0 when true. - * @param arrayRequired The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -static bool validate_string_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName, - const ParameterName &arrayName, uint32_t count, const char *const *array, bool countRequired, - bool arrayRequired, UNIQUE_VALIDATION_ERROR_CODE count_required_vuid, - UNIQUE_VALIDATION_ERROR_CODE array_required_vuid) { - bool skip_call = false; - - if ((count == 0) || (array == NULL)) { - skip_call |= validate_array(report_data, apiName, countName, arrayName, count, &array, countRequired, arrayRequired, - count_required_vuid, array_required_vuid); - } else { - // Verify that strings in the array are not NULL - for (uint32_t i = 0; i < count; ++i) { - if (array[i] == NULL) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - REQUIRED_PARAMETER, "%s: required parameter %s[%d] specified as NULL", apiName, - arrayName.get_name().c_str(), i); - } - } - } - - return skip_call; -} - -/** - * Validate a structure's pNext member. - * - * Verify that the specified pNext value points to the head of a list of - * allowed extension structures. If no extension structures are allowed, - * verify that pNext is null. - * - * @param report_data debug_report_data object for routing validation messages. - * @param api_name Name of API call being validated. - * @param parameter_name Name of parameter being validated. - * @param allowed_struct_names Names of allowed structs. - * @param next Pointer to validate. - * @param allowed_type_count Total number of allowed structure types. - * @param allowed_types Array of structure types allowed for pNext. - * @param header_version Version of header defining the pNext validation rules. - * @return Boolean value indicating that the call should be skipped. - */ -static bool validate_struct_pnext(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name, - const char *allowed_struct_names, const void *next, size_t allowed_type_count, - const VkStructureType *allowed_types, uint32_t header_version, - UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip_call = false; - std::unordered_set cycle_check; - std::unordered_set> unique_stype_check; - - const char disclaimer[] = - "This warning is based on the Valid Usage documentation for version %d of the Vulkan header. It is possible that you are " - "using a struct from a private extension or an extension that was added to a later version of the Vulkan header, in which " - "case your use of %s is perfectly valid but is not guaranteed to work correctly with validation enabled"; - - // TODO: The valid pNext structure types are not recursive. Each structure has its own list of valid sTypes for pNext. - // Codegen a map of vectors containing the allowable pNext types for each struct and use that here -- also simplifies parms. - if (next != NULL) { - if (allowed_type_count == 0) { - std::string message = "%s: value of %s must be NULL. "; - message += disclaimer; - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid, - message.c_str(), api_name, parameter_name.get_name().c_str(), header_version, - parameter_name.get_name().c_str()); - } else { - const VkStructureType *start = allowed_types; - const VkStructureType *end = allowed_types + allowed_type_count; - const GenericHeader *current = reinterpret_cast(next); - - cycle_check.insert(next); - - while (current != NULL) { - if (cycle_check.find(current->pNext) != cycle_check.end()) { - std::string message = "%s: %s chain contains a cycle -- pNext pointer " PRIx64 " is repeated."; - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_STRUCT_PNEXT, message.c_str(), api_name, parameter_name.get_name().c_str(), - reinterpret_cast(next)); - break; - } else { - cycle_check.insert(current->pNext); - } - - std::string type_name = string_VkStructureType(current->sType); - if (unique_stype_check.find(current->sType) != unique_stype_check.end()) { - std::string message = "%s: %s chain contains duplicate structure types: %s appears multiple times."; - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_STRUCT_PNEXT, message.c_str(), api_name, parameter_name.get_name().c_str(), - type_name.c_str()); - } else { - unique_stype_check.insert(current->sType); - } - - if (std::find(start, end, current->sType) == end) { - if (type_name == UnsupportedStructureTypeString) { - std::string message = - "%s: %s chain includes a structure with unknown VkStructureType (%d); Allowed structures are [%s]. "; - message += disclaimer; - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, vuid, message.c_str(), api_name, parameter_name.get_name().c_str(), current->sType, - allowed_struct_names, header_version, parameter_name.get_name().c_str()); - } else { - std::string message = - "%s: %s chain includes a structure with unexpected VkStructureType %s; Allowed structures are [%s]. "; - message += disclaimer; - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid, - message.c_str(), api_name, parameter_name.get_name().c_str(), type_name.c_str(), - allowed_struct_names, header_version, parameter_name.get_name().c_str()); - } - } - current = reinterpret_cast(current->pNext); - } - } - } - - return skip_call; -} - -/** - * Validate a VkBool32 value. - * - * Generate a warning if a VkBool32 value is neither VK_TRUE nor VK_FALSE. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param parameterName Name of parameter being validated. - * @param value Boolean value to validate. - * @return Boolean value indicating that the call should be skipped. - */ -static bool validate_bool32(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName, - VkBool32 value) { - bool skip_call = false; - - if ((value != VK_TRUE) && (value != VK_FALSE)) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, UNRECOGNIZED_VALUE, - "%s: value of %s (%d) is neither VK_TRUE nor VK_FALSE", apiName, parameterName.get_name().c_str(), value); - } - - return skip_call; -} - -/** - * Validate a Vulkan enumeration value. - * - * Generate a warning if an enumeration token value does not fall within the core enumeration - * begin and end token values, and was not added to the enumeration by an extension. Extension - * provided enumerations use the equation specified in Appendix C.10 of the Vulkan specification, - * with 1,000,000,000 as the base token value. - * - * @note This function does not expect to process enumerations defining bitmask flag bits. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param parameterName Name of parameter being validated. - * @param enumName Name of the enumeration being validated. - * @param valid_values The list of valid values for the enumeration. - * @param value Enumeration value to validate. - * @return Boolean value indicating that the call should be skipped. - */ -template -bool validate_ranged_enum(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName, - const char *enumName, const std::vector &valid_values, T value, UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip = false; - - if (std::find(valid_values.begin(), valid_values.end(), value) == valid_values.end()) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid, - "%s: value of %s (%d) does not fall within the begin..end range of the core %s enumeration tokens and is " - "not an extension added token.", - apiName, parameterName.get_name().c_str(), value, enumName); - } - - return skip; -} - -/** - * Validate an array of Vulkan enumeration value. - * - * Process all enumeration token values in the specified array and generate a warning if a value - * does not fall within the core enumeration begin and end token values, and was not added to - * the enumeration by an extension. Extension provided enumerations use the equation specified - * in Appendix C.10 of the Vulkan specification, with 1,000,000,000 as the base token value. - * - * @note This function does not expect to process enumerations defining bitmask flag bits. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param countName Name of count parameter. - * @param arrayName Name of array parameter. - * @param enumName Name of the enumeration being validated. - * @param valid_values The list of valid values for the enumeration. - * @param count Number of enumeration values in the array. - * @param array Array of enumeration values to validate. - * @param countRequired The 'count' parameter may not be 0 when true. - * @param arrayRequired The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -template -static bool validate_ranged_enum_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName, - const ParameterName &arrayName, const char *enumName, const std::vector &valid_values, - uint32_t count, const T *array, bool countRequired, bool arrayRequired) { - bool skip_call = false; - - if ((count == 0) || (array == NULL)) { - skip_call |= validate_array(report_data, apiName, countName, arrayName, count, &array, countRequired, arrayRequired, - VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - } else { - for (uint32_t i = 0; i < count; ++i) { - if (std::find(valid_values.begin(), valid_values.end(), array[i]) == valid_values.end()) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - UNRECOGNIZED_VALUE, - "%s: value of %s[%d] (%d) does not fall within the begin..end range of the core %s " - "enumeration tokens and is not an extension added token", - apiName, arrayName.get_name().c_str(), i, array[i], enumName); - } - } - } - - return skip_call; -} - -/** - * Verify that a reserved VkFlags value is zero. - * - * Verify that the specified value is zero, to check VkFlags values that are reserved for - * future use. - * - * @param report_data debug_report_data object for routing validation messages. - * @param api_name Name of API call being validated. - * @param parameter_name Name of parameter being validated. - * @param value Value to validate. - * @return Boolean value indicating that the call should be skipped. - */ -static bool validate_reserved_flags(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name, - VkFlags value, UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip_call = false; - - if (value != 0) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid, - "%s: parameter %s must be 0.", api_name, parameter_name.get_name().c_str()); - } - - return skip_call; -} - -/** - * Validate a Vulkan bitmask value. - * - * Generate a warning if a value with a VkFlags derived type does not contain valid flag bits - * for that type. - * - * @param report_data debug_report_data object for routing validation messages. - * @param api_name Name of API call being validated. - * @param parameter_name Name of parameter being validated. - * @param flag_bits_name Name of the VkFlags type being validated. - * @param all_flags A bit mask combining all valid flag bits for the VkFlags type being validated. - * @param value VkFlags value to validate. - * @param flags_required The 'value' parameter may not be 0 when true. - * @param singleFlag The 'value' parameter may not contain more than one bit from all_flags. - * @return Boolean value indicating that the call should be skipped. - */ -static bool validate_flags(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name, - const char *flag_bits_name, VkFlags all_flags, VkFlags value, bool flags_required, bool singleFlag, - UNIQUE_VALIDATION_ERROR_CODE vuid) { - bool skip_call = false; - - if (value == 0) { - if (flags_required) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid, - "%s: value of %s must not be 0.", api_name, parameter_name.get_name().c_str()); - } - } else if ((value & (~all_flags)) != 0) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - UNRECOGNIZED_VALUE, "%s: value of %s contains flag bits that are not recognized members of %s", - api_name, parameter_name.get_name().c_str(), flag_bits_name); - } else if (singleFlag && (std::bitset(value).count() > 1)) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, UNRECOGNIZED_VALUE, - "%s: value of %s contains multiple members of %s when only a single value is allowed", api_name, - parameter_name.get_name().c_str(), flag_bits_name); - } - - return skip_call; -} - -/** - * Validate an array of Vulkan bitmask values. - * - * Generate a warning if a value with a VkFlags derived type does not contain valid flag bits - * for that type. - * - * @param report_data debug_report_data object for routing validation messages. - * @param api_name Name of API call being validated. - * @param count_name Name of parameter being validated. - * @param array_name Name of parameter being validated. - * @param flag_bits_name Name of the VkFlags type being validated. - * @param all_flags A bitmask combining all valid flag bits for the VkFlags type being validated. - * @param count Number of VkFlags values in the array. - * @param array Array of VkFlags value to validate. - * @param count_required The 'count' parameter may not be 0 when true. - * @param array_required The 'array' parameter may not be NULL when true. - * @return Boolean value indicating that the call should be skipped. - */ -static bool validate_flags_array(debug_report_data *report_data, const char *api_name, const ParameterName &count_name, - const ParameterName &array_name, const char *flag_bits_name, VkFlags all_flags, uint32_t count, - const VkFlags *array, bool count_required, bool array_required) { - bool skip_call = false; - - if ((count == 0) || (array == NULL)) { - skip_call |= validate_array(report_data, api_name, count_name, array_name, count, &array, count_required, array_required, - VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - } else { - // Verify that all VkFlags values in the array - for (uint32_t i = 0; i < count; ++i) { - if (array[i] == 0) { - // Current XML registry logic for validity generation uses the array parameter's optional tag to determine if - // elements in the array are allowed be 0 - if (array_required) { - skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - REQUIRED_PARAMETER, "%s: value of %s[%d] must not be 0", api_name, - array_name.get_name().c_str(), i); - } - } else if ((array[i] & (~all_flags)) != 0) { - skip_call |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - UNRECOGNIZED_VALUE, "%s: value of %s[%d] contains flag bits that are not recognized members of %s", - api_name, array_name.get_name().c_str(), i, flag_bits_name); - } - } - } - - return skip_call; -} - -/** - * Get VkResult code description. - * - * Returns a string describing the specified VkResult code. The description is based on the language in the Vulkan API - * specification. - * - * @param value VkResult code to process. - * @return String describing the specified VkResult code. - */ -static std::string get_result_description(VkResult result) { - // clang-format off - switch (result) { - case VK_SUCCESS: return "a command completed successfully"; - case VK_NOT_READY: return "a fence or query has not yet completed"; - case VK_TIMEOUT: return "a wait operation has not completed in the specified time"; - case VK_EVENT_SET: return "an event is signaled"; - case VK_EVENT_RESET: return "an event is unsignalled"; - case VK_INCOMPLETE: return "a return array was too small for the result"; - case VK_ERROR_OUT_OF_HOST_MEMORY: return "a host memory allocation has failed"; - case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "a device memory allocation has failed"; - case VK_ERROR_INITIALIZATION_FAILED: return "initialization of an object has failed"; - case VK_ERROR_DEVICE_LOST: return "the logical device has been lost"; - case VK_ERROR_MEMORY_MAP_FAILED: return "mapping of a memory object has failed"; - case VK_ERROR_LAYER_NOT_PRESENT: return "the specified layer does not exist"; - case VK_ERROR_EXTENSION_NOT_PRESENT: return "the specified extension does not exist"; - case VK_ERROR_FEATURE_NOT_PRESENT: return "the requested feature is not available on this device"; - case VK_ERROR_INCOMPATIBLE_DRIVER: return "a Vulkan driver could not be found"; - case VK_ERROR_TOO_MANY_OBJECTS: return "too many objects of the type have already been created"; - case VK_ERROR_FORMAT_NOT_SUPPORTED: return "the requested format is not supported on this device"; - case VK_ERROR_SURFACE_LOST_KHR: return "a surface is no longer available"; - case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "the requested window is already connected to another " - "VkSurfaceKHR object, or some other non-Vulkan surface object"; - case VK_SUBOPTIMAL_KHR: return "an image became available, and the swapchain no longer " - "matches the surface properties exactly, but can still be used to " - "present to the surface successfully."; - case VK_ERROR_OUT_OF_DATE_KHR: return "a surface has changed in such a way that it is no " - "longer compatible with the swapchain"; - case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "the display used by a swapchain does not use the same " - "presentable image layout, or is incompatible in a way that prevents " - "sharing an image"; - case VK_ERROR_VALIDATION_FAILED_EXT: return "API validation has detected an invalid use of the API"; - case VK_ERROR_INVALID_SHADER_NV: return "one or more shaders failed to compile or link"; - default: return "an error has occurred"; - }; - // clang-format on -} - -/** - * Validate return code. - * - * Print a message describing the reason for failure when an error code is returned. - * - * @param report_data debug_report_data object for routing validation messages. - * @param apiName Name of API call being validated. - * @param ignore vector of VkResult return codes to be ignored - * @param value VkResult value to validate. - */ -static void validate_result(debug_report_data *report_data, const char *apiName, std::vector const &ignore, - VkResult result) { - if (result < 0 && result != VK_ERROR_VALIDATION_FAILED_EXT) { - if (std::find(ignore.begin(), ignore.end(), result) != ignore.end()) { - return; - } - std::string resultName = string_VkResult(result); - if (resultName == UnsupportedResultString) { - // Unrecognized result code - log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, FAILURE_RETURN_CODE, - "%s: returned a result code indicating that an error has occurred", apiName); - } else { - std::string resultDesc = get_result_description(result); - log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, FAILURE_RETURN_CODE, - "%s: returned %s, indicating that %s", apiName, resultName.c_str(), resultDesc.c_str()); - } - } -} - -} // namespace parameter_validation - -#endif // PARAMETER_VALIDATION_UTILS_H diff --git a/layers/parameter_validation_layer.md b/layers/parameter_validation_layer.md deleted file mode 100644 index 1c238d3b..00000000 --- a/layers/parameter_validation_layer.md +++ /dev/null @@ -1,8 +0,0 @@ -# VK\_LAYER\_LUNARG\_parameter\_validation -The `VK_LAYER_LUNARG_parameter_validation` validation layer checks the input parameters to API calls for validity. This layer performs the following tasks: - - - validation of structures; structures are recursed if necessary - - validation of enumerated type values - - null pointer conditions - - stateless valid usage checks - - validation of `VkResult`. diff --git a/layers/parameter_validation_utils.cpp b/layers/parameter_validation_utils.cpp deleted file mode 100644 index 2f467b53..00000000 --- a/layers/parameter_validation_utils.cpp +++ /dev/null @@ -1,3093 +0,0 @@ -/* 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 - */ - -#define NOMINMAX - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -#include "vk_loader_platform.h" -#include "vulkan/vk_layer.h" -#include "vk_layer_config.h" -#include "vk_dispatch_table_helper.h" -#include "vk_typemap_helper.h" - -#include "vk_layer_table.h" -#include "vk_layer_data.h" -#include "vk_layer_logging.h" -#include "vk_layer_extension_utils.h" -#include "vk_layer_utils.h" - -#include "parameter_name.h" -#include "parameter_validation.h" - -#if defined __ANDROID__ -#include -#define LOGCONSOLE(...) ((void)__android_log_print(ANDROID_LOG_INFO, "PARAMETER_VALIDATION", __VA_ARGS__)) -#else -#define LOGCONSOLE(...) \ - { \ - printf(__VA_ARGS__); \ - printf("\n"); \ - } -#endif - -namespace parameter_validation { - -extern std::unordered_map custom_functions; - -extern bool parameter_validation_vkCreateInstance(VkInstance instance, const VkInstanceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkInstance *pInstance); -extern bool parameter_validation_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator); -extern bool parameter_validation_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice); -extern bool parameter_validation_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator); -extern bool parameter_validation_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool); -extern bool parameter_validation_vkCreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pMsgCallback); -extern bool parameter_validation_vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, - const VkAllocationCallbacks *pAllocator); -extern bool parameter_validation_vkCreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger); -extern bool parameter_validation_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator); -extern bool parameter_validation_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool); -extern bool parameter_validation_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass); -extern bool parameter_validation_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, - const VkAllocationCallbacks *pAllocator); - -// TODO : This can be much smarter, using separate locks for separate global data -std::mutex global_lock; - -static uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION; -std::unordered_map layer_data_map; -std::unordered_map instance_layer_data_map; - -void InitializeManualParameterValidationFunctionPointers(void); - -static void init_parameter_validation(instance_layer_data *instance_data, const VkAllocationCallbacks *pAllocator) { - layer_debug_report_actions(instance_data->report_data, instance_data->logging_callback, pAllocator, - "lunarg_parameter_validation"); - layer_debug_messenger_actions(instance_data->report_data, instance_data->logging_messenger, pAllocator, - "lunarg_parameter_validation"); -} - -static const VkExtensionProperties instance_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}, - {VK_EXT_DEBUG_UTILS_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_SPEC_VERSION}}; - -static const VkLayerProperties global_layer = { - "VK_LAYER_LUNARG_parameter_validation", - VK_LAYER_API_VERSION, - 1, - "LunarG Validation Layer", -}; - -static const int MaxParamCheckerStringLength = 256; - -template -static inline bool in_inclusive_range(const T &value, const T &min, const T &max) { - // Using only < for generality and || for early abort - return !((value < min) || (max < value)); -} - -static bool validate_string(debug_report_data *report_data, const char *apiName, const ParameterName &stringName, - const char *validateString) { - assert(apiName != nullptr); - assert(validateString != nullptr); - - bool skip = false; - - VkStringErrorFlags result = vk_string_validate(MaxParamCheckerStringLength, validateString); - - if (result == VK_STRING_ERROR_NONE) { - return skip; - } else if (result & VK_STRING_ERROR_LENGTH) { - skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, INVALID_USAGE, - "%s: string %s exceeds max length %d", apiName, stringName.get_name().c_str(), MaxParamCheckerStringLength); - } else if (result & VK_STRING_ERROR_BAD_DATA) { - skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, INVALID_USAGE, - "%s: string %s contains invalid characters or is badly formed", apiName, stringName.get_name().c_str()); - } - return skip; -} - -static bool ValidateDeviceQueueFamily(layer_data *device_data, uint32_t queue_family, const char *cmd_name, - const char *parameter_name, int32_t error_code, bool optional = false) { - bool skip = false; - - if (!optional && queue_family == VK_QUEUE_FAMILY_IGNORED) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(device_data->device), error_code, - "%s: %s is VK_QUEUE_FAMILY_IGNORED, but it is required to provide a valid queue family index value.", - cmd_name, parameter_name); - } else if (device_data->queueFamilyIndexMap.find(queue_family) == device_data->queueFamilyIndexMap.end()) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(device_data->device), error_code, - "%s: %s (= %" PRIu32 - ") is not one of the queue families given via VkDeviceQueueCreateInfo structures when the device was created.", - cmd_name, parameter_name, queue_family); - } - - return skip; -} - -static bool ValidateQueueFamilies(layer_data *device_data, uint32_t queue_family_count, const uint32_t *queue_families, - const char *cmd_name, const char *array_parameter_name, int32_t unique_error_code, - int32_t valid_error_code, bool optional = false) { - bool skip = false; - if (queue_families) { - std::unordered_set set; - for (uint32_t i = 0; i < queue_family_count; ++i) { - std::string parameter_name = std::string(array_parameter_name) + "[" + std::to_string(i) + "]"; - - if (set.count(queue_families[i])) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(device_data->device), VALIDATION_ERROR_056002e8, - "%s: %s (=%" PRIu32 ") is not unique within %s array.", cmd_name, parameter_name.c_str(), - queue_families[i], array_parameter_name); - } else { - set.insert(queue_families[i]); - skip |= ValidateDeviceQueueFamily(device_data, queue_families[i], cmd_name, parameter_name.c_str(), - valid_error_code, optional); - } - } - } - return skip; -} - -static bool validate_api_version(const instance_layer_data *instance_data, uint32_t api_version, uint32_t effective_api_version) { - bool skip = false; - uint32_t api_version_nopatch = VK_MAKE_VERSION(VK_VERSION_MAJOR(api_version), VK_VERSION_MINOR(api_version), 0); - if (api_version_nopatch != effective_api_version) { - if (api_version_nopatch < VK_API_VERSION_1_0) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - HandleToUint64(instance_data->instance), VALIDATION_ERROR_UNDEFINED, - "Invalid CreateInstance->pCreateInfo->pApplicationInfo.apiVersion number (0x%08x). " - "Using VK_API_VERSION_%" PRIu32 "_%" PRIu32 ".", - api_version, VK_VERSION_MAJOR(effective_api_version), VK_VERSION_MINOR(effective_api_version)); - } else { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - HandleToUint64(instance_data->instance), VALIDATION_ERROR_UNDEFINED, - "Unrecognized CreateInstance->pCreateInfo->pApplicationInfo.apiVersion number (0x%08x). " - "Assuming VK_API_VERSION_%" PRIu32 "_%" PRIu32 ".", - api_version, VK_VERSION_MAJOR(effective_api_version), VK_VERSION_MINOR(effective_api_version)); - } - } - return skip; -} - -template -static bool validate_extension_reqs(const instance_layer_data *instance_data, const ExtensionState &extensions, - UNIQUE_VALIDATION_ERROR_CODE vuid, const char *extension_type, const char *extension_name) { - bool skip = false; - if (!extension_name) { - return skip; // Robust to invalid char * - } - auto info = ExtensionState::get_info(extension_name); - - if (!info.state) { - return skip; // Unknown extensions cannot be checked so report OK - } - - // Check agains the reqs list in the info - std::vector missing; - for (const auto &req : info.requires) { - if (!(extensions.*(req.enabled))) { - missing.push_back(req.name); - } - } - - // Report any missing requirements - if (missing.size()) { - std::string missing_joined_list = string_join(", ", missing); - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - HandleToUint64(instance_data->instance), vuid, "Missing required extensions for %s extension %s, %s.", - extension_type, extension_name, missing_joined_list.c_str()); - } - return skip; -} - -bool validate_instance_extensions(const instance_layer_data *instance_data, const VkInstanceCreateInfo *pCreateInfo) { - bool skip = false; - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - skip |= validate_extension_reqs(instance_data, instance_data->extensions, VALIDATION_ERROR_21200ad8, "instance", - pCreateInfo->ppEnabledExtensionNames[i]); - } - - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - - VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - assert(chain_info != nullptr); - assert(chain_info->u.pLayerInfo != nullptr); - - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); - if (fpCreateInstance == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); - - if (result == VK_SUCCESS) { - InitializeManualParameterValidationFunctionPointers(); - auto my_instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), instance_layer_data_map); - assert(my_instance_data != nullptr); - - layer_init_instance_dispatch_table(*pInstance, &my_instance_data->dispatch_table, fpGetInstanceProcAddr); - my_instance_data->instance = *pInstance; - my_instance_data->report_data = - debug_utils_create_instance(&my_instance_data->dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount, - pCreateInfo->ppEnabledExtensionNames); - - // Look for one or more debug report create info structures - // and setup a callback(s) for each one found. - if (!layer_copy_tmp_debug_messengers(pCreateInfo->pNext, &my_instance_data->num_tmp_debug_messengers, - &my_instance_data->tmp_messenger_create_infos, - &my_instance_data->tmp_debug_messengers)) { - if (my_instance_data->num_tmp_debug_messengers > 0) { - // Setup the temporary callback(s) here to catch early issues: - if (layer_enable_tmp_debug_messengers(my_instance_data->report_data, my_instance_data->num_tmp_debug_messengers, - my_instance_data->tmp_messenger_create_infos, - my_instance_data->tmp_debug_messengers)) { - // Failure of setting up one or more of the callback. - // Therefore, clean up and don't use those callbacks: - layer_free_tmp_debug_messengers(my_instance_data->tmp_messenger_create_infos, - my_instance_data->tmp_debug_messengers); - my_instance_data->num_tmp_debug_messengers = 0; - } - } - } - if (!layer_copy_tmp_report_callbacks(pCreateInfo->pNext, &my_instance_data->num_tmp_report_callbacks, - &my_instance_data->tmp_report_create_infos, &my_instance_data->tmp_report_callbacks)) { - if (my_instance_data->num_tmp_report_callbacks > 0) { - // Setup the temporary callback(s) here to catch early issues: - if (layer_enable_tmp_report_callbacks(my_instance_data->report_data, my_instance_data->num_tmp_report_callbacks, - my_instance_data->tmp_report_create_infos, - my_instance_data->tmp_report_callbacks)) { - // Failure of setting up one or more of the callback. - // Therefore, clean up and don't use those callbacks: - layer_free_tmp_report_callbacks(my_instance_data->tmp_report_create_infos, - my_instance_data->tmp_report_callbacks); - my_instance_data->num_tmp_report_callbacks = 0; - } - } - } - - init_parameter_validation(my_instance_data, pAllocator); - // Note: From the spec-- - // Providing a NULL VkInstanceCreateInfo::pApplicationInfo or providing an apiVersion of 0 is equivalent to providing - // an apiVersion of VK_MAKE_VERSION(1, 0, 0). (a.k.a. VK_API_VERSION_1_0) - uint32_t api_version = (pCreateInfo->pApplicationInfo && pCreateInfo->pApplicationInfo->apiVersion) - ? pCreateInfo->pApplicationInfo->apiVersion - : VK_API_VERSION_1_0; - - uint32_t effective_api_version = my_instance_data->extensions.InitFromInstanceCreateInfo(api_version, pCreateInfo); - - // Ordinarily we'd check these before calling down the chain, but none of the layer support is in place until now, if we - // survive we can report the issue now. - validate_api_version(my_instance_data, api_version, effective_api_version); - validate_instance_extensions(my_instance_data, pCreateInfo); - - parameter_validation_vkCreateInstance(*pInstance, pCreateInfo, pAllocator, pInstance); - - if (pCreateInfo->pApplicationInfo) { - if (pCreateInfo->pApplicationInfo->pApplicationName) { - validate_string(my_instance_data->report_data, "vkCreateInstance", - "pCreateInfo->VkApplicationInfo->pApplicationName", - pCreateInfo->pApplicationInfo->pApplicationName); - } - - if (pCreateInfo->pApplicationInfo->pEngineName) { - validate_string(my_instance_data->report_data, "vkCreateInstance", "pCreateInfo->VkApplicationInfo->pEngineName", - pCreateInfo->pApplicationInfo->pEngineName); - } - } - - // Disable the tmp callbacks: - if (my_instance_data->num_tmp_debug_messengers > 0) { - layer_disable_tmp_debug_messengers(my_instance_data->report_data, my_instance_data->num_tmp_debug_messengers, - my_instance_data->tmp_debug_messengers); - } - if (my_instance_data->num_tmp_report_callbacks > 0) { - layer_disable_tmp_report_callbacks(my_instance_data->report_data, my_instance_data->num_tmp_report_callbacks, - my_instance_data->tmp_report_callbacks); - } - } - - return result; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - // Grab the key before the instance is destroyed. - dispatch_key key = get_dispatch_key(instance); - bool skip = false; - auto instance_data = GetLayerDataPtr(key, instance_layer_data_map); - - // Enable the temporary callback(s) here to catch vkDestroyInstance issues: - bool callback_setup = false; - if (instance_data->num_tmp_debug_messengers > 0) { - if (!layer_enable_tmp_debug_messengers(instance_data->report_data, instance_data->num_tmp_debug_messengers, - instance_data->tmp_messenger_create_infos, instance_data->tmp_debug_messengers)) { - callback_setup = true; - } - } - if (instance_data->num_tmp_report_callbacks > 0) { - if (!layer_enable_tmp_report_callbacks(instance_data->report_data, instance_data->num_tmp_report_callbacks, - instance_data->tmp_report_create_infos, instance_data->tmp_report_callbacks)) { - callback_setup = true; - } - } - - skip |= parameter_validation_vkDestroyInstance(instance, pAllocator); - - // Disable and cleanup the temporary callback(s): - if (callback_setup) { - layer_disable_tmp_debug_messengers(instance_data->report_data, instance_data->num_tmp_debug_messengers, - instance_data->tmp_debug_messengers); - layer_disable_tmp_report_callbacks(instance_data->report_data, instance_data->num_tmp_report_callbacks, - instance_data->tmp_report_callbacks); - } - if (instance_data->num_tmp_debug_messengers > 0) { - layer_free_tmp_debug_messengers(instance_data->tmp_messenger_create_infos, instance_data->tmp_debug_messengers); - instance_data->num_tmp_debug_messengers = 0; - } - if (instance_data->num_tmp_report_callbacks > 0) { - layer_free_tmp_report_callbacks(instance_data->tmp_report_create_infos, instance_data->tmp_report_callbacks); - instance_data->num_tmp_report_callbacks = 0; - } - - if (!skip) { - instance_data->dispatch_table.DestroyInstance(instance, pAllocator); - - // Clean up logging callback, if any - while (instance_data->logging_messenger.size() > 0) { - VkDebugUtilsMessengerEXT messenger = instance_data->logging_messenger.back(); - layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator); - instance_data->logging_messenger.pop_back(); - } - while (instance_data->logging_callback.size() > 0) { - VkDebugReportCallbackEXT callback = instance_data->logging_callback.back(); - layer_destroy_report_callback(instance_data->report_data, callback, pAllocator); - instance_data->logging_callback.pop_back(); - } - - layer_debug_utils_destroy_instance(instance_data->report_data); - } - - FreeLayerDataPtr(key, instance_layer_data_map); -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pMsgCallback) { - bool skip = parameter_validation_vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - VkResult result = instance_data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); - if (result == VK_SUCCESS) { - result = layer_create_report_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pMsgCallback); - // If something happened during this call, clean up the message callback that was created earlier in the lower levels - if (VK_SUCCESS != result) { - instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, *pMsgCallback, pAllocator); - } - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, - const VkAllocationCallbacks *pAllocator) { - bool skip = parameter_validation_vkDestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); - if (!skip) { - auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); - layer_destroy_report_callback(instance_data->report_data, msgCallback, pAllocator); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger) { - bool skip = parameter_validation_vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - VkResult result = instance_data->dispatch_table.CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); - if (VK_SUCCESS == result) { - result = layer_create_messenger_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pMessenger); - // If something happened during this call, clean up the message callback that was created earlier in the lower levels - if (VK_SUCCESS != result) { - instance_data->dispatch_table.DestroyDebugUtilsMessengerEXT(instance, *pMessenger, pAllocator); - } - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - bool skip = parameter_validation_vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); - if (!skip) { - auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - instance_data->dispatch_table.DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); - layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator); - } -} - -template -static bool extension_state_by_name(const ExtensionState &extensions, const char *extension_name) { - if (!extension_name) return false; // null strings specify nothing - auto info = ExtensionState::get_info(extension_name); - bool state = info.state ? extensions.*(info.state) : false; // unknown extensions can't be enabled in extension struct - return state; -} - -static bool ValidateDeviceCreateInfo(instance_layer_data *instance_data, VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo *pCreateInfo, const DeviceExtensions &extensions) { - bool skip = false; - bool maint1 = false; - bool negative_viewport = false; - - if ((pCreateInfo->enabledLayerCount > 0) && (pCreateInfo->ppEnabledLayerNames != NULL)) { - for (size_t i = 0; i < pCreateInfo->enabledLayerCount; i++) { - skip |= validate_string(instance_data->report_data, "vkCreateDevice", "pCreateInfo->ppEnabledLayerNames", - pCreateInfo->ppEnabledLayerNames[i]); - } - } - - if ((pCreateInfo->enabledExtensionCount > 0) && (pCreateInfo->ppEnabledExtensionNames != NULL)) { - maint1 = extension_state_by_name(extensions, VK_KHR_MAINTENANCE1_EXTENSION_NAME); - negative_viewport = extension_state_by_name(extensions, VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME); - - for (size_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - skip |= validate_string(instance_data->report_data, "vkCreateDevice", "pCreateInfo->ppEnabledExtensionNames", - pCreateInfo->ppEnabledExtensionNames[i]); - skip |= validate_extension_reqs(instance_data, extensions, VALIDATION_ERROR_1fc00ad6, "device", - pCreateInfo->ppEnabledExtensionNames[i]); - } - } - - if (maint1 && negative_viewport) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_056002ec, - "VkDeviceCreateInfo->ppEnabledExtensionNames must not simultaneously include VK_KHR_maintenance1 and " - "VK_AMD_negative_viewport_height."); - } - - if (pCreateInfo->pNext != NULL && pCreateInfo->pEnabledFeatures) { - // Check for get_physical_device_properties2 struct - const auto *features2 = lvl_find_in_chain(pCreateInfo->pNext); - if (features2) { - // Cannot include VkPhysicalDeviceFeatures2KHR and have non-null pEnabledFeatures - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_USAGE, - "VkDeviceCreateInfo->pNext includes a VkPhysicalDeviceFeatures2KHR struct when " - "pCreateInfo->pEnabledFeatures is non-NULL."); - } - } - - // Validate pCreateInfo->pQueueCreateInfos - if (pCreateInfo->pQueueCreateInfos) { - std::unordered_set set; - - for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; ++i) { - const uint32_t requested_queue_family = pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex; - if (requested_queue_family == VK_QUEUE_FAMILY_IGNORED) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, HandleToUint64(physicalDevice), - VALIDATION_ERROR_06c002fa, - "vkCreateDevice: pCreateInfo->pQueueCreateInfos[%" PRIu32 - "].queueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, but it is required to provide a valid queue family " - "index value.", - i); - } else if (set.count(requested_queue_family)) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, HandleToUint64(physicalDevice), - VALIDATION_ERROR_056002e8, - "vkCreateDevice: pCreateInfo->pQueueCreateInfos[%" PRIu32 "].queueFamilyIndex (=%" PRIu32 - ") is not unique within pCreateInfo->pQueueCreateInfos array.", - i, requested_queue_family); - } else { - set.insert(requested_queue_family); - } - - if (pCreateInfo->pQueueCreateInfos[i].pQueuePriorities != nullptr) { - for (uint32_t j = 0; j < pCreateInfo->pQueueCreateInfos[i].queueCount; ++j) { - const float queue_priority = pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j]; - if (!(queue_priority >= 0.f) || !(queue_priority <= 1.f)) { - skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, HandleToUint64(physicalDevice), - VALIDATION_ERROR_06c002fe, - "vkCreateDevice: pCreateInfo->pQueueCreateInfos[%" PRIu32 "].pQueuePriorities[%" PRIu32 - "] (=%f) is not between 0 and 1 (inclusive).", - i, j, queue_priority); - } - } - } - } - } - - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - // NOTE: Don't validate physicalDevice or any dispatchable object as the first parameter. We couldn't get here if it was wrong! - - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - bool skip = false; - auto my_instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - assert(my_instance_data != nullptr); - - // Query and save physical device limits for this device, needed for validation - VkPhysicalDeviceProperties device_properties = {}; - my_instance_data->dispatch_table.GetPhysicalDeviceProperties(physicalDevice, &device_properties); - - // Set up the extension structure also for validation. - DeviceExtensions extensions; - uint32_t api_version = - extensions.InitFromDeviceCreateInfo(&my_instance_data->extensions, device_properties.apiVersion, pCreateInfo); - - std::unique_lock lock(global_lock); - - skip |= parameter_validation_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); - - if (pCreateInfo != NULL) skip |= ValidateDeviceCreateInfo(my_instance_data, physicalDevice, pCreateInfo, extensions); - - if (!skip) { - VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - assert(chain_info != nullptr); - assert(chain_info->u.pLayerInfo != nullptr); - - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(my_instance_data->instance, "vkCreateDevice"); - if (fpCreateDevice == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - lock.unlock(); - - result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); - - lock.lock(); - - if (result == VK_SUCCESS) { - layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); - assert(my_device_data != nullptr); - - my_device_data->report_data = layer_debug_utils_create_device(my_instance_data->report_data, *pDevice); - layer_init_device_dispatch_table(*pDevice, &my_device_data->dispatch_table, fpGetDeviceProcAddr); - - my_device_data->api_version = api_version; - my_device_data->extensions = extensions; - - // Store createdevice data - if ((pCreateInfo != nullptr) && (pCreateInfo->pQueueCreateInfos != nullptr)) { - for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; ++i) { - my_device_data->queueFamilyIndexMap.insert(std::make_pair(pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex, - pCreateInfo->pQueueCreateInfos[i].queueCount)); - } - } - - memcpy(&my_device_data->device_limits, &device_properties.limits, sizeof(VkPhysicalDeviceLimits)); - my_device_data->physical_device = physicalDevice; - my_device_data->device = *pDevice; - - // Save app-enabled features in this device's layer_data structure - // The enabled features can come from either pEnabledFeatures, or from the pNext chain - const VkPhysicalDeviceFeatures *enabled_features_found = pCreateInfo->pEnabledFeatures; - if ((nullptr == enabled_features_found) && my_device_data->extensions.vk_khr_get_physical_device_properties_2) { - const auto *features2 = lvl_find_in_chain(pCreateInfo->pNext); - if (features2) { - enabled_features_found = &(features2->features); - } - } - if (enabled_features_found) { - my_device_data->physical_device_features = *enabled_features_found; - } else { - memset(&my_device_data->physical_device_features, 0, sizeof(VkPhysicalDeviceFeatures)); - } - } - } - - return result; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { - dispatch_key key = get_dispatch_key(device); - bool skip = false; - layer_data *device_data = GetLayerDataPtr(key, layer_data_map); - { - std::unique_lock lock(global_lock); - skip |= parameter_validation_vkDestroyDevice(device, pAllocator); - } - - if (!skip) { - layer_debug_utils_destroy_device(device); - device_data->dispatch_table.DestroyDevice(device, pAllocator); - } - FreeLayerDataPtr(key, layer_data_map); -} - -bool pv_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - skip |= - ValidateDeviceQueueFamily(device_data, queueFamilyIndex, "vkGetDeviceQueue", "queueFamilyIndex", VALIDATION_ERROR_29600300); - const auto &queue_data = device_data->queueFamilyIndexMap.find(queueFamilyIndex); - if (queue_data != device_data->queueFamilyIndexMap.end() && queue_data->second <= queueIndex) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - HandleToUint64(device), VALIDATION_ERROR_29600302, - "vkGetDeviceQueue: queueIndex (=%" PRIu32 - ") is not less than the number of queues requested from queueFamilyIndex (=%" PRIu32 - ") when the device was created (i.e. is not less than %" PRIu32 ").", - queueIndex, queueFamilyIndex, queue_data->second); - } - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) { - layer_data *local_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::unique_lock lock(global_lock); - - skip |= ValidateDeviceQueueFamily(local_data, pCreateInfo->queueFamilyIndex, "vkCreateCommandPool", - "pCreateInfo->queueFamilyIndex", VALIDATION_ERROR_02c0004e); - - skip |= parameter_validation_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); - - lock.unlock(); - if (!skip) { - result = local_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - skip |= parameter_validation_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - if (pCreateInfo != nullptr) { - // If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of - // VkQueryPipelineStatisticFlagBits values - if ((pCreateInfo->queryType == VK_QUERY_TYPE_PIPELINE_STATISTICS) && (pCreateInfo->pipelineStatistics != 0) && - ((pCreateInfo->pipelineStatistics & (~AllVkQueryPipelineStatisticFlagBits)) != 0)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_11c00630, - "vkCreateQueryPool(): if pCreateInfo->queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, " - "pCreateInfo->pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits " - "values."); - } - } - if (!skip) { - result = device_data->dispatch_table.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - - { - std::unique_lock lock(global_lock); - skip |= parameter_validation_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); - - typedef bool (*PFN_manual_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass); - PFN_manual_vkCreateRenderPass custom_func = (PFN_manual_vkCreateRenderPass)custom_functions["vkCreateRenderPass"]; - if (custom_func != nullptr) { - skip |= custom_func(device, pCreateInfo, pAllocator, pRenderPass); - } - } - - if (!skip) { - result = device_data->dispatch_table.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); - - // track the state necessary for checking vkCreateGraphicsPipeline (subpass usage of depth and color attachments) - if (result == VK_SUCCESS) { - std::unique_lock lock(global_lock); - const auto renderPass = *pRenderPass; - auto &renderpass_state = device_data->renderpasses_states[renderPass]; - - for (uint32_t subpass = 0; subpass < pCreateInfo->subpassCount; ++subpass) { - bool uses_color = false; - for (uint32_t i = 0; i < pCreateInfo->pSubpasses[subpass].colorAttachmentCount && !uses_color; ++i) - if (pCreateInfo->pSubpasses[subpass].pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED) uses_color = true; - - bool uses_depthstencil = false; - if (pCreateInfo->pSubpasses[subpass].pDepthStencilAttachment) - if (pCreateInfo->pSubpasses[subpass].pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) - uses_depthstencil = true; - - if (uses_color) renderpass_state.subpasses_using_color_attachment.insert(subpass); - if (uses_depthstencil) renderpass_state.subpasses_using_depthstencil_attachment.insert(subpass); - } - } - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - - { - std::unique_lock lock(global_lock); - skip |= parameter_validation_vkDestroyRenderPass(device, renderPass, pAllocator); - - typedef bool (*PFN_manual_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, - const VkAllocationCallbacks *pAllocator); - PFN_manual_vkDestroyRenderPass custom_func = (PFN_manual_vkDestroyRenderPass)custom_functions["vkDestroyRenderPass"]; - if (custom_func != nullptr) { - skip |= custom_func(device, renderPass, pAllocator); - } - } - - if (!skip) { - device_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator); - - // track the state necessary for checking vkCreateGraphicsPipeline (subpass usage of depth and color attachments) - { - std::unique_lock lock(global_lock); - device_data->renderpasses_states.erase(renderPass); - } - } -} - -bool pv_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkBuffer *pBuffer) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - const LogMiscParams log_misc{report_data, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, VK_NULL_HANDLE, "vkCreateBuffer"}; - - if (pCreateInfo != nullptr) { - skip |= ValidateGreaterThanZero(pCreateInfo->size, "pCreateInfo->size", VALIDATION_ERROR_01400720, log_misc); - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) { - // If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1 - if (pCreateInfo->queueFamilyIndexCount <= 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_01400724, - "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, " - "pCreateInfo->queueFamilyIndexCount must be greater than 1."); - } - - // If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a pointer to an array of - // queueFamilyIndexCount uint32_t values - if (pCreateInfo->pQueueFamilyIndices == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_01400722, - "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, " - "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of " - "pCreateInfo->queueFamilyIndexCount uint32_t values."); - } else { - skip |= ValidateQueueFamilies(device_data, pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices, - "vkCreateBuffer", "pCreateInfo->pQueueFamilyIndices", INVALID_USAGE, INVALID_USAGE, - false); - } - } - - // If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain - // VK_BUFFER_CREATE_SPARSE_BINDING_BIT - if (((pCreateInfo->flags & (VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT)) != 0) && - ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) != VK_BUFFER_CREATE_SPARSE_BINDING_BIT)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0140072c, - "vkCreateBuffer: if pCreateInfo->flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or " - "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT."); - } - } - - return skip; -} - -bool pv_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkImage *pImage) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - const LogMiscParams log_misc{report_data, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_NULL_HANDLE, "vkCreateImage"}; - - if (pCreateInfo != nullptr) { - if ((device_data->physical_device_features.textureCompressionETC2 == false) && - FormatIsCompressed_ETC2_EAC(pCreateInfo->format)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DEVICE_FEATURE, - "vkCreateImage(): Attempting to create VkImage with format %s. The textureCompressionETC2 feature is " - "not enabled: neither ETC2 nor EAC formats can be used to create images.", - string_VkFormat(pCreateInfo->format)); - } - - if ((device_data->physical_device_features.textureCompressionASTC_LDR == false) && - FormatIsCompressed_ASTC_LDR(pCreateInfo->format)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DEVICE_FEATURE, - "vkCreateImage(): Attempting to create VkImage with format %s. The textureCompressionASTC_LDR feature " - "is not enabled: ASTC formats cannot be used to create images.", - string_VkFormat(pCreateInfo->format)); - } - - if ((device_data->physical_device_features.textureCompressionBC == false) && FormatIsCompressed_BC(pCreateInfo->format)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DEVICE_FEATURE, - "vkCreateImage(): Attempting to create VkImage with format %s. The textureCompressionBC feature is not " - "enabled: BC compressed formats cannot be used to create images.", - string_VkFormat(pCreateInfo->format)); - } - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) { - // If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1 - if (pCreateInfo->queueFamilyIndexCount <= 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0075c, - "vkCreateImage(): if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, " - "pCreateInfo->queueFamilyIndexCount must be greater than 1."); - } - - // If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a pointer to an array of - // queueFamilyIndexCount uint32_t values - if (pCreateInfo->pQueueFamilyIndices == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0075a, - "vkCreateImage(): if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, " - "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of " - "pCreateInfo->queueFamilyIndexCount uint32_t values."); - } else { - skip |= - ValidateQueueFamilies(device_data, pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices, - "vkCreateImage", "pCreateInfo->pQueueFamilyIndices", INVALID_USAGE, INVALID_USAGE, false); - } - } - - skip |= - ValidateGreaterThanZero(pCreateInfo->extent.width, "pCreateInfo->extent.width", VALIDATION_ERROR_09e00760, log_misc); - skip |= - ValidateGreaterThanZero(pCreateInfo->extent.height, "pCreateInfo->extent.height", VALIDATION_ERROR_09e00762, log_misc); - skip |= - ValidateGreaterThanZero(pCreateInfo->extent.depth, "pCreateInfo->extent.depth", VALIDATION_ERROR_09e00764, log_misc); - - skip |= ValidateGreaterThanZero(pCreateInfo->mipLevels, "pCreateInfo->mipLevels", VALIDATION_ERROR_09e00766, log_misc); - skip |= ValidateGreaterThanZero(pCreateInfo->arrayLayers, "pCreateInfo->arrayLayers", VALIDATION_ERROR_09e00768, log_misc); - - // InitialLayout must be PREINITIALIZED or UNDEFINED - if ((pCreateInfo->initialLayout != VK_IMAGE_LAYOUT_UNDEFINED) && - (pCreateInfo->initialLayout != VK_IMAGE_LAYOUT_PREINITIALIZED)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, VALIDATION_ERROR_09e007c2, - "vkCreateImage(): initialLayout is %s, must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.", - string_VkImageLayout(pCreateInfo->initialLayout)); - } - - // If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1 - if ((pCreateInfo->imageType == VK_IMAGE_TYPE_1D) && - ((pCreateInfo->extent.height != 1) || (pCreateInfo->extent.depth != 1))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00778, - "vkCreateImage(): if pCreateInfo->imageType is VK_IMAGE_TYPE_1D, both pCreateInfo->extent.height and " - "pCreateInfo->extent.depth must be 1."); - } - - if (pCreateInfo->imageType == VK_IMAGE_TYPE_2D) { - if (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) { - if (pCreateInfo->extent.width != pCreateInfo->extent.height) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_09e00774, - "vkCreateImage(): pCreateInfo->flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, but " - "pCreateInfo->extent.width (=%" PRIu32 ") and pCreateInfo->extent.height (=%" PRIu32 - ") are not equal.", - pCreateInfo->extent.width, pCreateInfo->extent.height); - } - - if (pCreateInfo->arrayLayers < 6) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_09e00774, - "vkCreateImage(): pCreateInfo->flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, but " - "pCreateInfo->arrayLayers (=%" PRIu32 ") is not greater than or equal to 6.", - pCreateInfo->arrayLayers); - } - } - - if (pCreateInfo->extent.depth != 1) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0077a, - "vkCreateImage(): if pCreateInfo->imageType is VK_IMAGE_TYPE_2D, pCreateInfo->extent.depth must be 1."); - } - } - - // 3D image may have only 1 layer - if ((pCreateInfo->imageType == VK_IMAGE_TYPE_3D) && (pCreateInfo->arrayLayers != 1)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00782, - "vkCreateImage(): if pCreateInfo->imageType is VK_IMAGE_TYPE_3D, pCreateInfo->arrayLayers must be 1."); - } - - // If multi-sample, validate type, usage, tiling and mip levels. - if ((pCreateInfo->samples != VK_SAMPLE_COUNT_1_BIT) && - ((pCreateInfo->imageType != VK_IMAGE_TYPE_2D) || (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) || - (pCreateInfo->tiling != VK_IMAGE_TILING_OPTIMAL) || (pCreateInfo->mipLevels != 1))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00784, - "vkCreateImage(): Multi-sample image with incompatible type, usage, tiling, or mips."); - } - - if (0 != (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)) { - VkImageUsageFlags legal_flags = (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT); - // At least one of the legal attachment bits must be set - if (0 == (pCreateInfo->usage & legal_flags)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0078c, - "vkCreateImage(): Transient attachment image without a compatible attachment flag set."); - } - // No flags other than the legal attachment bits may be set - legal_flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; - if (0 != (pCreateInfo->usage & ~legal_flags)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00786, - "vkCreateImage(): Transient attachment image with incompatible usage flags set."); - } - } - - // mipLevels must be less than or equal to floor(log2(max(extent.width,extent.height,extent.depth)))+1 - uint32_t maxDim = std::max(std::max(pCreateInfo->extent.width, pCreateInfo->extent.height), pCreateInfo->extent.depth); - if (maxDim > 0 && pCreateInfo->mipLevels > (floor(log2(maxDim)) + 1)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, VALIDATION_ERROR_09e0077c, - "vkCreateImage(): pCreateInfo->mipLevels must be less than or equal to " - "floor(log2(max(pCreateInfo->extent.width, pCreateInfo->extent.height, pCreateInfo->extent.depth)))+1."); - } - - if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) && (!device_data->physical_device_features.sparseBinding)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_NULL_HANDLE, - VALIDATION_ERROR_09e00792, - "vkCreateImage(): pCreateInfo->flags contains VK_IMAGE_CREATE_SPARSE_BINDING_BIT, but the " - "VkPhysicalDeviceFeatures::sparseBinding feature is disabled."); - } - - // If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain - // VK_IMAGE_CREATE_SPARSE_BINDING_BIT - if (((pCreateInfo->flags & (VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT)) != 0) && - ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) != VK_IMAGE_CREATE_SPARSE_BINDING_BIT)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e007b6, - "vkCreateImage: if pCreateInfo->flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or " - "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT."); - } - - // Check for combinations of attributes that are incompatible with having VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set - if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) != 0) { - // Linear tiling is unsupported - if (VK_IMAGE_TILING_LINEAR == pCreateInfo->tiling) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, INVALID_USAGE, - "vkCreateImage: if pCreateInfo->flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT then image " - "tiling of VK_IMAGE_TILING_LINEAR is not supported"); - } - - // Sparse 1D image isn't valid - if (VK_IMAGE_TYPE_1D == pCreateInfo->imageType) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00794, - "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 1D image."); - } - - // Sparse 2D image when device doesn't support it - if ((VK_FALSE == device_data->physical_device_features.sparseResidencyImage2D) && - (VK_IMAGE_TYPE_2D == pCreateInfo->imageType)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00796, - "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 2D image if corresponding " - "feature is not enabled on the device."); - } - - // Sparse 3D image when device doesn't support it - if ((VK_FALSE == device_data->physical_device_features.sparseResidencyImage3D) && - (VK_IMAGE_TYPE_3D == pCreateInfo->imageType)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e00798, - "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 3D image if corresponding " - "feature is not enabled on the device."); - } - - // Multi-sample 2D image when device doesn't support it - if (VK_IMAGE_TYPE_2D == pCreateInfo->imageType) { - if ((VK_FALSE == device_data->physical_device_features.sparseResidency2Samples) && - (VK_SAMPLE_COUNT_2_BIT == pCreateInfo->samples)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0079a, - "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 2-sample image if " - "corresponding feature is not enabled on the device."); - } else if ((VK_FALSE == device_data->physical_device_features.sparseResidency4Samples) && - (VK_SAMPLE_COUNT_4_BIT == pCreateInfo->samples)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0079c, - "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 4-sample image if " - "corresponding feature is not enabled on the device."); - } else if ((VK_FALSE == device_data->physical_device_features.sparseResidency8Samples) && - (VK_SAMPLE_COUNT_8_BIT == pCreateInfo->samples)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e0079e, - "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 8-sample image if " - "corresponding feature is not enabled on the device."); - } else if ((VK_FALSE == device_data->physical_device_features.sparseResidency16Samples) && - (VK_SAMPLE_COUNT_16_BIT == pCreateInfo->samples)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_09e007a0, - "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 16-sample image if " - "corresponding feature is not enabled on the device."); - } - } - } - } - return skip; -} - -bool pv_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkImageView *pView) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - if (pCreateInfo != nullptr) { - if ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D) || (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D)) { - if ((pCreateInfo->subresourceRange.layerCount != 1) && - (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 1, - - "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_%dD, " - "pCreateInfo->subresourceRange.layerCount must be 1", - ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D) ? 1 : 2)); - } - } else if ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY) || - (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) { - if ((pCreateInfo->subresourceRange.layerCount < 1) && - (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 1, - - "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_%dD_ARRAY, " - "pCreateInfo->subresourceRange.layerCount must be >= 1", - ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? 1 : 2)); - } - } else if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE) { - if ((pCreateInfo->subresourceRange.layerCount != 6) && - (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 1, - - "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_CUBE, " - "pCreateInfo->subresourceRange.layerCount must be 6"); - } - } else if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) { - if (((pCreateInfo->subresourceRange.layerCount == 0) || ((pCreateInfo->subresourceRange.layerCount % 6) != 0)) && - (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 1, - - "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_CUBE_ARRAY, " - "pCreateInfo->subresourceRange.layerCount must be a multiple of 6"); - } - if (!device_data->physical_device_features.imageCubeArray) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 1, - "vkCreateImageView: Device feature imageCubeArray not enabled."); - } - } else if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_3D) { - if (pCreateInfo->subresourceRange.baseArrayLayer != 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 1, - - "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_3D, " - "pCreateInfo->subresourceRange.baseArrayLayer must be 0"); - } - - if ((pCreateInfo->subresourceRange.layerCount != 1) && - (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, 1, - - "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_3D, " - "pCreateInfo->subresourceRange.layerCount must be 1"); - } - } - - // Validate chained VkImageViewUsageCreateInfo struct, if present - if (nullptr != pCreateInfo->pNext) { - auto chained_ivuci_struct = lvl_find_in_chain(pCreateInfo->pNext); - if (chained_ivuci_struct) { - if (0 == chained_ivuci_struct->usage) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_3f230603, - "vkCreateImageView: Chained VkImageViewUsageCreateInfo usage field must not be 0."); - } else if (chained_ivuci_struct->usage & ~AllVkImageUsageFlagBits) { - std::stringstream ss; - ss << "vkCreateImageView: Chained VkImageViewUsageCreateInfo usage field (0x" << std::hex - << chained_ivuci_struct->usage << ") contains invalid flag bits."; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_3f230601, "%s", ss.str().c_str()); - } - } - } - } - return skip; -} - -bool pv_VkViewport(const layer_data *device_data, const VkViewport &viewport, const char *fn_name, const char *param_name, - VkDebugReportObjectTypeEXT object_type, uint64_t object = 0) { - bool skip = false; - debug_report_data *report_data = device_data->report_data; - - // Note: for numerical correctness - // - float comparisons should expect NaN (comparison always false). - // - VkPhysicalDeviceLimits::maxViewportDimensions is uint32_t, not float -> careful. - - const auto f_lte_u32_exact = [](const float v1_f, const uint32_t v2_u32) { - if (std::isnan(v1_f)) return false; - if (v1_f <= 0.0f) return true; - - float intpart; - const float fract = modff(v1_f, &intpart); - - assert(std::numeric_limits::radix == 2); - const float u32_max_plus1 = ldexpf(1.0f, 32); // hopefully exact - if (intpart >= u32_max_plus1) return false; - - uint32_t v1_u32 = static_cast(intpart); - if (v1_u32 < v2_u32) - return true; - else if (v1_u32 == v2_u32 && fract == 0.0f) - return true; - else - return false; - }; - - const auto f_lte_u32_direct = [](const float v1_f, const uint32_t v2_u32) { - const float v2_f = static_cast(v2_u32); // not accurate for > radix^digits; and undefined rounding mode - return (v1_f <= v2_f); - }; - - // width - bool width_healthy = true; - const auto max_w = device_data->device_limits.maxViewportDimensions[0]; - - if (!(viewport.width > 0.0f)) { - width_healthy = false; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000dd4, - "%s: %s.width (=%f) is not greater than 0.0.", fn_name, param_name, viewport.width); - } else if (!(f_lte_u32_exact(viewport.width, max_w) || f_lte_u32_direct(viewport.width, max_w))) { - width_healthy = false; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000dd6, - "%s: %s.width (=%f) exceeds VkPhysicalDeviceLimits::maxViewportDimensions[0] (=%" PRIu32 ").", fn_name, - param_name, viewport.width, max_w); - } else if (!f_lte_u32_exact(viewport.width, max_w) && f_lte_u32_direct(viewport.width, max_w)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, object_type, object, NONE, - "%s: %s.width (=%f) technically exceeds VkPhysicalDeviceLimits::maxViewportDimensions[0] (=%" PRIu32 - "), but it is within the static_cast(maxViewportDimensions[0]) limit.", - fn_name, param_name, viewport.width, max_w); - } - - // height - bool height_healthy = true; - const bool negative_height_enabled = device_data->api_version >= VK_API_VERSION_1_1 || - device_data->extensions.vk_khr_maintenance1 || - device_data->extensions.vk_amd_negative_viewport_height; - const auto max_h = device_data->device_limits.maxViewportDimensions[1]; - - if (!negative_height_enabled && !(viewport.height > 0.0f)) { - height_healthy = false; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000dd8, - "%s: %s.height (=%f) is not greater 0.0.", fn_name, param_name, viewport.height); - } else if (!(f_lte_u32_exact(fabsf(viewport.height), max_h) || f_lte_u32_direct(fabsf(viewport.height), max_h))) { - height_healthy = false; - - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000dda, - "%s: Absolute value of %s.height (=%f) exceeds VkPhysicalDeviceLimits::maxViewportDimensions[1] (=%" PRIu32 - ").", - fn_name, param_name, viewport.height, max_h); - } else if (!f_lte_u32_exact(fabsf(viewport.height), max_h) && f_lte_u32_direct(fabsf(viewport.height), max_h)) { - height_healthy = false; - - skip |= log_msg( - report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, object_type, object, NONE, - "%s: Absolute value of %s.height (=%f) technically exceeds VkPhysicalDeviceLimits::maxViewportDimensions[1] (=%" PRIu32 - "), but it is within the static_cast(maxViewportDimensions[1]) limit.", - fn_name, param_name, viewport.height, max_h); - } - - // x - bool x_healthy = true; - if (!(viewport.x >= device_data->device_limits.viewportBoundsRange[0])) { - x_healthy = false; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000ddc, - "%s: %s.x (=%f) is less than VkPhysicalDeviceLimits::viewportBoundsRange[0] (=%f).", fn_name, param_name, - viewport.x, device_data->device_limits.viewportBoundsRange[0]); - } - - // x + width - if (x_healthy && width_healthy) { - const float right_bound = viewport.x + viewport.width; - if (!(right_bound <= device_data->device_limits.viewportBoundsRange[1])) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_150009a0, - "%s: %s.x + %s.width (=%f + %f = %f) is greater than VkPhysicalDeviceLimits::viewportBoundsRange[1] (=%f).", - fn_name, param_name, param_name, viewport.x, viewport.width, right_bound, - device_data->device_limits.viewportBoundsRange[1]); - } - } - - // y - bool y_healthy = true; - if (!(viewport.y >= device_data->device_limits.viewportBoundsRange[0])) { - y_healthy = false; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000dde, - "%s: %s.y (=%f) is less than VkPhysicalDeviceLimits::viewportBoundsRange[0] (=%f).", fn_name, param_name, - viewport.y, device_data->device_limits.viewportBoundsRange[0]); - } else if (negative_height_enabled && !(viewport.y <= device_data->device_limits.viewportBoundsRange[1])) { - y_healthy = false; - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000de0, - "%s: %s.y (=%f) exceeds VkPhysicalDeviceLimits::viewportBoundsRange[1] (=%f).", fn_name, param_name, - viewport.y, device_data->device_limits.viewportBoundsRange[1]); - } - - // y + height - if (y_healthy && height_healthy) { - const float boundary = viewport.y + viewport.height; - - if (!(boundary <= device_data->device_limits.viewportBoundsRange[1])) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_150009a2, - "%s: %s.y + %s.height (=%f + %f = %f) exceeds VkPhysicalDeviceLimits::viewportBoundsRange[1] (=%f).", - fn_name, param_name, param_name, viewport.y, viewport.height, boundary, - device_data->device_limits.viewportBoundsRange[1]); - } else if (negative_height_enabled && !(boundary >= device_data->device_limits.viewportBoundsRange[0])) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_15000de2, - "%s: %s.y + %s.height (=%f + %f = %f) is less than VkPhysicalDeviceLimits::viewportBoundsRange[0] (=%f).", fn_name, - param_name, param_name, viewport.y, viewport.height, boundary, device_data->device_limits.viewportBoundsRange[0]); - } - } - - if (!device_data->extensions.vk_ext_depth_range_unrestricted) { - // minDepth - if (!(viewport.minDepth >= 0.0) || !(viewport.minDepth <= 1.0)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_150009a4, - - "%s: VK_EXT_depth_range_unrestricted extension is not enabled and %s.minDepth (=%f) is not within the " - "[0.0, 1.0] range.", - fn_name, param_name, viewport.minDepth); - } - - // maxDepth - if (!(viewport.maxDepth >= 0.0) || !(viewport.maxDepth <= 1.0)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, VALIDATION_ERROR_150009a6, - - "%s: VK_EXT_depth_range_unrestricted extension is not enabled and %s.maxDepth (=%f) is not within the " - "[0.0, 1.0] range.", - fn_name, param_name, viewport.maxDepth); - } - } - - return skip; -} - -bool pv_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, - VkPipeline *pPipelines) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - if (pCreateInfos != nullptr) { - for (uint32_t i = 0; i < createInfoCount; ++i) { - bool has_dynamic_viewport = false; - bool has_dynamic_scissor = false; - bool has_dynamic_line_width = false; - bool has_dynamic_viewport_w_scaling_nv = false; - bool has_dynamic_discard_rectangle_ext = false; - bool has_dynamic_sample_locations_ext = false; - if (pCreateInfos[i].pDynamicState != nullptr) { - const auto &dynamic_state_info = *pCreateInfos[i].pDynamicState; - for (uint32_t state_index = 0; state_index < dynamic_state_info.dynamicStateCount; ++state_index) { - const auto &dynamic_state = dynamic_state_info.pDynamicStates[state_index]; - if (dynamic_state == VK_DYNAMIC_STATE_VIEWPORT) has_dynamic_viewport = true; - if (dynamic_state == VK_DYNAMIC_STATE_SCISSOR) has_dynamic_scissor = true; - if (dynamic_state == VK_DYNAMIC_STATE_LINE_WIDTH) has_dynamic_line_width = true; - if (dynamic_state == VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV) has_dynamic_viewport_w_scaling_nv = true; - if (dynamic_state == VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT) has_dynamic_discard_rectangle_ext = true; - if (dynamic_state == VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT) has_dynamic_sample_locations_ext = true; - } - } - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - if (pCreateInfos[i].pVertexInputState != nullptr) { - auto const &vertex_input_state = pCreateInfos[i].pVertexInputState; - for (uint32_t d = 0; d < vertex_input_state->vertexBindingDescriptionCount; ++d) { - auto const &vertex_bind_desc = vertex_input_state->pVertexBindingDescriptions[d]; - if (vertex_bind_desc.binding >= device_data->device_limits.maxVertexInputBindings) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_14c004d4, - "vkCreateGraphicsPipelines: parameter " - "pCreateInfos[%u].pVertexInputState->pVertexBindingDescriptions[%u].binding (%u) is " - "greater than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings (%u).", - i, d, vertex_bind_desc.binding, device_data->device_limits.maxVertexInputBindings); - } - - if (vertex_bind_desc.stride > device_data->device_limits.maxVertexInputBindingStride) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_14c004d6, - "vkCreateGraphicsPipelines: parameter " - "pCreateInfos[%u].pVertexInputState->pVertexBindingDescriptions[%u].stride (%u) is greater " - "than VkPhysicalDeviceLimits::maxVertexInputBindingStride (%u).", - i, d, vertex_bind_desc.stride, device_data->device_limits.maxVertexInputBindingStride); - } - } - - for (uint32_t d = 0; d < vertex_input_state->vertexAttributeDescriptionCount; ++d) { - auto const &vertex_attrib_desc = vertex_input_state->pVertexAttributeDescriptions[d]; - if (vertex_attrib_desc.location >= device_data->device_limits.maxVertexInputAttributes) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_14a004d8, - "vkCreateGraphicsPipelines: parameter " - "pCreateInfos[%u].pVertexInputState->pVertexAttributeDescriptions[%u].location (%u) is " - "greater than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes (%u).", - i, d, vertex_attrib_desc.location, device_data->device_limits.maxVertexInputAttributes); - } - - if (vertex_attrib_desc.binding >= device_data->device_limits.maxVertexInputBindings) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_14a004da, - "vkCreateGraphicsPipelines: parameter " - "pCreateInfos[%u].pVertexInputState->pVertexAttributeDescriptions[%u].binding (%u) is " - "greater than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings (%u).", - i, d, vertex_attrib_desc.binding, device_data->device_limits.maxVertexInputBindings); - } - - if (vertex_attrib_desc.offset > device_data->device_limits.maxVertexInputAttributeOffset) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_14a004dc, - "vkCreateGraphicsPipelines: parameter " - "pCreateInfos[%u].pVertexInputState->pVertexAttributeDescriptions[%u].offset (%u) is " - "greater than VkPhysicalDeviceLimits::maxVertexInputAttributeOffset (%u).", - i, d, vertex_attrib_desc.offset, device_data->device_limits.maxVertexInputAttributeOffset); - } - } - } - - if (pCreateInfos[i].pStages != nullptr) { - bool has_control = false; - bool has_eval = false; - - for (uint32_t stage_index = 0; stage_index < pCreateInfos[i].stageCount; ++stage_index) { - if (pCreateInfos[i].pStages[stage_index].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) { - has_control = true; - } else if (pCreateInfos[i].pStages[stage_index].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) { - has_eval = true; - } - } - - // pTessellationState is ignored without both tessellation control and tessellation evaluation shaders stages - if (has_control && has_eval) { - if (pCreateInfos[i].pTessellationState == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_096005b6, - "vkCreateGraphicsPipelines: if pCreateInfos[%d].pStages includes a tessellation control " - "shader stage and a tessellation evaluation shader stage, " - "pCreateInfos[%d].pTessellationState must not be NULL.", - i, i); - } else { - skip |= validate_struct_pnext( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pTessellationState->pNext", ParameterName::IndexVector{i}), NULL, - pCreateInfos[i].pTessellationState->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0961c40d); - - skip |= validate_reserved_flags( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pTessellationState->flags", ParameterName::IndexVector{i}), - pCreateInfos[i].pTessellationState->flags, VALIDATION_ERROR_10809005); - - if (pCreateInfos[i].pTessellationState->sType != - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1082b00b, - "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pTessellationState->sType must " - "be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO.", - i); - } - - if (pCreateInfos[i].pTessellationState->patchControlPoints == 0 || - pCreateInfos[i].pTessellationState->patchControlPoints > - device_data->device_limits.maxTessellationPatchSize) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1080097c, - "vkCreateGraphicsPipelines: invalid parameter " - "pCreateInfos[%d].pTessellationState->patchControlPoints value %u. patchControlPoints " - "should be >0 and <=%u.", - i, pCreateInfos[i].pTessellationState->patchControlPoints, - device_data->device_limits.maxTessellationPatchSize); - } - } - } - } - - // pViewportState, pMultisampleState, pDepthStencilState, and pColorBlendState ignored when rasterization is disabled - if ((pCreateInfos[i].pRasterizationState != nullptr) && - (pCreateInfos[i].pRasterizationState->rasterizerDiscardEnable == VK_FALSE)) { - if (pCreateInfos[i].pViewportState == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_096005dc, - "vkCreateGraphicsPipelines: Rasterization is enabled (pCreateInfos[%" PRIu32 - "].pRasterizationState->rasterizerDiscardEnable is VK_FALSE), but pCreateInfos[%" PRIu32 - "].pViewportState (=NULL) is not a valid pointer.", - i, i); - } else { - const auto &viewport_state = *pCreateInfos[i].pViewportState; - - if (viewport_state.sType != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c2b00b, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 - "].pViewportState->sType is not VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO.", - i); - } - - const VkStructureType allowed_structs_VkPipelineViewportStateCreateInfo[] = { - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV}; - skip |= validate_struct_pnext( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pViewportState->pNext", ParameterName::IndexVector{i}), - "VkPipelineViewportSwizzleStateCreateInfoNV, VkPipelineViewportWScalingStateCreateInfoNV", - viewport_state.pNext, ARRAY_SIZE(allowed_structs_VkPipelineViewportStateCreateInfo), - allowed_structs_VkPipelineViewportStateCreateInfo, 65, VALIDATION_ERROR_10c1c40d); - - skip |= validate_reserved_flags( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pViewportState->flags", ParameterName::IndexVector{i}), - viewport_state.flags, VALIDATION_ERROR_10c09005); - - if (!device_data->physical_device_features.multiViewport) { - if (viewport_state.viewportCount != 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c00980, - "vkCreateGraphicsPipelines: The VkPhysicalDeviceFeatures::multiViewport feature is " - "disabled, but pCreateInfos[%" PRIu32 "].pViewportState->viewportCount (=%" PRIu32 - ") is not 1.", - i, viewport_state.viewportCount); - } - - if (viewport_state.scissorCount != 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c00982, - "vkCreateGraphicsPipelines: The VkPhysicalDeviceFeatures::multiViewport feature is " - "disabled, but pCreateInfos[%" PRIu32 "].pViewportState->scissorCount (=%" PRIu32 - ") is not 1.", - i, viewport_state.scissorCount); - } - } else { // multiViewport enabled - if (viewport_state.viewportCount == 0) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c30a1b, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "].pViewportState->viewportCount is 0.", i); - } else if (viewport_state.viewportCount > device_data->device_limits.maxViewports) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c00984, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 - "].pViewportState->viewportCount (=%" PRIu32 - ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").", - i, viewport_state.viewportCount, device_data->device_limits.maxViewports); - } - - if (viewport_state.scissorCount == 0) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c2b61b, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "].pViewportState->scissorCount is 0.", i); - } else if (viewport_state.scissorCount > device_data->device_limits.maxViewports) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c00986, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 - "].pViewportState->scissorCount (=%" PRIu32 - ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").", - i, viewport_state.scissorCount, device_data->device_limits.maxViewports); - } - } - - if (viewport_state.scissorCount != viewport_state.viewportCount) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_10c00988, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "].pViewportState->scissorCount (=%" PRIu32 - ") is not identical to pCreateInfos[%" PRIu32 "].pViewportState->viewportCount (=%" PRIu32 ").", - i, viewport_state.scissorCount, i, viewport_state.viewportCount); - } - - if (!has_dynamic_viewport && viewport_state.viewportCount > 0 && viewport_state.pViewports == nullptr) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE, - VALIDATION_ERROR_096005d6, - "vkCreateGraphicsPipelines: The viewport state is static (pCreateInfos[%" PRIu32 - "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_VIEWPORT), but pCreateInfos[%" PRIu32 - "].pViewportState->pViewports (=NULL) is an invalid pointer.", - i, i); - } - - if (!has_dynamic_scissor && viewport_state.scissorCount > 0 && viewport_state.pScissors == nullptr) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE, - VALIDATION_ERROR_096005d8, - "vkCreateGraphicsPipelines: The scissor state is static (pCreateInfos[%" PRIu32 - "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_SCISSOR), but pCreateInfos[%" PRIu32 - "].pViewportState->pScissors (=NULL) is an invalid pointer.", - i, i); - } - - // validate the VkViewports - if (!has_dynamic_viewport && viewport_state.pViewports) { - for (uint32_t viewport_i = 0; viewport_i < viewport_state.viewportCount; ++viewport_i) { - const auto &viewport = viewport_state.pViewports[viewport_i]; // will crash on invalid ptr - const char fn_name[] = "vkCreateGraphicsPipelines"; - const std::string param_name = "pCreateInfos[" + std::to_string(i) + "].pViewportState->pViewports[" + - std::to_string(viewport_i) + "]"; - skip |= pv_VkViewport(device_data, viewport, fn_name, param_name.c_str(), - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT); - } - } - - if (has_dynamic_viewport_w_scaling_nv && !device_data->extensions.vk_nv_clip_space_w_scaling) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, EXTENSION_NOT_ENABLED, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 - "].pDynamicState->pDynamicStates contains VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, but " - "VK_NV_clip_space_w_scaling extension is not enabled.", - i); - } - - if (has_dynamic_discard_rectangle_ext && !device_data->extensions.vk_ext_discard_rectangles) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, EXTENSION_NOT_ENABLED, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 - "].pDynamicState->pDynamicStates contains VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, but " - "VK_EXT_discard_rectangles extension is not enabled.", - i); - } - - if (has_dynamic_sample_locations_ext && !device_data->extensions.vk_ext_sample_locations) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - VK_NULL_HANDLE, EXTENSION_NOT_ENABLED, - "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 - "].pDynamicState->pDynamicStates contains VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, but " - "VK_EXT_sample_locations extension is not enabled.", - i); - } - } - - if (pCreateInfos[i].pMultisampleState == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_096005de, - "vkCreateGraphicsPipelines: if pCreateInfos[%d].pRasterizationState->rasterizerDiscardEnable " - "is VK_FALSE, pCreateInfos[%d].pMultisampleState must not be NULL.", - i, i); - } else { - const VkStructureType valid_next_stypes[] = {LvlTypeMap::kSType, - LvlTypeMap::kSType, - LvlTypeMap::kSType}; - const char *valid_struct_names = - "VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, " - "VkPipelineSampleLocationsStateCreateInfoEXT"; - skip |= validate_struct_pnext( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pMultisampleState->pNext", ParameterName::IndexVector{i}), - valid_struct_names, pCreateInfos[i].pMultisampleState->pNext, 3, valid_next_stypes, GeneratedHeaderVersion, - VALIDATION_ERROR_1001c40d); - - skip |= validate_reserved_flags( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pMultisampleState->flags", ParameterName::IndexVector{i}), - pCreateInfos[i].pMultisampleState->flags, VALIDATION_ERROR_10009005); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pMultisampleState->sampleShadingEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pMultisampleState->sampleShadingEnable); - - skip |= validate_array( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pMultisampleState->rasterizationSamples", ParameterName::IndexVector{i}), - ParameterName("pCreateInfos[%i].pMultisampleState->pSampleMask", ParameterName::IndexVector{i}), - pCreateInfos[i].pMultisampleState->rasterizationSamples, &pCreateInfos[i].pMultisampleState->pSampleMask, - true, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pMultisampleState->alphaToCoverageEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pMultisampleState->alphaToCoverageEnable); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pMultisampleState->alphaToOneEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pMultisampleState->alphaToOneEnable); - - if (pCreateInfos[i].pMultisampleState->sType != VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_STRUCT_STYPE, - "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pMultisampleState->sType must be " - "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO", - i); - } - if (pCreateInfos[i].pMultisampleState->sampleShadingEnable == VK_TRUE) { - if (!device_data->physical_device_features.sampleRateShading) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_10000620, - "vkCreateGraphicsPipelines(): parameter " - "pCreateInfos[%d].pMultisampleState->sampleShadingEnable.", - i); - } - // TODO Add documentation issue about when minSampleShading must be in range and when it is ignored - // For now a "least noise" test *only* when sampleShadingEnable is VK_TRUE. - if (!in_inclusive_range(pCreateInfos[i].pMultisampleState->minSampleShading, 0.F, 1.0F)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_10000624, - "vkCreateGraphicsPipelines(): parameter pCreateInfos[%d].pMultisampleState->minSampleShading.", i); - } - } - } - - bool uses_color_attachment = false; - bool uses_depthstencil_attachment = false; - { - const auto subpasses_uses_it = device_data->renderpasses_states.find(pCreateInfos[i].renderPass); - if (subpasses_uses_it != device_data->renderpasses_states.end()) { - const auto &subpasses_uses = subpasses_uses_it->second; - if (subpasses_uses.subpasses_using_color_attachment.count(pCreateInfos[i].subpass)) - uses_color_attachment = true; - if (subpasses_uses.subpasses_using_depthstencil_attachment.count(pCreateInfos[i].subpass)) - uses_depthstencil_attachment = true; - } - } - - if (pCreateInfos[i].pDepthStencilState != nullptr && uses_depthstencil_attachment) { - skip |= validate_struct_pnext( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->pNext", ParameterName::IndexVector{i}), NULL, - pCreateInfos[i].pDepthStencilState->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0f61c40d); - - skip |= validate_reserved_flags( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->flags", ParameterName::IndexVector{i}), - pCreateInfos[i].pDepthStencilState->flags, VALIDATION_ERROR_0f609005); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->depthTestEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pDepthStencilState->depthTestEnable); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->depthWriteEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pDepthStencilState->depthWriteEnable); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->depthCompareOp", ParameterName::IndexVector{i}), - "VkCompareOp", AllVkCompareOpEnums, pCreateInfos[i].pDepthStencilState->depthCompareOp, - VALIDATION_ERROR_0f604001); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->depthBoundsTestEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pDepthStencilState->depthBoundsTestEnable); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->stencilTestEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pDepthStencilState->stencilTestEnable); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->front.failOp", ParameterName::IndexVector{i}), - "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->front.failOp, - VALIDATION_ERROR_13a08601); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->front.passOp", ParameterName::IndexVector{i}), - "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->front.passOp, - VALIDATION_ERROR_13a27801); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->front.depthFailOp", ParameterName::IndexVector{i}), - "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->front.depthFailOp, - VALIDATION_ERROR_13a04201); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->front.compareOp", ParameterName::IndexVector{i}), - "VkCompareOp", AllVkCompareOpEnums, pCreateInfos[i].pDepthStencilState->front.compareOp, - VALIDATION_ERROR_0f604001); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->back.failOp", ParameterName::IndexVector{i}), - "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->back.failOp, - VALIDATION_ERROR_13a08601); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->back.passOp", ParameterName::IndexVector{i}), - "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->back.passOp, - VALIDATION_ERROR_13a27801); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->back.depthFailOp", ParameterName::IndexVector{i}), - "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->back.depthFailOp, - VALIDATION_ERROR_13a04201); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pDepthStencilState->back.compareOp", ParameterName::IndexVector{i}), - "VkCompareOp", AllVkCompareOpEnums, pCreateInfos[i].pDepthStencilState->back.compareOp, - VALIDATION_ERROR_0f604001); - - if (pCreateInfos[i].pDepthStencilState->sType != VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_STRUCT_STYPE, - "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pDepthStencilState->sType must be " - "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO", - i); - } - } - - if (pCreateInfos[i].pColorBlendState != nullptr && uses_color_attachment) { - skip |= validate_struct_pnext( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pNext", ParameterName::IndexVector{i}), NULL, - pCreateInfos[i].pColorBlendState->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0f41c40d); - - skip |= validate_reserved_flags( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->flags", ParameterName::IndexVector{i}), - pCreateInfos[i].pColorBlendState->flags, VALIDATION_ERROR_0f409005); - - skip |= validate_bool32( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->logicOpEnable", ParameterName::IndexVector{i}), - pCreateInfos[i].pColorBlendState->logicOpEnable); - - skip |= validate_array( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->attachmentCount", ParameterName::IndexVector{i}), - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments", ParameterName::IndexVector{i}), - pCreateInfos[i].pColorBlendState->attachmentCount, &pCreateInfos[i].pColorBlendState->pAttachments, false, - true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - - if (pCreateInfos[i].pColorBlendState->pAttachments != NULL) { - for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfos[i].pColorBlendState->attachmentCount; - ++attachmentIndex) { - skip |= validate_bool32(report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].blendEnable", - ParameterName::IndexVector{i, attachmentIndex}), - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].blendEnable); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].srcColorBlendFactor", - ParameterName::IndexVector{i, attachmentIndex}), - "VkBlendFactor", AllVkBlendFactorEnums, - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].srcColorBlendFactor, - VALIDATION_ERROR_0f22cc01); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].dstColorBlendFactor", - ParameterName::IndexVector{i, attachmentIndex}), - "VkBlendFactor", AllVkBlendFactorEnums, - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].dstColorBlendFactor, - VALIDATION_ERROR_0f207001); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].colorBlendOp", - ParameterName::IndexVector{i, attachmentIndex}), - "VkBlendOp", AllVkBlendOpEnums, - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].colorBlendOp, - VALIDATION_ERROR_0f202001); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].srcAlphaBlendFactor", - ParameterName::IndexVector{i, attachmentIndex}), - "VkBlendFactor", AllVkBlendFactorEnums, - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].srcAlphaBlendFactor, - VALIDATION_ERROR_0f22c601); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].dstAlphaBlendFactor", - ParameterName::IndexVector{i, attachmentIndex}), - "VkBlendFactor", AllVkBlendFactorEnums, - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].dstAlphaBlendFactor, - VALIDATION_ERROR_0f206a01); - - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].alphaBlendOp", - ParameterName::IndexVector{i, attachmentIndex}), - "VkBlendOp", AllVkBlendOpEnums, - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].alphaBlendOp, - VALIDATION_ERROR_0f200801); - - skip |= - validate_flags(report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].colorWriteMask", - ParameterName::IndexVector{i, attachmentIndex}), - "VkColorComponentFlagBits", AllVkColorComponentFlagBits, - pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].colorWriteMask, - false, false, VALIDATION_ERROR_0f202201); - } - } - - if (pCreateInfos[i].pColorBlendState->sType != VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_STRUCT_STYPE, - "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pColorBlendState->sType must be " - "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO", - i); - } - - // If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value - if (pCreateInfos[i].pColorBlendState->logicOpEnable == VK_TRUE) { - skip |= validate_ranged_enum( - report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pColorBlendState->logicOp", ParameterName::IndexVector{i}), "VkLogicOp", - AllVkLogicOpEnums, pCreateInfos[i].pColorBlendState->logicOp, VALIDATION_ERROR_0f4004be); - } - } - } - - if (pCreateInfos[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) { - if (pCreateInfos[i].basePipelineIndex != -1) { - if (pCreateInfos[i].basePipelineHandle != VK_NULL_HANDLE) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_096005a8, - "vkCreateGraphicsPipelines parameter, pCreateInfos->basePipelineHandle, must be " - "VK_NULL_HANDLE if pCreateInfos->flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag " - "and pCreateInfos->basePipelineIndex is not -1."); - } - } - - if (pCreateInfos[i].basePipelineHandle != VK_NULL_HANDLE) { - if (pCreateInfos[i].basePipelineIndex != -1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_096005aa, - "vkCreateGraphicsPipelines parameter, pCreateInfos->basePipelineIndex, must be -1 if " - "pCreateInfos->flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag and " - "pCreateInfos->basePipelineHandle is not VK_NULL_HANDLE."); - } - } - } - - if (pCreateInfos[i].pRasterizationState) { - if ((pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL) && - (device_data->physical_device_features.fillModeNonSolid == false)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DEVICE_FEATURE, - "vkCreateGraphicsPipelines parameter, VkPolygonMode " - "pCreateInfos->pRasterizationState->polygonMode cannot be VK_POLYGON_MODE_POINT or " - "VK_POLYGON_MODE_LINE if VkPhysicalDeviceFeatures->fillModeNonSolid is false."); - } - - if (!has_dynamic_line_width && !device_data->physical_device_features.wideLines && - (pCreateInfos[i].pRasterizationState->lineWidth != 1.0f)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, 0, VALIDATION_ERROR_096005da, - "The line width state is static (pCreateInfos[%" PRIu32 - "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_LINE_WIDTH) and " - "VkPhysicalDeviceFeatures::wideLines is disabled, but pCreateInfos[%" PRIu32 - "].pRasterizationState->lineWidth (=%f) is not 1.0.", - i, i, pCreateInfos[i].pRasterizationState->lineWidth); - } - } - - for (size_t j = 0; j < pCreateInfos[i].stageCount; j++) { - skip |= validate_string(device_data->report_data, "vkCreateGraphicsPipelines", - ParameterName("pCreateInfos[%i].pStages[%i].pName", ParameterName::IndexVector{i, j}), - pCreateInfos[i].pStages[j].pName); - } - } - } - - return skip; -} - -bool pv_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, - const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, - VkPipeline *pPipelines) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - for (uint32_t i = 0; i < createInfoCount; i++) { - skip |= validate_string(device_data->report_data, "vkCreateComputePipelines", - ParameterName("pCreateInfos[%i].stage.pName", ParameterName::IndexVector{i}), - pCreateInfos[i].stage.pName); - } - - return skip; -} - -bool pv_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkSampler *pSampler) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - if (pCreateInfo != nullptr) { - const auto &features = device_data->physical_device_features; - const auto &limits = device_data->device_limits; - if (pCreateInfo->anisotropyEnable == VK_TRUE) { - if (!in_inclusive_range(pCreateInfo->maxAnisotropy, 1.0F, limits.maxSamplerAnisotropy)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1260085e, - "vkCreateSampler(): value of %s must be in range [1.0, %f] %s, but %f found.", - "pCreateInfo->maxAnisotropy", limits.maxSamplerAnisotropy, - "VkPhysicalDeviceLimits::maxSamplerAnistropy", pCreateInfo->maxAnisotropy); - } - - // Anistropy cannot be enabled in sampler unless enabled as a feature - if (features.samplerAnisotropy == VK_FALSE) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1260085c, - "vkCreateSampler(): Anisotropic sampling feature is not enabled, %s must be VK_FALSE.", - "pCreateInfo->anisotropyEnable"); - } - - // Anistropy and unnormalized coordinates cannot be enabled simultaneously - if (pCreateInfo->unnormalizedCoordinates == VK_TRUE) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_12600868, - "vkCreateSampler(): pCreateInfo->anisotropyEnable and pCreateInfo->unnormalizedCoordinates must " - "not both be VK_TRUE."); - } - } - - // If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value - if (pCreateInfo->compareEnable == VK_TRUE) { - skip |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->compareOp", "VkCompareOp", - AllVkCompareOpEnums, pCreateInfo->compareOp, VALIDATION_ERROR_12600870); - } - - // If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a - // valid VkBorderColor value - if ((pCreateInfo->addressModeU == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) || - (pCreateInfo->addressModeV == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) || - (pCreateInfo->addressModeW == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)) { - skip |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->borderColor", "VkBorderColor", - AllVkBorderColorEnums, pCreateInfo->borderColor, VALIDATION_ERROR_1260086c); - } - - // If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, the - // VK_KHR_sampler_mirror_clamp_to_edge extension must be enabled - if (!device_data->extensions.vk_khr_sampler_mirror_clamp_to_edge && - ((pCreateInfo->addressModeU == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE) || - (pCreateInfo->addressModeV == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE) || - (pCreateInfo->addressModeW == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE))) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, VALIDATION_ERROR_1260086e, - "vkCreateSampler(): A VkSamplerAddressMode value is set to VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE " - "but the VK_KHR_sampler_mirror_clamp_to_edge extension has not been enabled."); - } - - // Checks for the IMG cubic filtering extension - if (device_data->extensions.vk_img_filter_cubic) { - if ((pCreateInfo->anisotropyEnable == VK_TRUE) && - ((pCreateInfo->minFilter == VK_FILTER_CUBIC_IMG) || (pCreateInfo->magFilter == VK_FILTER_CUBIC_IMG))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_12600872, - "vkCreateSampler(): Anisotropic sampling must not be VK_TRUE when either minFilter or magFilter " - "are VK_FILTER_CUBIC_IMG."); - } - } - } - - return skip; -} - -bool pv_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - if ((pCreateInfo != nullptr) && (pCreateInfo->pBindings != nullptr)) { - for (uint32_t i = 0; i < pCreateInfo->bindingCount; ++i) { - if (pCreateInfo->pBindings[i].descriptorCount != 0) { - // If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount - // is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a pointer to an array of descriptorCount - // valid VkSampler handles - if (((pCreateInfo->pBindings[i].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || - (pCreateInfo->pBindings[i].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) && - (pCreateInfo->pBindings[i].pImmutableSamplers != nullptr)) { - for (uint32_t descriptor_index = 0; descriptor_index < pCreateInfo->pBindings[i].descriptorCount; - ++descriptor_index) { - if (pCreateInfo->pBindings[i].pImmutableSamplers[descriptor_index] == VK_NULL_HANDLE) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - REQUIRED_PARAMETER, - "vkCreateDescriptorSetLayout: required parameter " - "pCreateInfo->pBindings[%d].pImmutableSamplers[%d] specified as VK_NULL_HANDLE", - i, descriptor_index); - } - } - } - - // If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values - if ((pCreateInfo->pBindings[i].stageFlags != 0) && - ((pCreateInfo->pBindings[i].stageFlags & (~AllVkShaderStageFlagBits)) != 0)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_04e00236, - "vkCreateDescriptorSetLayout(): if pCreateInfo->pBindings[%d].descriptorCount is not 0, " - "pCreateInfo->pBindings[%d].stageFlags must be a valid combination of VkShaderStageFlagBits " - "values.", - i, i); - } - } - } - } - - return skip; -} - -bool pv_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, - const VkDescriptorSet *pDescriptorSets) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond - // validate_array() - skip |= validate_array(report_data, "vkFreeDescriptorSets", "descriptorSetCount", "pDescriptorSets", descriptorSetCount, - &pDescriptorSets, true, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - return skip; -} - -bool pv_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, - uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - if (pDescriptorWrites != NULL) { - for (uint32_t i = 0; i < descriptorWriteCount; ++i) { - // descriptorCount must be greater than 0 - if (pDescriptorWrites[i].descriptorCount == 0) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_15c0441b, - "vkUpdateDescriptorSets(): parameter pDescriptorWrites[%d].descriptorCount must be greater than 0.", i); - } - - // dstSet must be a valid VkDescriptorSet handle - skip |= validate_required_handle(report_data, "vkUpdateDescriptorSets", - ParameterName("pDescriptorWrites[%i].dstSet", ParameterName::IndexVector{i}), - pDescriptorWrites[i].dstSet); - - if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) { - // If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - // VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, - // pImageInfo must be a pointer to an array of descriptorCount valid VkDescriptorImageInfo structures - if (pDescriptorWrites[i].pImageInfo == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_15c00284, - "vkUpdateDescriptorSets(): if pDescriptorWrites[%d].descriptorType is " - "VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, " - "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or " - "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pDescriptorWrites[%d].pImageInfo must not be NULL.", - i, i); - } else if (pDescriptorWrites[i].descriptorType != VK_DESCRIPTOR_TYPE_SAMPLER) { - // If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, - // VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView and imageLayout - // members of any given element of pImageInfo must be a valid VkImageView and VkImageLayout, respectively - for (uint32_t descriptor_index = 0; descriptor_index < pDescriptorWrites[i].descriptorCount; - ++descriptor_index) { - skip |= validate_required_handle(report_data, "vkUpdateDescriptorSets", - ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageView", - ParameterName::IndexVector{i, descriptor_index}), - pDescriptorWrites[i].pImageInfo[descriptor_index].imageView); - skip |= validate_ranged_enum(report_data, "vkUpdateDescriptorSets", - ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageLayout", - ParameterName::IndexVector{i, descriptor_index}), - "VkImageLayout", AllVkImageLayoutEnums, - pDescriptorWrites[i].pImageInfo[descriptor_index].imageLayout, - VALIDATION_ERROR_UNDEFINED); - } - } - } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { - // If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - // VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a - // pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures - if (pDescriptorWrites[i].pBufferInfo == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_15c00288, - "vkUpdateDescriptorSets(): if pDescriptorWrites[%d].descriptorType is " - "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, " - "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, " - "pDescriptorWrites[%d].pBufferInfo must not be NULL.", - i, i); - } else { - for (uint32_t descriptorIndex = 0; descriptorIndex < pDescriptorWrites[i].descriptorCount; ++descriptorIndex) { - skip |= validate_required_handle(report_data, "vkUpdateDescriptorSets", - ParameterName("pDescriptorWrites[%i].pBufferInfo[%i].buffer", - ParameterName::IndexVector{i, descriptorIndex}), - pDescriptorWrites[i].pBufferInfo[descriptorIndex].buffer); - } - } - } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) { - // If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, - // pTexelBufferView must be a pointer to an array of descriptorCount valid VkBufferView handles - if (pDescriptorWrites[i].pTexelBufferView == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_15c00286, - "vkUpdateDescriptorSets(): if pDescriptorWrites[%d].descriptorType is " - "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, " - "pDescriptorWrites[%d].pTexelBufferView must not be NULL.", - i, i); - } else { - for (uint32_t descriptor_index = 0; descriptor_index < pDescriptorWrites[i].descriptorCount; - ++descriptor_index) { - skip |= validate_required_handle(report_data, "vkUpdateDescriptorSets", - ParameterName("pDescriptorWrites[%i].pTexelBufferView[%i]", - ParameterName::IndexVector{i, descriptor_index}), - pDescriptorWrites[i].pTexelBufferView[descriptor_index]); - } - } - } - - if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC)) { - VkDeviceSize uniformAlignment = device_data->device_limits.minUniformBufferOffsetAlignment; - for (uint32_t j = 0; j < pDescriptorWrites[i].descriptorCount; j++) { - if (pDescriptorWrites[i].pBufferInfo != NULL) { - if (SafeModulo(pDescriptorWrites[i].pBufferInfo[j].offset, uniformAlignment) != 0) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, VALIDATION_ERROR_15c0028e, - "vkUpdateDescriptorSets(): pDescriptorWrites[%d].pBufferInfo[%d].offset (0x%" PRIxLEAST64 - ") must be a multiple of device limit minUniformBufferOffsetAlignment 0x%" PRIxLEAST64 ".", - i, j, pDescriptorWrites[i].pBufferInfo[j].offset, uniformAlignment); - } - } - } - } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || - (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { - VkDeviceSize storageAlignment = device_data->device_limits.minStorageBufferOffsetAlignment; - for (uint32_t j = 0; j < pDescriptorWrites[i].descriptorCount; j++) { - if (pDescriptorWrites[i].pBufferInfo != NULL) { - if (SafeModulo(pDescriptorWrites[i].pBufferInfo[j].offset, storageAlignment) != 0) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, VALIDATION_ERROR_15c00290, - "vkUpdateDescriptorSets(): pDescriptorWrites[%d].pBufferInfo[%d].offset (0x%" PRIxLEAST64 - ") must be a multiple of device limit minStorageBufferOffsetAlignment 0x%" PRIxLEAST64 ".", - i, j, pDescriptorWrites[i].pBufferInfo[j].offset, storageAlignment); - } - } - } - } - } - } - return skip; -} - -bool pv_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkRenderPass *pRenderPass) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - uint32_t max_color_attachments = device_data->device_limits.maxColorAttachments; - - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - if (pCreateInfo->pAttachments[i].format == VK_FORMAT_UNDEFINED) { - std::stringstream ss; - ss << "vkCreateRenderPass: pCreateInfo->pAttachments[" << i << "].format is VK_FORMAT_UNDEFINED. "; - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_00809201, "%s", ss.str().c_str()); - } - if (pCreateInfo->pAttachments[i].finalLayout == VK_IMAGE_LAYOUT_UNDEFINED || - pCreateInfo->pAttachments[i].finalLayout == VK_IMAGE_LAYOUT_PREINITIALIZED) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_00800696, - "pCreateInfo->pAttachments[%d].finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or " - "VK_IMAGE_LAYOUT_PREINITIALIZED.", - i); - } - } - - for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { - if (pCreateInfo->pSubpasses[i].colorAttachmentCount > max_color_attachments) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1400069a, "Cannot create a render pass with %d color attachments. Max is %d.", - pCreateInfo->pSubpasses[i].colorAttachmentCount, max_color_attachments); - } - } - return skip; -} - -bool pv_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, - const VkCommandBuffer *pCommandBuffers) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond - // validate_array() - skip |= validate_array(report_data, "vkFreeCommandBuffers", "commandBufferCount", "pCommandBuffers", commandBufferCount, - &pCommandBuffers, true, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - return skip; -} - -bool pv_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - debug_report_data *report_data = device_data->report_data; - const VkCommandBufferInheritanceInfo *pInfo = pBeginInfo->pInheritanceInfo; - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - // TODO: pBeginInfo->pInheritanceInfo must not be NULL if commandBuffer is a secondary command buffer - skip |= validate_struct_type(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo", - "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", pBeginInfo->pInheritanceInfo, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, false, VALIDATION_ERROR_UNDEFINED); - - if (pBeginInfo->pInheritanceInfo != NULL) { - skip |= - validate_struct_pnext(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->pNext", NULL, - pBeginInfo->pInheritanceInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0281c40d); - - skip |= validate_bool32(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->occlusionQueryEnable", - pBeginInfo->pInheritanceInfo->occlusionQueryEnable); - - // TODO: This only needs to be validated when the inherited queries feature is enabled - // skip |= validate_flags(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->queryFlags", - // "VkQueryControlFlagBits", AllVkQueryControlFlagBits, pBeginInfo->pInheritanceInfo->queryFlags, false); - - // TODO: This must be 0 if the pipeline statistics queries feature is not enabled - skip |= validate_flags(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->pipelineStatistics", - "VkQueryPipelineStatisticFlagBits", AllVkQueryPipelineStatisticFlagBits, - pBeginInfo->pInheritanceInfo->pipelineStatistics, false, false, VALIDATION_ERROR_UNDEFINED); - } - - if (pInfo != NULL) { - if ((device_data->physical_device_features.inheritedQueries == VK_FALSE) && (pInfo->occlusionQueryEnable != VK_FALSE)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_02a00070, - "Cannot set inherited occlusionQueryEnable in vkBeginCommandBuffer() when device does not support " - "inheritedQueries."); - } - if ((device_data->physical_device_features.inheritedQueries != VK_FALSE) && (pInfo->occlusionQueryEnable != VK_FALSE)) { - skip |= validate_flags(device_data->report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->queryFlags", - "VkQueryControlFlagBits", AllVkQueryControlFlagBits, pInfo->queryFlags, false, false, - VALIDATION_ERROR_02a00072); - } - } - - return skip; -} - -bool pv_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, - const VkViewport *pViewports) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - if (!device_data->physical_device_features.multiViewport) { - if (firstViewport != 0) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1e000990, - "vkCmdSetViewport: The multiViewport feature is disabled, but firstViewport (=%" PRIu32 ") is not 0.", - firstViewport); - } - if (viewportCount > 1) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1e000992, - "vkCmdSetViewport: The multiViewport feature is disabled, but viewportCount (=%" PRIu32 ") is not 1.", - viewportCount); - } - } else { // multiViewport enabled - const uint64_t sum = static_cast(firstViewport) + static_cast(viewportCount); - if (sum > device_data->device_limits.maxViewports) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1e00098e, - "vkCmdSetViewport: firstViewport + viewportCount (=%" PRIu32 " + %" PRIu32 " = %" PRIu64 - ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").", - firstViewport, viewportCount, sum, device_data->device_limits.maxViewports); - } - } - - if (pViewports) { - for (uint32_t viewport_i = 0; viewport_i < viewportCount; ++viewport_i) { - const auto &viewport = pViewports[viewport_i]; // will crash on invalid ptr - const char fn_name[] = "vkCmdSetViewport"; - const std::string param_name = "pViewports[" + std::to_string(viewport_i) + "]"; - skip |= pv_VkViewport(device_data, viewport, fn_name, param_name.c_str(), - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer)); - } - } - - return skip; -} - -bool pv_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - if (!device_data->physical_device_features.multiViewport) { - if (firstScissor != 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d8004a2, - "vkCmdSetScissor: The multiViewport feature is disabled, but firstScissor (=%" PRIu32 ") is not 0.", - firstScissor); - } - if (scissorCount > 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d8004a4, - "vkCmdSetScissor: The multiViewport feature is disabled, but scissorCount (=%" PRIu32 ") is not 1.", - scissorCount); - } - } else { // multiViewport enabled - const uint64_t sum = static_cast(firstScissor) + static_cast(scissorCount); - if (sum > device_data->device_limits.maxViewports) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d8004a0, - "vkCmdSetScissor: firstScissor + scissorCount (=%" PRIu32 " + %" PRIu32 " = %" PRIu64 - ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").", - firstScissor, scissorCount, sum, device_data->device_limits.maxViewports); - } - } - - if (pScissors) { - for (uint32_t scissor_i = 0; scissor_i < scissorCount; ++scissor_i) { - const auto &scissor = pScissors[scissor_i]; // will crash on invalid ptr - - if (scissor.offset.x < 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d8004a6, - "vkCmdSetScissor: pScissors[%" PRIu32 "].offset.x (=%" PRIi32 ") is negative.", scissor_i, - scissor.offset.x); - } - - if (scissor.offset.y < 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d8004a6, - "vkCmdSetScissor: pScissors[%" PRIu32 "].offset.y (=%" PRIi32 ") is negative.", scissor_i, - scissor.offset.y); - } - - const int64_t x_sum = static_cast(scissor.offset.x) + static_cast(scissor.extent.width); - if (x_sum > INT32_MAX) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d8004a8, - "vkCmdSetScissor: offset.x + extent.width (=%" PRIi32 " + %" PRIu32 " = %" PRIi64 - ") of pScissors[%" PRIu32 "] will overflow int32_t.", - scissor.offset.x, scissor.extent.width, x_sum, scissor_i); - } - - const int64_t y_sum = static_cast(scissor.offset.y) + static_cast(scissor.extent.height); - if (y_sum > INT32_MAX) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d8004aa, - "vkCmdSetScissor: offset.y + extent.height (=%" PRIi32 " + %" PRIu32 " = %" PRIi64 - ") of pScissors[%" PRIu32 "] will overflow int32_t.", - scissor.offset.y, scissor.extent.height, y_sum, scissor_i); - } - } - } - - return skip; -} - -bool pv_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - if (!device_data->physical_device_features.wideLines && (lineWidth != 1.0f)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_1d600628, - "VkPhysicalDeviceFeatures::wideLines is disabled, but lineWidth (=%f) is not 1.0.", lineWidth); - } - - return skip; -} - -bool pv_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, - uint32_t firstInstance) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - if (vertexCount == 0) { - // TODO: Verify against Valid Usage section. I don't see a non-zero vertexCount listed, may need to add that and make - // this an error or leave as is. - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - REQUIRED_PARAMETER, "vkCmdDraw parameter, uint32_t vertexCount, is 0"); - } - - if (instanceCount == 0) { - // TODO: Verify against Valid Usage section. I don't see a non-zero instanceCount listed, may need to add that and make - // this an error or leave as is. - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - REQUIRED_PARAMETER, "vkCmdDraw parameter, uint32_t instanceCount, is 0"); - } - return skip; -} - -bool pv_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - if (!device_data->physical_device_features.multiDrawIndirect && ((count > 1))) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - DEVICE_FEATURE, - "CmdDrawIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count); - } - return skip; -} - -bool pv_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, - uint32_t stride) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - if (!device_data->physical_device_features.multiDrawIndirect && ((count > 1))) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DEVICE_FEATURE, - "CmdDrawIndexedIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count); - } - return skip; -} - -bool pv_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - VkImageAspectFlags legal_aspect_flags = - VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; - if (device_data->extensions.vk_khr_sampler_ycbcr_conversion) { - legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - - if (pRegions != nullptr) { - if ((pRegions->srcSubresource.aspectMask & legal_aspect_flags) == 0) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0a600c01, - "vkCmdCopyImage() parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator."); - } - if ((pRegions->dstSubresource.aspectMask & legal_aspect_flags) == 0) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_0a600c01, - "vkCmdCopyImage() parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator."); - } - } - return skip; -} - -bool pv_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - VkImageAspectFlags legal_aspect_flags = - VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; - if (device_data->extensions.vk_khr_sampler_ycbcr_conversion) { - legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - - if (pRegions != nullptr) { - if ((pRegions->srcSubresource.aspectMask & legal_aspect_flags) == 0) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - UNRECOGNIZED_VALUE, - "vkCmdBlitImage() parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator"); - } - if ((pRegions->dstSubresource.aspectMask & legal_aspect_flags) == 0) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - UNRECOGNIZED_VALUE, - "vkCmdBlitImage() parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator"); - } - } - return skip; -} - -bool pv_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, - uint32_t regionCount, const VkBufferImageCopy *pRegions) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - VkImageAspectFlags legal_aspect_flags = - VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; - if (device_data->extensions.vk_khr_sampler_ycbcr_conversion) { - legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - - if (pRegions != nullptr) { - if ((pRegions->imageSubresource.aspectMask & legal_aspect_flags) == 0) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - UNRECOGNIZED_VALUE, - "vkCmdCopyBufferToImage() parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an " - "unrecognized enumerator"); - } - } - return skip; -} - -bool pv_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, - uint32_t regionCount, const VkBufferImageCopy *pRegions) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - VkImageAspectFlags legal_aspect_flags = - VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; - if (device_data->extensions.vk_khr_sampler_ycbcr_conversion) { - legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR); - } - - if (pRegions != nullptr) { - if ((pRegions->imageSubresource.aspectMask & legal_aspect_flags) == 0) { - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - UNRECOGNIZED_VALUE, - "vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an unrecognized " - "enumerator"); - } - } - return skip; -} - -bool pv_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, - const void *pData) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - if (dstOffset & 3) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1e400048, - "vkCmdUpdateBuffer() parameter, VkDeviceSize dstOffset (0x%" PRIxLEAST64 "), is not a multiple of 4.", - dstOffset); - } - - if ((dataSize <= 0) || (dataSize > 65536)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1e40004a, - "vkCmdUpdateBuffer() parameter, VkDeviceSize dataSize (0x%" PRIxLEAST64 - "), must be greater than zero and less than or equal to 65536.", - dataSize); - } else if (dataSize & 3) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1e40004c, - "vkCmdUpdateBuffer() parameter, VkDeviceSize dataSize (0x%" PRIxLEAST64 "), is not a multiple of 4.", dataSize); - } - return skip; -} - -bool pv_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, - uint32_t data) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - if (dstOffset & 3) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1b400032, - "vkCmdFillBuffer() parameter, VkDeviceSize dstOffset (0x%" PRIxLEAST64 "), is not a multiple of 4.", dstOffset); - } - - if (size != VK_WHOLE_SIZE) { - if (size <= 0) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1b400034, - "vkCmdFillBuffer() parameter, VkDeviceSize size (0x%" PRIxLEAST64 "), must be greater than zero.", size); - } else if (size & 3) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_1b400038, - "vkCmdFillBuffer() parameter, VkDeviceSize size (0x%" PRIxLEAST64 "), is not a multiple of 4.", size); - } - } - return skip; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &global_layer, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &global_layer, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) - return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties); - - return VK_ERROR_LAYER_NOT_PRESENT; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, - uint32_t *pPropertyCount, VkExtensionProperties *pProperties) { - // Parameter_validation does not have any physical device extensions - if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) - return util_GetExtensionProperties(0, NULL, pPropertyCount, pProperties); - - instance_layer_data *local_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - bool skip = - validate_array(local_data->report_data, "vkEnumerateDeviceExtensionProperties", "pPropertyCount", "pProperties", - pPropertyCount, &pProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2761f401); - if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; - - return local_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pPropertyCount, pProperties); -} - -static bool require_device_extension(layer_data *device_data, bool flag, char const *function_name, char const *extension_name) { - if (!flag) { - return log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - EXTENSION_NOT_ENABLED, "%s() called even though the %s extension was not enabled for this VkDevice.", - function_name, extension_name); - } - - return false; -} - -bool pv_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkSwapchainKHR *pSwapchain) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - debug_report_data *report_data = device_data->report_data; - - const LogMiscParams log_misc{report_data, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, VK_NULL_HANDLE, - "vkCreateSwapchainKHR"}; - - if (pCreateInfo != nullptr) { - if ((device_data->physical_device_features.textureCompressionETC2 == false) && - FormatIsCompressed_ETC2_EAC(pCreateInfo->imageFormat)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DEVICE_FEATURE, - "vkCreateSwapchainKHR(): Attempting to create swapchain VkImage with format %s. The textureCompressionETC2 " - "feature is not enabled: neither ETC2 nor EAC formats can be used to create images.", - string_VkFormat(pCreateInfo->imageFormat)); - } - - if ((device_data->physical_device_features.textureCompressionASTC_LDR == false) && - FormatIsCompressed_ASTC_LDR(pCreateInfo->imageFormat)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DEVICE_FEATURE, - "vkCreateSwapchainKHR(): Attempting to create swapchain VkImage with format %s. The " - "textureCompressionASTC_LDR feature is not enabled: ASTC formats cannot be used to create images.", - string_VkFormat(pCreateInfo->imageFormat)); - } - - if ((device_data->physical_device_features.textureCompressionBC == false) && - FormatIsCompressed_BC(pCreateInfo->imageFormat)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DEVICE_FEATURE, - "vkCreateSwapchainKHR(): Attempting to create swapchain VkImage with format %s. The " - "textureCompressionBC feature is not enabled: BC compressed formats cannot be used to create images.", - string_VkFormat(pCreateInfo->imageFormat)); - } - - // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml - if (pCreateInfo->imageSharingMode == VK_SHARING_MODE_CONCURRENT) { - // If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1 - if (pCreateInfo->queueFamilyIndexCount <= 1) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_146009fc, - "vkCreateSwapchainKHR(): if pCreateInfo->imageSharingMode is VK_SHARING_MODE_CONCURRENT, " - "pCreateInfo->queueFamilyIndexCount must be greater than 1."); - } - - // If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a pointer to an array of - // queueFamilyIndexCount uint32_t values - if (pCreateInfo->pQueueFamilyIndices == nullptr) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_146009fa, - "vkCreateSwapchainKHR(): if pCreateInfo->imageSharingMode is VK_SHARING_MODE_CONCURRENT, " - "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of " - "pCreateInfo->queueFamilyIndexCount uint32_t values."); - } else { - skip |= ValidateQueueFamilies(device_data, pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices, - "vkCreateSwapchainKHR", "pCreateInfo->pQueueFamilyIndices", INVALID_USAGE, - INVALID_USAGE, false); - } - } - - skip |= ValidateGreaterThanZero(pCreateInfo->imageArrayLayers, "pCreateInfo->imageArrayLayers", VALIDATION_ERROR_146009f6, - log_misc); - } - - return skip; -} - -bool pv_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - - if (pPresentInfo && pPresentInfo->pNext) { - const auto *present_regions = lvl_find_in_chain(pPresentInfo->pNext); - if (present_regions) { - // TODO: This and all other pNext extension dependencies should be added to code-generation - skip |= require_device_extension(device_data, device_data->extensions.vk_khr_incremental_present, "vkQueuePresentKHR", - VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME); - if (present_regions->swapchainCount != pPresentInfo->swapchainCount) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - INVALID_USAGE, - "QueuePresentKHR(): pPresentInfo->swapchainCount has a value of %i but VkPresentRegionsKHR " - "extension swapchainCount is %i. These values must be equal.", - pPresentInfo->swapchainCount, present_regions->swapchainCount); - } - skip |= validate_struct_pnext(device_data->report_data, "QueuePresentKHR", "pCreateInfo->pNext->pNext", NULL, - present_regions->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_1121c40d); - skip |= validate_array(device_data->report_data, "QueuePresentKHR", "pCreateInfo->pNext->swapchainCount", - "pCreateInfo->pNext->pRegions", present_regions->swapchainCount, &present_regions->pRegions, - true, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - for (uint32_t i = 0; i < present_regions->swapchainCount; ++i) { - skip |= validate_array(device_data->report_data, "QueuePresentKHR", "pCreateInfo->pNext->pRegions[].rectangleCount", - "pCreateInfo->pNext->pRegions[].pRectangles", present_regions->pRegions[i].rectangleCount, - &present_regions->pRegions[i].pRectangles, true, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - } - } - } - - return skip; -} - -#ifdef VK_USE_PLATFORM_WIN32_KHR -bool pv_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - auto device_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - bool skip = false; - - if (pCreateInfo->hwnd == nullptr) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_15a00a38, "vkCreateWin32SurfaceKHR(): hwnd must be a valid Win32 HWND but hwnd is NULL."); - } - - return skip; -} -#endif // VK_USE_PLATFORM_WIN32_KHR - -bool pv_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) { - auto device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - if (pNameInfo->pObjectName) { - device_data->report_data->debugObjectNameMap->insert( - std::make_pair((uint64_t &&) pNameInfo->object, pNameInfo->pObjectName)); - } else { - device_data->report_data->debugObjectNameMap->erase(pNameInfo->object); - } - return false; -} - -bool pv_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) { - auto device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - bool skip = false; - - if (pCreateInfo) { - if (pCreateInfo->maxSets <= 0) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, VK_NULL_HANDLE, VALIDATION_ERROR_0480025a, - "vkCreateDescriptorPool(): pCreateInfo->maxSets is not greater than 0."); - } - - if (pCreateInfo->pPoolSizes) { - for (uint32_t i = 0; i < pCreateInfo->poolSizeCount; ++i) { - if (pCreateInfo->pPoolSizes[i].descriptorCount <= 0) { - skip |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - VK_NULL_HANDLE, VALIDATION_ERROR_04a0025c, - "vkCreateDescriptorPool(): pCreateInfo->pPoolSizes[%" PRIu32 "].descriptorCount is not greater than 0.", i); - } - } - } - } - - return skip; -} - -bool pv_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - if (groupCountX > device_data->device_limits.maxComputeWorkGroupCount[0]) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19c00304, - "vkCmdDispatch(): groupCountX (%" PRIu32 ") exceeds device limit maxComputeWorkGroupCount[0] (%" PRIu32 ").", - groupCountX, device_data->device_limits.maxComputeWorkGroupCount[0]); - } - - if (groupCountY > device_data->device_limits.maxComputeWorkGroupCount[1]) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19c00306, - "vkCmdDispatch(): groupCountY (%" PRIu32 ") exceeds device limit maxComputeWorkGroupCount[1] (%" PRIu32 ").", - groupCountY, device_data->device_limits.maxComputeWorkGroupCount[1]); - } - - if (groupCountZ > device_data->device_limits.maxComputeWorkGroupCount[2]) { - skip |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19c00308, - "vkCmdDispatch(): groupCountZ (%" PRIu32 ") exceeds device limit maxComputeWorkGroupCount[2] (%" PRIu32 ").", - groupCountZ, device_data->device_limits.maxComputeWorkGroupCount[2]); - } - - return skip; -} - -bool pv_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, - uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - bool skip = false; - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - - // Paired if {} else if {} tests used to avoid any possible uint underflow - uint32_t limit = device_data->device_limits.maxComputeWorkGroupCount[0]; - if (baseGroupX >= limit) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19e0034a, - "vkCmdDispatch(): baseGroupX (%" PRIu32 - ") equals or exceeds device limit maxComputeWorkGroupCount[0] (%" PRIu32 ").", - baseGroupX, limit); - } else if (groupCountX > (limit - baseGroupX)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19e00350, - "vkCmdDispatchBaseKHR(): baseGroupX (%" PRIu32 ") + groupCountX (%" PRIu32 - ") exceeds device limit maxComputeWorkGroupCount[0] (%" PRIu32 ").", - baseGroupX, groupCountX, limit); - } - - limit = device_data->device_limits.maxComputeWorkGroupCount[1]; - if (baseGroupY >= limit) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19e0034c, - "vkCmdDispatch(): baseGroupY (%" PRIu32 - ") equals or exceeds device limit maxComputeWorkGroupCount[1] (%" PRIu32 ").", - baseGroupY, limit); - } else if (groupCountY > (limit - baseGroupY)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19e00352, - "vkCmdDispatchBaseKHR(): baseGroupY (%" PRIu32 ") + groupCountY (%" PRIu32 - ") exceeds device limit maxComputeWorkGroupCount[1] (%" PRIu32 ").", - baseGroupY, groupCountY, limit); - } - - limit = device_data->device_limits.maxComputeWorkGroupCount[2]; - if (baseGroupZ >= limit) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19e0034e, - "vkCmdDispatch(): baseGroupZ (%" PRIu32 - ") equals or exceeds device limit maxComputeWorkGroupCount[2] (%" PRIu32 ").", - baseGroupZ, limit); - } else if (groupCountZ > (limit - baseGroupZ)) { - skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - HandleToUint64(commandBuffer), VALIDATION_ERROR_19e00354, - "vkCmdDispatchBaseKHR(): baseGroupZ (%" PRIu32 ") + groupCountZ (%" PRIu32 - ") exceeds device limit maxComputeWorkGroupCount[2] (%" PRIu32 ").", - baseGroupZ, groupCountZ, limit); - } - - return skip; -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - const auto &table = device_data->dispatch_table; - if (!table.GetDeviceProcAddr) return nullptr; - return table.GetDeviceProcAddr(device, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - auto &table = instance_data->dispatch_table; - if (!table.GetInstanceProcAddr) return nullptr; - return table.GetInstanceProcAddr(instance, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { - assert(instance); - auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - - if (!instance_data->dispatch_table.GetPhysicalDeviceProcAddr) return nullptr; - return instance_data->dispatch_table.GetPhysicalDeviceProcAddr(instance, funcName); -} - -// If additional validation is needed outside of the generated checks, a manual routine can be added to this file -// and the address filled in here. The autogenerated source will call these routines if the pointers are not NULL. -void InitializeManualParameterValidationFunctionPointers() { - custom_functions["vkGetDeviceQueue"] = (void *)pv_vkGetDeviceQueue; - custom_functions["vkCreateBuffer"] = (void *)pv_vkCreateBuffer; - custom_functions["vkCreateImage"] = (void *)pv_vkCreateImage; - custom_functions["vkCreateImageView"] = (void *)pv_vkCreateImageView; - custom_functions["vkCreateGraphicsPipelines"] = (void *)pv_vkCreateGraphicsPipelines; - custom_functions["vkCreateComputePipelines"] = (void *)pv_vkCreateComputePipelines; - custom_functions["vkCreateSampler"] = (void *)pv_vkCreateSampler; - custom_functions["vkCreateDescriptorSetLayout"] = (void *)pv_vkCreateDescriptorSetLayout; - custom_functions["vkFreeDescriptorSets"] = (void *)pv_vkFreeDescriptorSets; - custom_functions["vkUpdateDescriptorSets"] = (void *)pv_vkUpdateDescriptorSets; - custom_functions["vkCreateRenderPass"] = (void *)pv_vkCreateRenderPass; - custom_functions["vkBeginCommandBuffer"] = (void *)pv_vkBeginCommandBuffer; - custom_functions["vkCmdSetViewport"] = (void *)pv_vkCmdSetViewport; - custom_functions["vkCmdSetScissor"] = (void *)pv_vkCmdSetScissor; - custom_functions["vkCmdSetLineWidth"] = (void *)pv_vkCmdSetLineWidth; - custom_functions["vkCmdDraw"] = (void *)pv_vkCmdDraw; - custom_functions["vkCmdDrawIndirect"] = (void *)pv_vkCmdDrawIndirect; - custom_functions["vkCmdDrawIndexedIndirect"] = (void *)pv_vkCmdDrawIndexedIndirect; - custom_functions["vkCmdCopyImage"] = (void *)pv_vkCmdCopyImage; - custom_functions["vkCmdBlitImage"] = (void *)pv_vkCmdBlitImage; - custom_functions["vkCmdCopyBufferToImage"] = (void *)pv_vkCmdCopyBufferToImage; - custom_functions["vkCmdCopyImageToBuffer"] = (void *)pv_vkCmdCopyImageToBuffer; - custom_functions["vkCmdUpdateBuffer"] = (void *)pv_vkCmdUpdateBuffer; - custom_functions["vkCmdFillBuffer"] = (void *)pv_vkCmdFillBuffer; - custom_functions["vkCreateSwapchainKHR"] = (void *)pv_vkCreateSwapchainKHR; - custom_functions["vkQueuePresentKHR"] = (void *)pv_vkQueuePresentKHR; - custom_functions["vkCreateDescriptorPool"] = (void *)pv_vkCreateDescriptorPool; - custom_functions["vkCmdDispatch"] = (void *)pv_vkCmdDispatch; - custom_functions["vkCmdDispatchBaseKHR"] = (void *)pv_vkCmdDispatchBaseKHR; -} - -} // namespace parameter_validation - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - return parameter_validation::vkEnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, - VkLayerProperties *pProperties) { - return parameter_validation::vkEnumerateInstanceLayerProperties(pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - // the layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return parameter_validation::vkEnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - // the layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return parameter_validation::vkEnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { - return parameter_validation::vkGetDeviceProcAddr(dev, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { - return parameter_validation::vkGetInstanceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, - const char *funcName) { - return parameter_validation::vkGetPhysicalDeviceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT bool pv_vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { - assert(pVersionStruct != NULL); - assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); - - // Fill in the function pointers if our version is at least capable of having the structure contain them. - if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { - pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; - pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; - pVersionStruct->pfnGetPhysicalDeviceProcAddr = vk_layerGetPhysicalDeviceProcAddr; - } - - if (pVersionStruct->loaderLayerInterfaceVersion < CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - parameter_validation::loader_layer_if_version = pVersionStruct->loaderLayerInterfaceVersion; - } else if (pVersionStruct->loaderLayerInterfaceVersion > CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - pVersionStruct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - } - - return VK_SUCCESS; -} diff --git a/layers/shader_validation.cpp b/layers/shader_validation.cpp deleted file mode 100644 index 0c725e95..00000000 --- a/layers/shader_validation.cpp +++ /dev/null @@ -1,1728 +0,0 @@ -/* 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: Chris Forbes - */ - -#include -#include -#include -#include -#include -#include -#include -#include "vk_loader_platform.h" -#include "vk_enum_string_helper.h" -#include "vk_layer_table.h" -#include "vk_layer_data.h" -#include "vk_layer_extension_utils.h" -#include "vk_layer_utils.h" -#include "core_validation.h" -#include "core_validation_types.h" -#include "shader_validation.h" -#include "spirv-tools/libspirv.h" -#include "xxhash.h" - -enum FORMAT_TYPE { - FORMAT_TYPE_FLOAT = 1, // UNORM, SNORM, FLOAT, USCALED, SSCALED, SRGB -- anything we consider float in the shader - FORMAT_TYPE_SINT = 2, - FORMAT_TYPE_UINT = 4, -}; - -typedef std::pair location_t; - -struct interface_var { - uint32_t id; - uint32_t type_id; - uint32_t offset; - bool is_patch; - bool is_block_member; - bool is_relaxed_precision; - // TODO: collect the name, too? Isn't required to be present. -}; - -struct shader_stage_attributes { - char const *const name; - bool arrayed_input; - bool arrayed_output; -}; - -static shader_stage_attributes shader_stage_attribs[] = { - {"vertex shader", false, false}, {"tessellation control shader", true, true}, {"tessellation evaluation shader", true, false}, - {"geometry shader", true, false}, {"fragment shader", false, false}, -}; - -// SPIRV utility functions -void shader_module::build_def_index() { - for (auto insn : *this) { - switch (insn.opcode()) { - // Types - case spv::OpTypeVoid: - case spv::OpTypeBool: - case spv::OpTypeInt: - case spv::OpTypeFloat: - case spv::OpTypeVector: - case spv::OpTypeMatrix: - case spv::OpTypeImage: - case spv::OpTypeSampler: - case spv::OpTypeSampledImage: - case spv::OpTypeArray: - case spv::OpTypeRuntimeArray: - case spv::OpTypeStruct: - case spv::OpTypeOpaque: - case spv::OpTypePointer: - case spv::OpTypeFunction: - case spv::OpTypeEvent: - case spv::OpTypeDeviceEvent: - case spv::OpTypeReserveId: - case spv::OpTypeQueue: - case spv::OpTypePipe: - def_index[insn.word(1)] = insn.offset(); - break; - - // Fixed constants - case spv::OpConstantTrue: - case spv::OpConstantFalse: - case spv::OpConstant: - case spv::OpConstantComposite: - case spv::OpConstantSampler: - case spv::OpConstantNull: - def_index[insn.word(2)] = insn.offset(); - break; - - // Specialization constants - case spv::OpSpecConstantTrue: - case spv::OpSpecConstantFalse: - case spv::OpSpecConstant: - case spv::OpSpecConstantComposite: - case spv::OpSpecConstantOp: - def_index[insn.word(2)] = insn.offset(); - break; - - // Variables - case spv::OpVariable: - def_index[insn.word(2)] = insn.offset(); - break; - - // Functions - case spv::OpFunction: - def_index[insn.word(2)] = insn.offset(); - break; - - default: - // We don't care about any other defs for now. - break; - } - } -} - -static spirv_inst_iter find_entrypoint(shader_module const *src, char const *name, VkShaderStageFlagBits stageBits) { - for (auto insn : *src) { - if (insn.opcode() == spv::OpEntryPoint) { - auto entrypointName = (char const *)&insn.word(3); - auto entrypointStageBits = 1u << insn.word(1); - - if (!strcmp(entrypointName, name) && (entrypointStageBits & stageBits)) { - return insn; - } - } - } - - return src->end(); -} - -static char const *storage_class_name(unsigned sc) { - switch (sc) { - case spv::StorageClassInput: - return "input"; - case spv::StorageClassOutput: - return "output"; - case spv::StorageClassUniformConstant: - return "const uniform"; - case spv::StorageClassUniform: - return "uniform"; - case spv::StorageClassWorkgroup: - return "workgroup local"; - case spv::StorageClassCrossWorkgroup: - return "workgroup global"; - case spv::StorageClassPrivate: - return "private global"; - case spv::StorageClassFunction: - return "function"; - case spv::StorageClassGeneric: - return "generic"; - case spv::StorageClassAtomicCounter: - return "atomic counter"; - case spv::StorageClassImage: - return "image"; - case spv::StorageClassPushConstant: - return "push constant"; - case spv::StorageClassStorageBuffer: - return "storage buffer"; - default: - return "unknown"; - } -} - -// Get the value of an integral constant -unsigned get_constant_value(shader_module const *src, unsigned id) { - auto value = src->get_def(id); - assert(value != src->end()); - - if (value.opcode() != spv::OpConstant) { - // TODO: Either ensure that the specialization transform is already performed on a module we're - // considering here, OR -- specialize on the fly now. - return 1; - } - - return value.word(3); -} - -static void describe_type_inner(std::ostringstream &ss, shader_module const *src, unsigned type) { - auto insn = src->get_def(type); - assert(insn != src->end()); - - switch (insn.opcode()) { - case spv::OpTypeBool: - ss << "bool"; - break; - case spv::OpTypeInt: - ss << (insn.word(3) ? 's' : 'u') << "int" << insn.word(2); - break; - case spv::OpTypeFloat: - ss << "float" << insn.word(2); - break; - case spv::OpTypeVector: - ss << "vec" << insn.word(3) << " of "; - describe_type_inner(ss, src, insn.word(2)); - break; - case spv::OpTypeMatrix: - ss << "mat" << insn.word(3) << " of "; - describe_type_inner(ss, src, insn.word(2)); - break; - case spv::OpTypeArray: - ss << "arr[" << get_constant_value(src, insn.word(3)) << "] of "; - describe_type_inner(ss, src, insn.word(2)); - break; - case spv::OpTypePointer: - ss << "ptr to " << storage_class_name(insn.word(2)) << " "; - describe_type_inner(ss, src, insn.word(3)); - break; - case spv::OpTypeStruct: { - ss << "struct of ("; - for (unsigned i = 2; i < insn.len(); i++) { - describe_type_inner(ss, src, insn.word(i)); - if (i == insn.len() - 1) { - ss << ")"; - } else { - ss << ", "; - } - } - break; - } - case spv::OpTypeSampler: - ss << "sampler"; - break; - case spv::OpTypeSampledImage: - ss << "sampler+"; - describe_type_inner(ss, src, insn.word(2)); - break; - case spv::OpTypeImage: - ss << "image(dim=" << insn.word(3) << ", sampled=" << insn.word(7) << ")"; - break; - default: - ss << "oddtype"; - break; - } -} - -static std::string describe_type(shader_module const *src, unsigned type) { - std::ostringstream ss; - describe_type_inner(ss, src, type); - return ss.str(); -} - -static bool is_narrow_numeric_type(spirv_inst_iter type) { - if (type.opcode() != spv::OpTypeInt && type.opcode() != spv::OpTypeFloat) return false; - return type.word(2) < 64; -} - -static bool types_match(shader_module const *a, shader_module const *b, unsigned a_type, unsigned b_type, bool a_arrayed, - bool b_arrayed, bool relaxed) { - // Walk two type trees together, and complain about differences - auto a_insn = a->get_def(a_type); - auto b_insn = b->get_def(b_type); - assert(a_insn != a->end()); - assert(b_insn != b->end()); - - if (a_arrayed && a_insn.opcode() == spv::OpTypeArray) { - return types_match(a, b, a_insn.word(2), b_type, false, b_arrayed, relaxed); - } - - if (b_arrayed && b_insn.opcode() == spv::OpTypeArray) { - // We probably just found the extra level of arrayness in b_type: compare the type inside it to a_type - return types_match(a, b, a_type, b_insn.word(2), a_arrayed, false, relaxed); - } - - if (a_insn.opcode() == spv::OpTypeVector && relaxed && is_narrow_numeric_type(b_insn)) { - return types_match(a, b, a_insn.word(2), b_type, a_arrayed, b_arrayed, false); - } - - if (a_insn.opcode() != b_insn.opcode()) { - return false; - } - - if (a_insn.opcode() == spv::OpTypePointer) { - // Match on pointee type. storage class is expected to differ - return types_match(a, b, a_insn.word(3), b_insn.word(3), a_arrayed, b_arrayed, relaxed); - } - - if (a_arrayed || b_arrayed) { - // If we havent resolved array-of-verts by here, we're not going to. - return false; - } - - switch (a_insn.opcode()) { - case spv::OpTypeBool: - return true; - case spv::OpTypeInt: - // Match on width, signedness - return a_insn.word(2) == b_insn.word(2) && a_insn.word(3) == b_insn.word(3); - case spv::OpTypeFloat: - // Match on width - return a_insn.word(2) == b_insn.word(2); - case spv::OpTypeVector: - // Match on element type, count. - if (!types_match(a, b, a_insn.word(2), b_insn.word(2), a_arrayed, b_arrayed, false)) return false; - if (relaxed && is_narrow_numeric_type(a->get_def(a_insn.word(2)))) { - return a_insn.word(3) >= b_insn.word(3); - } else { - return a_insn.word(3) == b_insn.word(3); - } - case spv::OpTypeMatrix: - // Match on element type, count. - return types_match(a, b, a_insn.word(2), b_insn.word(2), a_arrayed, b_arrayed, false) && - a_insn.word(3) == b_insn.word(3); - case spv::OpTypeArray: - // Match on element type, count. these all have the same layout. we don't get here if b_arrayed. This differs from - // vector & matrix types in that the array size is the id of a constant instruction, * not a literal within OpTypeArray - return types_match(a, b, a_insn.word(2), b_insn.word(2), a_arrayed, b_arrayed, false) && - get_constant_value(a, a_insn.word(3)) == get_constant_value(b, b_insn.word(3)); - case spv::OpTypeStruct: - // Match on all element types - { - if (a_insn.len() != b_insn.len()) { - return false; // Structs cannot match if member counts differ - } - - for (unsigned i = 2; i < a_insn.len(); i++) { - if (!types_match(a, b, a_insn.word(i), b_insn.word(i), a_arrayed, b_arrayed, false)) { - return false; - } - } - - return true; - } - default: - // Remaining types are CLisms, or may not appear in the interfaces we are interested in. Just claim no match. - return false; - } -} - -static unsigned value_or_default(std::unordered_map const &map, unsigned id, unsigned def) { - auto it = map.find(id); - if (it == map.end()) - return def; - else - return it->second; -} - -static unsigned get_locations_consumed_by_type(shader_module const *src, unsigned type, bool strip_array_level) { - auto insn = src->get_def(type); - assert(insn != src->end()); - - switch (insn.opcode()) { - case spv::OpTypePointer: - // See through the ptr -- this is only ever at the toplevel for graphics shaders we're never actually passing - // pointers around. - return get_locations_consumed_by_type(src, insn.word(3), strip_array_level); - case spv::OpTypeArray: - if (strip_array_level) { - return get_locations_consumed_by_type(src, insn.word(2), false); - } else { - return get_constant_value(src, insn.word(3)) * get_locations_consumed_by_type(src, insn.word(2), false); - } - case spv::OpTypeMatrix: - // Num locations is the dimension * element size - return insn.word(3) * get_locations_consumed_by_type(src, insn.word(2), false); - case spv::OpTypeVector: { - auto scalar_type = src->get_def(insn.word(2)); - auto bit_width = - (scalar_type.opcode() == spv::OpTypeInt || scalar_type.opcode() == spv::OpTypeFloat) ? scalar_type.word(2) : 32; - - // Locations are 128-bit wide; 3- and 4-component vectors of 64 bit types require two. - return (bit_width * insn.word(3) + 127) / 128; - } - default: - // Everything else is just 1. - return 1; - - // TODO: extend to handle 64bit scalar types, whose vectors may need multiple locations. - } -} - -static unsigned get_locations_consumed_by_format(VkFormat format) { - switch (format) { - case VK_FORMAT_R64G64B64A64_SFLOAT: - case VK_FORMAT_R64G64B64A64_SINT: - case VK_FORMAT_R64G64B64A64_UINT: - case VK_FORMAT_R64G64B64_SFLOAT: - case VK_FORMAT_R64G64B64_SINT: - case VK_FORMAT_R64G64B64_UINT: - return 2; - default: - return 1; - } -} - -static unsigned get_format_type(VkFormat fmt) { - if (FormatIsSInt(fmt)) return FORMAT_TYPE_SINT; - if (FormatIsUInt(fmt)) return FORMAT_TYPE_UINT; - if (FormatIsDepthAndStencil(fmt)) return FORMAT_TYPE_FLOAT | FORMAT_TYPE_UINT; - if (fmt == VK_FORMAT_UNDEFINED) return 0; - // everything else -- UNORM/SNORM/FLOAT/USCALED/SSCALED is all float in the shader. - return FORMAT_TYPE_FLOAT; -} - -// characterizes a SPIR-V type appearing in an interface to a FF stage, for comparison to a VkFormat's characterization above. -static unsigned get_fundamental_type(shader_module const *src, unsigned type) { - auto insn = src->get_def(type); - assert(insn != src->end()); - - switch (insn.opcode()) { - case spv::OpTypeInt: - return insn.word(3) ? FORMAT_TYPE_SINT : FORMAT_TYPE_UINT; - case spv::OpTypeFloat: - return FORMAT_TYPE_FLOAT; - case spv::OpTypeVector: - return get_fundamental_type(src, insn.word(2)); - case spv::OpTypeMatrix: - return get_fundamental_type(src, insn.word(2)); - case spv::OpTypeArray: - return get_fundamental_type(src, insn.word(2)); - case spv::OpTypePointer: - return get_fundamental_type(src, insn.word(3)); - case spv::OpTypeImage: - return get_fundamental_type(src, insn.word(2)); - - default: - return 0; - } -} - -static uint32_t get_shader_stage_id(VkShaderStageFlagBits stage) { - uint32_t bit_pos = uint32_t(u_ffs(stage)); - return bit_pos - 1; -} - -static spirv_inst_iter get_struct_type(shader_module const *src, spirv_inst_iter def, bool is_array_of_verts) { - while (true) { - if (def.opcode() == spv::OpTypePointer) { - def = src->get_def(def.word(3)); - } else if (def.opcode() == spv::OpTypeArray && is_array_of_verts) { - def = src->get_def(def.word(2)); - is_array_of_verts = false; - } else if (def.opcode() == spv::OpTypeStruct) { - return def; - } else { - return src->end(); - } - } -} - -static bool collect_interface_block_members(shader_module const *src, std::map *out, - std::unordered_map const &blocks, bool is_array_of_verts, - uint32_t id, uint32_t type_id, bool is_patch, int /*first_location*/) { - // Walk down the type_id presented, trying to determine whether it's actually an interface block. - auto type = get_struct_type(src, src->get_def(type_id), is_array_of_verts && !is_patch); - if (type == src->end() || blocks.find(type.word(1)) == blocks.end()) { - // This isn't an interface block. - return false; - } - - std::unordered_map member_components; - std::unordered_map member_relaxed_precision; - std::unordered_map member_patch; - - // Walk all the OpMemberDecorate for type's result id -- first pass, collect components. - for (auto insn : *src) { - if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1)) { - unsigned member_index = insn.word(2); - - if (insn.word(3) == spv::DecorationComponent) { - unsigned component = insn.word(4); - member_components[member_index] = component; - } - - if (insn.word(3) == spv::DecorationRelaxedPrecision) { - member_relaxed_precision[member_index] = 1; - } - - if (insn.word(3) == spv::DecorationPatch) { - member_patch[member_index] = 1; - } - } - } - - // TODO: correctly handle location assignment from outside - - // Second pass -- produce the output, from Location decorations - for (auto insn : *src) { - if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1)) { - unsigned member_index = insn.word(2); - unsigned member_type_id = type.word(2 + member_index); - - if (insn.word(3) == spv::DecorationLocation) { - unsigned location = insn.word(4); - unsigned num_locations = get_locations_consumed_by_type(src, member_type_id, false); - auto component_it = member_components.find(member_index); - unsigned component = component_it == member_components.end() ? 0 : component_it->second; - bool is_relaxed_precision = member_relaxed_precision.find(member_index) != member_relaxed_precision.end(); - bool member_is_patch = is_patch || member_patch.count(member_index) > 0; - - for (unsigned int offset = 0; offset < num_locations; offset++) { - interface_var v = {}; - v.id = id; - // TODO: member index in interface_var too? - v.type_id = member_type_id; - v.offset = offset; - v.is_patch = member_is_patch; - v.is_block_member = true; - v.is_relaxed_precision = is_relaxed_precision; - (*out)[std::make_pair(location + offset, component)] = v; - } - } - } - } - - return true; -} - -static std::map collect_interface_by_location(shader_module const *src, spirv_inst_iter entrypoint, - spv::StorageClass sinterface, bool is_array_of_verts) { - std::unordered_map var_locations; - std::unordered_map var_builtins; - std::unordered_map var_components; - std::unordered_map blocks; - std::unordered_map var_patch; - std::unordered_map var_relaxed_precision; - - for (auto insn : *src) { - // We consider two interface models: SSO rendezvous-by-location, and builtins. Complain about anything that - // fits neither model. - if (insn.opcode() == spv::OpDecorate) { - if (insn.word(2) == spv::DecorationLocation) { - var_locations[insn.word(1)] = insn.word(3); - } - - if (insn.word(2) == spv::DecorationBuiltIn) { - var_builtins[insn.word(1)] = insn.word(3); - } - - if (insn.word(2) == spv::DecorationComponent) { - var_components[insn.word(1)] = insn.word(3); - } - - if (insn.word(2) == spv::DecorationBlock) { - blocks[insn.word(1)] = 1; - } - - if (insn.word(2) == spv::DecorationPatch) { - var_patch[insn.word(1)] = 1; - } - - if (insn.word(2) == spv::DecorationRelaxedPrecision) { - var_relaxed_precision[insn.word(1)] = 1; - } - } - } - - // TODO: handle grouped decorations - // TODO: handle index=1 dual source outputs from FS -- two vars will have the same location, and we DON'T want to clobber. - - // Find the end of the entrypoint's name string. additional zero bytes follow the actual null terminator, to fill out the - // rest of the word - so we only need to look at the last byte in the word to determine which word contains the terminator. - uint32_t word = 3; - while (entrypoint.word(word) & 0xff000000u) { - ++word; - } - ++word; - - std::map out; - - for (; word < entrypoint.len(); word++) { - auto insn = src->get_def(entrypoint.word(word)); - assert(insn != src->end()); - assert(insn.opcode() == spv::OpVariable); - - if (insn.word(3) == static_cast(sinterface)) { - unsigned id = insn.word(2); - unsigned type = insn.word(1); - - int location = value_or_default(var_locations, id, static_cast(-1)); - int builtin = value_or_default(var_builtins, id, static_cast(-1)); - unsigned component = value_or_default(var_components, id, 0); // Unspecified is OK, is 0 - bool is_patch = var_patch.find(id) != var_patch.end(); - bool is_relaxed_precision = var_relaxed_precision.find(id) != var_relaxed_precision.end(); - - if (builtin != -1) - continue; - else if (!collect_interface_block_members(src, &out, blocks, is_array_of_verts, id, type, is_patch, location)) { - // A user-defined interface variable, with a location. Where a variable occupied multiple locations, emit - // one result for each. - unsigned num_locations = get_locations_consumed_by_type(src, type, is_array_of_verts && !is_patch); - for (unsigned int offset = 0; offset < num_locations; offset++) { - interface_var v = {}; - v.id = id; - v.type_id = type; - v.offset = offset; - v.is_patch = is_patch; - v.is_relaxed_precision = is_relaxed_precision; - out[std::make_pair(location + offset, component)] = v; - } - } - } - } - - return out; -} - -static std::vector> collect_interface_by_input_attachment_index( - shader_module const *src, std::unordered_set const &accessible_ids) { - std::vector> out; - - for (auto insn : *src) { - if (insn.opcode() == spv::OpDecorate) { - if (insn.word(2) == spv::DecorationInputAttachmentIndex) { - auto attachment_index = insn.word(3); - auto id = insn.word(1); - - if (accessible_ids.count(id)) { - auto def = src->get_def(id); - assert(def != src->end()); - - if (def.opcode() == spv::OpVariable && insn.word(3) == spv::StorageClassUniformConstant) { - auto num_locations = get_locations_consumed_by_type(src, def.word(1), false); - for (unsigned int offset = 0; offset < num_locations; offset++) { - interface_var v = {}; - v.id = id; - v.type_id = def.word(1); - v.offset = offset; - out.emplace_back(attachment_index + offset, v); - } - } - } - } - } - } - - return out; -} - -static bool is_writable_descriptor_type(shader_module const *module, uint32_t type_id) { - auto type = module->get_def(type_id); - - // Strip off any array or ptrs. Where we remove array levels, adjust the descriptor count for each dimension. - while (type.opcode() == spv::OpTypeArray || type.opcode() == spv::OpTypePointer) { - if (type.opcode() == spv::OpTypeArray) { - type = module->get_def(type.word(2)); - } else { - if (type.word(2) == spv::StorageClassStorageBuffer) { - return true; - } - type = module->get_def(type.word(3)); - } - } - - switch (type.opcode()) { - case spv::OpTypeImage: { - auto dim = type.word(3); - auto sampled = type.word(7); - return sampled == 2 && dim != spv::DimSubpassData; - } - - case spv::OpTypeStruct: - for (auto insn : *module) { - if (insn.opcode() == spv::OpDecorate && insn.word(1) == type.word(1)) { - if (insn.word(2) == spv::DecorationBufferBlock) { - return true; - } - } - } - } - - return false; -} - -static std::vector> collect_interface_by_descriptor_slot( - debug_report_data const *report_data, shader_module const *src, std::unordered_set const &accessible_ids, - bool *has_writable_descriptor) { - std::unordered_map var_sets; - std::unordered_map var_bindings; - std::unordered_map var_nonwritable; - - for (auto insn : *src) { - // All variables in the Uniform or UniformConstant storage classes are required to be decorated with both - // DecorationDescriptorSet and DecorationBinding. - if (insn.opcode() == spv::OpDecorate) { - if (insn.word(2) == spv::DecorationDescriptorSet) { - var_sets[insn.word(1)] = insn.word(3); - } - - if (insn.word(2) == spv::DecorationBinding) { - var_bindings[insn.word(1)] = insn.word(3); - } - - if (insn.word(2) == spv::DecorationNonWritable) { - var_nonwritable[insn.word(1)] = 1; - } - } - } - - std::vector> out; - - for (auto id : accessible_ids) { - auto insn = src->get_def(id); - assert(insn != src->end()); - - if (insn.opcode() == spv::OpVariable && - (insn.word(3) == spv::StorageClassUniform || insn.word(3) == spv::StorageClassUniformConstant || - insn.word(3) == spv::StorageClassStorageBuffer)) { - unsigned set = value_or_default(var_sets, insn.word(2), 0); - unsigned binding = value_or_default(var_bindings, insn.word(2), 0); - - interface_var v = {}; - v.id = insn.word(2); - v.type_id = insn.word(1); - out.emplace_back(std::make_pair(set, binding), v); - - if (var_nonwritable.find(id) == var_nonwritable.end() && is_writable_descriptor_type(src, insn.word(1))) { - *has_writable_descriptor = true; - } - } - } - - return out; -} - -static bool validate_vi_consistency(debug_report_data const *report_data, VkPipelineVertexInputStateCreateInfo const *vi) { - // Walk the binding descriptions, which describe the step rate and stride of each vertex buffer. Each binding should - // be specified only once. - std::unordered_map bindings; - bool skip = false; - - for (unsigned i = 0; i < vi->vertexBindingDescriptionCount; i++) { - auto desc = &vi->pVertexBindingDescriptions[i]; - auto &binding = bindings[desc->binding]; - if (binding) { - // TODO: VALIDATION_ERROR_096005cc perhaps? - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_INCONSISTENT_VI, "Duplicate vertex input binding descriptions for binding %d", - desc->binding); - } else { - binding = desc; - } - } - - return skip; -} - -static bool validate_vi_against_vs_inputs(debug_report_data const *report_data, VkPipelineVertexInputStateCreateInfo const *vi, - shader_module const *vs, spirv_inst_iter entrypoint) { - bool skip = false; - - auto inputs = collect_interface_by_location(vs, entrypoint, spv::StorageClassInput, false); - - // Build index by location - std::map attribs; - if (vi) { - for (unsigned i = 0; i < vi->vertexAttributeDescriptionCount; i++) { - auto num_locations = get_locations_consumed_by_format(vi->pVertexAttributeDescriptions[i].format); - for (auto j = 0u; j < num_locations; j++) { - attribs[vi->pVertexAttributeDescriptions[i].location + j] = &vi->pVertexAttributeDescriptions[i]; - } - } - } - - auto it_a = attribs.begin(); - auto it_b = inputs.begin(); - bool used = false; - - while ((attribs.size() > 0 && it_a != attribs.end()) || (inputs.size() > 0 && it_b != inputs.end())) { - bool a_at_end = attribs.size() == 0 || it_a == attribs.end(); - bool b_at_end = inputs.size() == 0 || it_b == inputs.end(); - auto a_first = a_at_end ? 0 : it_a->first; - auto b_first = b_at_end ? 0 : it_b->first.first; - if (!a_at_end && (b_at_end || a_first < b_first)) { - if (!used && log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, - "Vertex attribute at location %d not consumed by vertex shader", a_first)) { - skip = true; - } - used = false; - it_a++; - } else if (!b_at_end && (a_at_end || b_first < a_first)) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, - SHADER_CHECKER_INPUT_NOT_PRODUCED, "Vertex shader consumes input at location %d but not provided", b_first); - it_b++; - } else { - unsigned attrib_type = get_format_type(it_a->second->format); - unsigned input_type = get_fundamental_type(vs, it_b->second.type_id); - - // Type checking - if (!(attrib_type & input_type)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, - "Attribute type of `%s` at location %d does not match vertex shader input type of `%s`", - string_VkFormat(it_a->second->format), a_first, describe_type(vs, it_b->second.type_id).c_str()); - } - - // OK! - used = true; - it_b++; - } - } - - return skip; -} - -static bool validate_fs_outputs_against_render_pass(debug_report_data const *report_data, shader_module const *fs, - spirv_inst_iter entrypoint, PIPELINE_STATE const *pipeline, - uint32_t subpass_index) { - auto rpci = pipeline->rp_state->createInfo.ptr(); - - std::map color_attachments; - auto subpass = rpci->pSubpasses[subpass_index]; - for (auto i = 0u; i < subpass.colorAttachmentCount; ++i) { - uint32_t attachment = subpass.pColorAttachments[i].attachment; - if (attachment == VK_ATTACHMENT_UNUSED) continue; - if (rpci->pAttachments[attachment].format != VK_FORMAT_UNDEFINED) { - color_attachments[i] = rpci->pAttachments[attachment].format; - } - } - - bool skip = false; - - // TODO: dual source blend index (spv::DecIndex, zero if not provided) - - auto outputs = collect_interface_by_location(fs, entrypoint, spv::StorageClassOutput, false); - - auto it_a = outputs.begin(); - auto it_b = color_attachments.begin(); - - // Walk attachment list and outputs together - - while ((outputs.size() > 0 && it_a != outputs.end()) || (color_attachments.size() > 0 && it_b != color_attachments.end())) { - bool a_at_end = outputs.size() == 0 || it_a == outputs.end(); - bool b_at_end = color_attachments.size() == 0 || it_b == color_attachments.end(); - - if (!a_at_end && (b_at_end || it_a->first.first < it_b->first)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_OUTPUT_NOT_CONSUMED, - "fragment shader writes to output location %d with no matching attachment", it_a->first.first); - it_a++; - } else if (!b_at_end && (a_at_end || it_a->first.first > it_b->first)) { - // Only complain if there are unmasked channels for this attachment. If the writemask is 0, it's acceptable for the - // shader to not produce a matching output. - if (pipeline->attachments[it_b->first].colorWriteMask != 0) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_INPUT_NOT_PRODUCED, "Attachment %d not written by fragment shader", it_b->first); - } - it_b++; - } else { - unsigned output_type = get_fundamental_type(fs, it_a->second.type_id); - unsigned att_type = get_format_type(it_b->second); - - // Type checking - if (!(output_type & att_type)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, - "Attachment %d of type `%s` does not match fragment shader output type of `%s`", it_b->first, - string_VkFormat(it_b->second), describe_type(fs, it_a->second.type_id).c_str()); - } - - // OK! - it_a++; - it_b++; - } - } - - return skip; -} - -// For some analyses, we need to know about all ids referenced by the static call tree of a particular entrypoint. This is -// important for identifying the set of shader resources actually used by an entrypoint, for example. -// Note: we only explore parts of the image which might actually contain ids we care about for the above analyses. -// - NOT the shader input/output interfaces. -// -// TODO: The set of interesting opcodes here was determined by eyeballing the SPIRV spec. It might be worth -// converting parts of this to be generated from the machine-readable spec instead. -static std::unordered_set mark_accessible_ids(shader_module const *src, spirv_inst_iter entrypoint) { - std::unordered_set ids; - std::unordered_set worklist; - worklist.insert(entrypoint.word(2)); - - while (!worklist.empty()) { - auto id_iter = worklist.begin(); - auto id = *id_iter; - worklist.erase(id_iter); - - auto insn = src->get_def(id); - if (insn == src->end()) { - // ID is something we didn't collect in build_def_index. that's OK -- we'll stumble across all kinds of things here - // that we may not care about. - continue; - } - - // Try to add to the output set - if (!ids.insert(id).second) { - continue; // If we already saw this id, we don't want to walk it again. - } - - switch (insn.opcode()) { - case spv::OpFunction: - // Scan whole body of the function, enlisting anything interesting - while (++insn, insn.opcode() != spv::OpFunctionEnd) { - switch (insn.opcode()) { - case spv::OpLoad: - case spv::OpAtomicLoad: - case spv::OpAtomicExchange: - case spv::OpAtomicCompareExchange: - case spv::OpAtomicCompareExchangeWeak: - case spv::OpAtomicIIncrement: - case spv::OpAtomicIDecrement: - case spv::OpAtomicIAdd: - case spv::OpAtomicISub: - case spv::OpAtomicSMin: - case spv::OpAtomicUMin: - case spv::OpAtomicSMax: - case spv::OpAtomicUMax: - case spv::OpAtomicAnd: - case spv::OpAtomicOr: - case spv::OpAtomicXor: - worklist.insert(insn.word(3)); // ptr - break; - case spv::OpStore: - case spv::OpAtomicStore: - worklist.insert(insn.word(1)); // ptr - break; - case spv::OpAccessChain: - case spv::OpInBoundsAccessChain: - worklist.insert(insn.word(3)); // base ptr - break; - case spv::OpSampledImage: - case spv::OpImageSampleImplicitLod: - case spv::OpImageSampleExplicitLod: - case spv::OpImageSampleDrefImplicitLod: - case spv::OpImageSampleDrefExplicitLod: - case spv::OpImageSampleProjImplicitLod: - case spv::OpImageSampleProjExplicitLod: - case spv::OpImageSampleProjDrefImplicitLod: - case spv::OpImageSampleProjDrefExplicitLod: - case spv::OpImageFetch: - case spv::OpImageGather: - case spv::OpImageDrefGather: - case spv::OpImageRead: - case spv::OpImage: - case spv::OpImageQueryFormat: - case spv::OpImageQueryOrder: - case spv::OpImageQuerySizeLod: - case spv::OpImageQuerySize: - case spv::OpImageQueryLod: - case spv::OpImageQueryLevels: - case spv::OpImageQuerySamples: - case spv::OpImageSparseSampleImplicitLod: - case spv::OpImageSparseSampleExplicitLod: - case spv::OpImageSparseSampleDrefImplicitLod: - case spv::OpImageSparseSampleDrefExplicitLod: - case spv::OpImageSparseSampleProjImplicitLod: - case spv::OpImageSparseSampleProjExplicitLod: - case spv::OpImageSparseSampleProjDrefImplicitLod: - case spv::OpImageSparseSampleProjDrefExplicitLod: - case spv::OpImageSparseFetch: - case spv::OpImageSparseGather: - case spv::OpImageSparseDrefGather: - case spv::OpImageTexelPointer: - worklist.insert(insn.word(3)); // Image or sampled image - break; - case spv::OpImageWrite: - worklist.insert(insn.word(1)); // Image -- different operand order to above - break; - case spv::OpFunctionCall: - for (uint32_t i = 3; i < insn.len(); i++) { - worklist.insert(insn.word(i)); // fn itself, and all args - } - break; - - case spv::OpExtInst: - for (uint32_t i = 5; i < insn.len(); i++) { - worklist.insert(insn.word(i)); // Operands to ext inst - } - break; - } - } - break; - } - } - - return ids; -} - -static bool validate_push_constant_block_against_pipeline(debug_report_data const *report_data, - std::vector const *push_constant_ranges, - shader_module const *src, spirv_inst_iter type, - VkShaderStageFlagBits stage) { - bool skip = false; - - // Strip off ptrs etc - type = get_struct_type(src, type, false); - assert(type != src->end()); - - // Validate directly off the offsets. this isn't quite correct for arrays and matrices, but is a good first step. - // TODO: arrays, matrices, weird sizes - for (auto insn : *src) { - if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1)) { - if (insn.word(3) == spv::DecorationOffset) { - unsigned offset = insn.word(4); - auto size = 4; // Bytes; TODO: calculate this based on the type - - bool found_range = false; - for (auto const &range : *push_constant_ranges) { - if (range.offset <= offset && range.offset + range.size >= offset + size) { - found_range = true; - - if ((range.stageFlags & stage) == 0) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_PUSH_CONSTANT_NOT_ACCESSIBLE_FROM_STAGE, - "Push constant range covering variable starting at offset %u not accessible from stage %s", - offset, string_VkShaderStageFlagBits(stage)); - } - - break; - } - } - - if (!found_range) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_PUSH_CONSTANT_OUT_OF_RANGE, - "Push constant range covering variable starting at offset %u not declared in layout", offset); - } - } - } - } - - return skip; -} - -static bool validate_push_constant_usage(debug_report_data const *report_data, - std::vector const *push_constant_ranges, shader_module const *src, - std::unordered_set accessible_ids, VkShaderStageFlagBits stage) { - bool skip = false; - - for (auto id : accessible_ids) { - auto def_insn = src->get_def(id); - if (def_insn.opcode() == spv::OpVariable && def_insn.word(3) == spv::StorageClassPushConstant) { - skip |= validate_push_constant_block_against_pipeline(report_data, push_constant_ranges, src, - src->get_def(def_insn.word(1)), stage); - } - } - - return skip; -} - -// Validate that data for each specialization entry is fully contained within the buffer. -static bool validate_specialization_offsets(debug_report_data const *report_data, VkPipelineShaderStageCreateInfo const *info) { - bool skip = false; - - VkSpecializationInfo const *spec = info->pSpecializationInfo; - - if (spec) { - for (auto i = 0u; i < spec->mapEntryCount; i++) { - // TODO: This is a good place for VALIDATION_ERROR_1360060a. - if (spec->pMapEntries[i].offset + spec->pMapEntries[i].size > spec->dataSize) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, - VALIDATION_ERROR_1360060c, - "Specialization entry %u (for constant id %u) references memory outside provided specialization " - "data (bytes %u.." PRINTF_SIZE_T_SPECIFIER "; " PRINTF_SIZE_T_SPECIFIER " bytes provided)..", - i, spec->pMapEntries[i].constantID, spec->pMapEntries[i].offset, - spec->pMapEntries[i].offset + spec->pMapEntries[i].size - 1, spec->dataSize); - } - } - } - - return skip; -} - -static bool descriptor_type_match(shader_module const *module, uint32_t type_id, VkDescriptorType descriptor_type, - unsigned &descriptor_count) { - auto type = module->get_def(type_id); - bool is_storage_buffer = false; - descriptor_count = 1; - - // Strip off any array or ptrs. Where we remove array levels, adjust the descriptor count for each dimension. - while (type.opcode() == spv::OpTypeArray || type.opcode() == spv::OpTypePointer || type.opcode() == spv::OpTypeRuntimeArray) { - if (type.opcode() == spv::OpTypeRuntimeArray) { - descriptor_count = 0; - type = module->get_def(type.word(2)); - } else if (type.opcode() == spv::OpTypeArray) { - descriptor_count *= get_constant_value(module, type.word(3)); - type = module->get_def(type.word(2)); - } else { - if (type.word(2) == spv::StorageClassStorageBuffer) { - is_storage_buffer = true; - } - type = module->get_def(type.word(3)); - } - } - - switch (type.opcode()) { - case spv::OpTypeStruct: { - for (auto insn : *module) { - if (insn.opcode() == spv::OpDecorate && insn.word(1) == type.word(1)) { - if (insn.word(2) == spv::DecorationBlock) { - if (is_storage_buffer) { - return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || - descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; - } else { - return descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || - descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; - } - } else if (insn.word(2) == spv::DecorationBufferBlock) { - return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || - descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; - } - } - } - - // Invalid - return false; - } - - case spv::OpTypeSampler: - return descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLER || descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - - case spv::OpTypeSampledImage: - if (descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) { - // Slight relaxation for some GLSL historical madness: samplerBuffer doesn't really have a sampler, and a texel - // buffer descriptor doesn't really provide one. Allow this slight mismatch. - auto image_type = module->get_def(type.word(2)); - auto dim = image_type.word(3); - auto sampled = image_type.word(7); - return dim == spv::DimBuffer && sampled == 1; - } - return descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - - case spv::OpTypeImage: { - // Many descriptor types backing image types-- depends on dimension and whether the image will be used with a sampler. - // SPIRV for Vulkan requires that sampled be 1 or 2 -- leaving the decision to runtime is unacceptable. - auto dim = type.word(3); - auto sampled = type.word(7); - - if (dim == spv::DimSubpassData) { - return descriptor_type == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; - } else if (dim == spv::DimBuffer) { - if (sampled == 1) { - return descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; - } else { - return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; - } - } else if (sampled == 1) { - return descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || - descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - } else { - return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; - } - } - - // We shouldn't really see any other junk types -- but if we do, they're a mismatch. - default: - return false; // Mismatch - } -} - -static bool require_feature(debug_report_data const *report_data, VkBool32 feature, char const *feature_name) { - if (!feature) { - if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_FEATURE_NOT_ENABLED, "Shader requires %s but is not enabled on the device", feature_name)) { - return true; - } - } - - return false; -} - -static bool require_extension(debug_report_data const *report_data, bool extension, char const *extension_name) { - if (!extension) { - if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_FEATURE_NOT_ENABLED, "Shader requires extension %s but is not enabled on the device", - extension_name)) { - return true; - } - } - - return false; -} - -static bool validate_shader_capabilities(layer_data *dev_data, shader_module const *src, VkShaderStageFlagBits stage, - bool has_writable_descriptor) { - bool skip = false; - - auto report_data = GetReportData(dev_data); - auto const &enabledFeatures = GetEnabledFeatures(dev_data); - auto const &extensions = GetDeviceExtensions(dev_data); - auto const &descriptorIndexingFeatures = GetEnabledDescriptorIndexingFeatures(dev_data); - - struct CapabilityInfo { - char const *name; - VkBool32 const *feature; - bool const *extension; - }; - - // clang-format off - static const std::unordered_multimap capabilities = { - // Capabilities always supported by a Vulkan 1.0 implementation -- no - // feature bits. - {spv::CapabilityMatrix, {nullptr}}, - {spv::CapabilityShader, {nullptr}}, - {spv::CapabilityInputAttachment, {nullptr}}, - {spv::CapabilitySampled1D, {nullptr}}, - {spv::CapabilityImage1D, {nullptr}}, - {spv::CapabilitySampledBuffer, {nullptr}}, - {spv::CapabilityImageQuery, {nullptr}}, - {spv::CapabilityDerivativeControl, {nullptr}}, - - // Capabilities that are optionally supported, but require a feature to - // be enabled on the device - {spv::CapabilityGeometry, {"VkPhysicalDeviceFeatures::geometryShader", &enabledFeatures->geometryShader}}, - {spv::CapabilityTessellation, {"VkPhysicalDeviceFeatures::tessellationShader", &enabledFeatures->tessellationShader}}, - {spv::CapabilityFloat64, {"VkPhysicalDeviceFeatures::shaderFloat64", &enabledFeatures->shaderFloat64}}, - {spv::CapabilityInt64, {"VkPhysicalDeviceFeatures::shaderInt64", &enabledFeatures->shaderInt64}}, - {spv::CapabilityTessellationPointSize, {"VkPhysicalDeviceFeatures::shaderTessellationAndGeometryPointSize", &enabledFeatures->shaderTessellationAndGeometryPointSize}}, - {spv::CapabilityGeometryPointSize, {"VkPhysicalDeviceFeatures::shaderTessellationAndGeometryPointSize", &enabledFeatures->shaderTessellationAndGeometryPointSize}}, - {spv::CapabilityImageGatherExtended, {"VkPhysicalDeviceFeatures::shaderImageGatherExtended", &enabledFeatures->shaderImageGatherExtended}}, - {spv::CapabilityStorageImageMultisample, {"VkPhysicalDeviceFeatures::shaderStorageImageMultisample", &enabledFeatures->shaderStorageImageMultisample}}, - {spv::CapabilityUniformBufferArrayDynamicIndexing, {"VkPhysicalDeviceFeatures::shaderUniformBufferArrayDynamicIndexing", &enabledFeatures->shaderUniformBufferArrayDynamicIndexing}}, - {spv::CapabilitySampledImageArrayDynamicIndexing, {"VkPhysicalDeviceFeatures::shaderSampledImageArrayDynamicIndexing", &enabledFeatures->shaderSampledImageArrayDynamicIndexing}}, - {spv::CapabilityStorageBufferArrayDynamicIndexing, {"VkPhysicalDeviceFeatures::shaderStorageBufferArrayDynamicIndexing", &enabledFeatures->shaderStorageBufferArrayDynamicIndexing}}, - {spv::CapabilityStorageImageArrayDynamicIndexing, {"VkPhysicalDeviceFeatures::shaderStorageImageArrayDynamicIndexing", &enabledFeatures->shaderStorageBufferArrayDynamicIndexing}}, - {spv::CapabilityClipDistance, {"VkPhysicalDeviceFeatures::shaderClipDistance", &enabledFeatures->shaderClipDistance}}, - {spv::CapabilityCullDistance, {"VkPhysicalDeviceFeatures::shaderCullDistance", &enabledFeatures->shaderCullDistance}}, - {spv::CapabilityImageCubeArray, {"VkPhysicalDeviceFeatures::imageCubeArray", &enabledFeatures->imageCubeArray}}, - {spv::CapabilitySampleRateShading, {"VkPhysicalDeviceFeatures::sampleRateShading", &enabledFeatures->sampleRateShading}}, - {spv::CapabilitySparseResidency, {"VkPhysicalDeviceFeatures::shaderResourceResidency", &enabledFeatures->shaderResourceResidency}}, - {spv::CapabilityMinLod, {"VkPhysicalDeviceFeatures::shaderResourceMinLod", &enabledFeatures->shaderResourceMinLod}}, - {spv::CapabilitySampledCubeArray, {"VkPhysicalDeviceFeatures::imageCubeArray", &enabledFeatures->imageCubeArray}}, - {spv::CapabilityImageMSArray, {"VkPhysicalDeviceFeatures::shaderStorageImageMultisample", &enabledFeatures->shaderStorageImageMultisample}}, - {spv::CapabilityStorageImageExtendedFormats, {"VkPhysicalDeviceFeatures::shaderStorageImageExtendedFormats", &enabledFeatures->shaderStorageImageExtendedFormats}}, - {spv::CapabilityInterpolationFunction, {"VkPhysicalDeviceFeatures::sampleRateShading", &enabledFeatures->sampleRateShading}}, - {spv::CapabilityStorageImageReadWithoutFormat, {"VkPhysicalDeviceFeatures::shaderStorageImageReadWithoutFormat", &enabledFeatures->shaderStorageImageReadWithoutFormat}}, - {spv::CapabilityStorageImageWriteWithoutFormat, {"VkPhysicalDeviceFeatures::shaderStorageImageWriteWithoutFormat", &enabledFeatures->shaderStorageImageWriteWithoutFormat}}, - {spv::CapabilityMultiViewport, {"VkPhysicalDeviceFeatures::multiViewport", &enabledFeatures->multiViewport}}, - - // XXX TODO: Descriptor indexing capability enums are not yet available in the spirv-tools we fetch. -#define CapabilityShaderNonUniformEXT 5301 -#define CapabilityRuntimeDescriptorArrayEXT 5302 -#define CapabilityInputAttachmentArrayDynamicIndexingEXT 5303 -#define CapabilityUniformTexelBufferArrayDynamicIndexingEXT 5304 -#define CapabilityStorageTexelBufferArrayDynamicIndexingEXT 5305 -#define CapabilityUniformBufferArrayNonUniformIndexingEXT 5306 -#define CapabilitySampledImageArrayNonUniformIndexingEXT 5307 -#define CapabilityStorageBufferArrayNonUniformIndexingEXT 5308 -#define CapabilityStorageImageArrayNonUniformIndexingEXT 5309 -#define CapabilityInputAttachmentArrayNonUniformIndexingEXT 5310 -#define CapabilityUniformTexelBufferArrayNonUniformIndexingEXT 5311 -#define CapabilityStorageTexelBufferArrayNonUniformIndexingEXT 5312 - {CapabilityShaderNonUniformEXT, {VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, nullptr, &extensions->vk_ext_descriptor_indexing}}, - {CapabilityRuntimeDescriptorArrayEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::runtimeDescriptorArray", &descriptorIndexingFeatures->runtimeDescriptorArray}}, - {CapabilityInputAttachmentArrayDynamicIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderInputAttachmentArrayDynamicIndexing", &descriptorIndexingFeatures->shaderInputAttachmentArrayDynamicIndexing}}, - {CapabilityUniformTexelBufferArrayDynamicIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderUniformTexelBufferArrayDynamicIndexing", &descriptorIndexingFeatures->shaderUniformTexelBufferArrayDynamicIndexing}}, - {CapabilityStorageTexelBufferArrayDynamicIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderStorageTexelBufferArrayDynamicIndexing", &descriptorIndexingFeatures->shaderStorageTexelBufferArrayDynamicIndexing}}, - {CapabilityUniformBufferArrayNonUniformIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderUniformBufferArrayNonUniformIndexing", &descriptorIndexingFeatures->shaderUniformBufferArrayNonUniformIndexing}}, - {CapabilitySampledImageArrayNonUniformIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderSampledImageArrayNonUniformIndexing", &descriptorIndexingFeatures->shaderSampledImageArrayNonUniformIndexing}}, - {CapabilityStorageBufferArrayNonUniformIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderStorageBufferArrayNonUniformIndexing", &descriptorIndexingFeatures->shaderStorageBufferArrayNonUniformIndexing}}, - {CapabilityStorageImageArrayNonUniformIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderStorageImageArrayNonUniformIndexing", &descriptorIndexingFeatures->shaderStorageImageArrayNonUniformIndexing}}, - {CapabilityInputAttachmentArrayNonUniformIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderInputAttachmentArrayNonUniformIndexing", &descriptorIndexingFeatures->shaderInputAttachmentArrayNonUniformIndexing}}, - {CapabilityUniformTexelBufferArrayNonUniformIndexingEXT, {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderUniformTexelBufferArrayNonUniformIndexing", &descriptorIndexingFeatures->shaderUniformTexelBufferArrayNonUniformIndexing}}, - {CapabilityStorageTexelBufferArrayNonUniformIndexingEXT , {"VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderStorageTexelBufferArrayNonUniformIndexing", &descriptorIndexingFeatures->shaderStorageTexelBufferArrayNonUniformIndexing}}, - - // Capabilities that require an extension - {spv::CapabilityDrawParameters, {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, nullptr, &extensions->vk_khr_shader_draw_parameters}}, - {spv::CapabilityGeometryShaderPassthroughNV, {VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME, nullptr, &extensions->vk_nv_geometry_shader_passthrough}}, - {spv::CapabilitySampleMaskOverrideCoverageNV, {VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME, nullptr, &extensions->vk_nv_sample_mask_override_coverage}}, - {spv::CapabilityShaderViewportIndexLayerEXT, {VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME, nullptr, &extensions->vk_ext_shader_viewport_index_layer}}, - {spv::CapabilityShaderViewportIndexLayerNV, {VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, nullptr, &extensions->vk_nv_viewport_array2}}, - {spv::CapabilityShaderViewportMaskNV, {VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, nullptr, &extensions->vk_nv_viewport_array2}}, - {spv::CapabilitySubgroupBallotKHR, {VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME, nullptr, &extensions->vk_ext_shader_subgroup_ballot }}, - {spv::CapabilitySubgroupVoteKHR, {VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, nullptr, &extensions->vk_ext_shader_subgroup_vote }}, - }; - // clang-format on - - for (auto insn : *src) { - if (insn.opcode() == spv::OpCapability) { - size_t n = capabilities.count(insn.word(1)); - if (1 == n) { // key occurs exactly once - auto it = capabilities.find(insn.word(1)); - if (it != capabilities.end()) { - if (it->second.feature) { - skip |= require_feature(report_data, *(it->second.feature), it->second.name); - } - if (it->second.extension) { - skip |= require_extension(report_data, *(it->second.extension), it->second.name); - } - } - } else if (1 < n) { // key occurs multiple times, at least one must be enabled - bool needs_feature = false, has_feature = false; - bool needs_ext = false, has_ext = false; - std::string feature_names = "(one of) [ "; - std::string extension_names = feature_names; - auto caps = capabilities.equal_range(insn.word(1)); - for (auto it = caps.first; it != caps.second; ++it) { - if (it->second.feature) { - needs_feature = true; - has_feature = has_feature || *(it->second.feature); - feature_names += it->second.name; - feature_names += " "; - } - if (it->second.extension) { - needs_ext = true; - has_ext = has_ext || *(it->second.extension); - extension_names += it->second.name; - extension_names += " "; - } - } - if (needs_feature) { - feature_names += "]"; - skip |= require_feature(report_data, has_feature, feature_names.c_str()); - } - if (needs_ext) { - extension_names += "]"; - skip |= require_extension(report_data, has_ext, extension_names.c_str()); - } - } - } - } - - if (has_writable_descriptor) { - switch (stage) { - case VK_SHADER_STAGE_COMPUTE_BIT: - /* No feature requirements for writes and atomics from compute - * stage */ - break; - case VK_SHADER_STAGE_FRAGMENT_BIT: - skip |= require_feature(report_data, enabledFeatures->fragmentStoresAndAtomics, "fragmentStoresAndAtomics"); - break; - default: - skip |= - require_feature(report_data, enabledFeatures->vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics"); - break; - } - } - - return skip; -} - -static uint32_t descriptor_type_to_reqs(shader_module const *module, uint32_t type_id) { - auto type = module->get_def(type_id); - - while (true) { - switch (type.opcode()) { - case spv::OpTypeArray: - case spv::OpTypeSampledImage: - type = module->get_def(type.word(2)); - break; - case spv::OpTypePointer: - type = module->get_def(type.word(3)); - break; - case spv::OpTypeImage: { - auto dim = type.word(3); - auto arrayed = type.word(5); - auto msaa = type.word(6); - - switch (dim) { - case spv::Dim1D: - return arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_1D_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_1D; - case spv::Dim2D: - return (msaa ? DESCRIPTOR_REQ_MULTI_SAMPLE : DESCRIPTOR_REQ_SINGLE_SAMPLE) | - (arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_2D_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_2D); - case spv::Dim3D: - return DESCRIPTOR_REQ_VIEW_TYPE_3D; - case spv::DimCube: - return arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_CUBE_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_CUBE; - case spv::DimSubpassData: - return msaa ? DESCRIPTOR_REQ_MULTI_SAMPLE : DESCRIPTOR_REQ_SINGLE_SAMPLE; - default: // buffer, etc. - return 0; - } - } - default: - return 0; - } - } -} - -// For given pipelineLayout verify that the set_layout_node at slot.first -// has the requested binding at slot.second and return ptr to that binding -static VkDescriptorSetLayoutBinding const *get_descriptor_binding(PIPELINE_LAYOUT_NODE const *pipelineLayout, - descriptor_slot_t slot) { - if (!pipelineLayout) return nullptr; - - if (slot.first >= pipelineLayout->set_layouts.size()) return nullptr; - - return pipelineLayout->set_layouts[slot.first]->GetDescriptorSetLayoutBindingPtrFromBinding(slot.second); -} - -static void process_execution_modes(shader_module const *src, spirv_inst_iter entrypoint, PIPELINE_STATE *pipeline) { - auto entrypoint_id = entrypoint.word(1); - bool is_point_mode = false; - - for (auto insn : *src) { - if (insn.opcode() == spv::OpExecutionMode && insn.word(1) == entrypoint_id) { - switch (insn.word(2)) { - case spv::ExecutionModePointMode: - // In tessellation shaders, PointMode is separate and trumps the tessellation topology. - is_point_mode = true; - break; - - case spv::ExecutionModeOutputPoints: - pipeline->topology_at_rasterizer = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; - break; - - case spv::ExecutionModeIsolines: - case spv::ExecutionModeOutputLineStrip: - pipeline->topology_at_rasterizer = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; - break; - - case spv::ExecutionModeTriangles: - case spv::ExecutionModeQuads: - case spv::ExecutionModeOutputTriangleStrip: - pipeline->topology_at_rasterizer = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - break; - } - } - } - - if (is_point_mode) pipeline->topology_at_rasterizer = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; -} - -static bool validate_pipeline_shader_stage(layer_data *dev_data, VkPipelineShaderStageCreateInfo const *pStage, - PIPELINE_STATE *pipeline, shader_module const **out_module, - spirv_inst_iter *out_entrypoint) { - bool skip = false; - auto module = *out_module = GetShaderModuleState(dev_data, pStage->module); - auto report_data = GetReportData(dev_data); - - if (!module->has_valid_spirv) return false; - - // Find the entrypoint - auto entrypoint = *out_entrypoint = find_entrypoint(module, pStage->pName, pStage->stage); - if (entrypoint == module->end()) { - if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_10600586, "No entrypoint found named `%s` for stage %s..", pStage->pName, - string_VkShaderStageFlagBits(pStage->stage))) { - return true; // no point continuing beyond here, any analysis is just going to be garbage. - } - } - - // Mark accessible ids - auto accessible_ids = mark_accessible_ids(module, entrypoint); - process_execution_modes(module, entrypoint, pipeline); - - // Validate descriptor set layout against what the entrypoint actually uses - bool has_writable_descriptor = false; - auto descriptor_uses = collect_interface_by_descriptor_slot(report_data, module, accessible_ids, &has_writable_descriptor); - - // Validate shader capabilities against enabled device features - skip |= validate_shader_capabilities(dev_data, module, pStage->stage, has_writable_descriptor); - - skip |= validate_specialization_offsets(report_data, pStage); - skip |= validate_push_constant_usage(report_data, pipeline->pipeline_layout.push_constant_ranges.get(), module, accessible_ids, - pStage->stage); - - // Validate descriptor use - for (auto use : descriptor_uses) { - // While validating shaders capture which slots are used by the pipeline - auto &reqs = pipeline->active_slots[use.first.first][use.first.second]; - reqs = descriptor_req(reqs | descriptor_type_to_reqs(module, use.second.type_id)); - - // Verify given pipelineLayout has requested setLayout with requested binding - const auto &binding = get_descriptor_binding(&pipeline->pipeline_layout, use.first); - unsigned required_descriptor_count; - - if (!binding) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_MISSING_DESCRIPTOR, - "Shader uses descriptor slot %u.%u (used as type `%s`) but not declared in pipeline layout", - use.first.first, use.first.second, describe_type(module, use.second.type_id).c_str()); - } else if (~binding->stageFlags & pStage->stage) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, - SHADER_CHECKER_DESCRIPTOR_NOT_ACCESSIBLE_FROM_STAGE, - "Shader uses descriptor slot %u.%u (used as type `%s`) but descriptor not accessible from stage %s", - use.first.first, use.first.second, describe_type(module, use.second.type_id).c_str(), - string_VkShaderStageFlagBits(pStage->stage)); - } else if (!descriptor_type_match(module, use.second.type_id, binding->descriptorType, required_descriptor_count)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_DESCRIPTOR_TYPE_MISMATCH, - "Type mismatch on descriptor slot %u.%u (used as type `%s`) but descriptor of type %s", use.first.first, - use.first.second, describe_type(module, use.second.type_id).c_str(), - string_VkDescriptorType(binding->descriptorType)); - } else if (binding->descriptorCount < required_descriptor_count) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_DESCRIPTOR_TYPE_MISMATCH, - "Shader expects at least %u descriptors for binding %u.%u (used as type `%s`) but only %u provided", - required_descriptor_count, use.first.first, use.first.second, - describe_type(module, use.second.type_id).c_str(), binding->descriptorCount); - } - } - - // Validate use of input attachments against subpass structure - if (pStage->stage == VK_SHADER_STAGE_FRAGMENT_BIT) { - auto input_attachment_uses = collect_interface_by_input_attachment_index(module, accessible_ids); - - auto rpci = pipeline->rp_state->createInfo.ptr(); - auto subpass = pipeline->graphicsPipelineCI.subpass; - - for (auto use : input_attachment_uses) { - auto input_attachments = rpci->pSubpasses[subpass].pInputAttachments; - auto index = (input_attachments && use.first < rpci->pSubpasses[subpass].inputAttachmentCount) - ? input_attachments[use.first].attachment - : VK_ATTACHMENT_UNUSED; - - if (index == VK_ATTACHMENT_UNUSED) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_MISSING_INPUT_ATTACHMENT, - "Shader consumes input attachment index %d but not provided in subpass", use.first); - } else if (!(get_format_type(rpci->pAttachments[index].format) & get_fundamental_type(module, use.second.type_id))) { - skip |= - log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_INPUT_ATTACHMENT_TYPE_MISMATCH, - "Subpass input attachment %u format of %s does not match type used in shader `%s`", use.first, - string_VkFormat(rpci->pAttachments[index].format), describe_type(module, use.second.type_id).c_str()); - } - } - } - - return skip; -} - -static bool validate_interface_between_stages(debug_report_data const *report_data, shader_module const *producer, - spirv_inst_iter producer_entrypoint, shader_stage_attributes const *producer_stage, - shader_module const *consumer, spirv_inst_iter consumer_entrypoint, - shader_stage_attributes const *consumer_stage) { - bool skip = false; - - auto outputs = - collect_interface_by_location(producer, producer_entrypoint, spv::StorageClassOutput, producer_stage->arrayed_output); - auto inputs = - collect_interface_by_location(consumer, consumer_entrypoint, spv::StorageClassInput, consumer_stage->arrayed_input); - - auto a_it = outputs.begin(); - auto b_it = inputs.begin(); - - // Maps sorted by key (location); walk them together to find mismatches - while ((outputs.size() > 0 && a_it != outputs.end()) || (inputs.size() && b_it != inputs.end())) { - bool a_at_end = outputs.size() == 0 || a_it == outputs.end(); - bool b_at_end = inputs.size() == 0 || b_it == inputs.end(); - auto a_first = a_at_end ? std::make_pair(0u, 0u) : a_it->first; - auto b_first = b_at_end ? std::make_pair(0u, 0u) : b_it->first; - - if (b_at_end || ((!a_at_end) && (a_first < b_first))) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "%s writes to output location %u.%u which is not consumed by %s", - producer_stage->name, a_first.first, a_first.second, consumer_stage->name); - a_it++; - } else if (a_at_end || a_first > b_first) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_INPUT_NOT_PRODUCED, "%s consumes input location %u.%u which is not written by %s", - consumer_stage->name, b_first.first, b_first.second, producer_stage->name); - b_it++; - } else { - // subtleties of arrayed interfaces: - // - if is_patch, then the member is not arrayed, even though the interface may be. - // - if is_block_member, then the extra array level of an arrayed interface is not - // expressed in the member type -- it's expressed in the block type. - if (!types_match(producer, consumer, a_it->second.type_id, b_it->second.type_id, - producer_stage->arrayed_output && !a_it->second.is_patch && !a_it->second.is_block_member, - consumer_stage->arrayed_input && !b_it->second.is_patch && !b_it->second.is_block_member, true)) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "Type mismatch on location %u.%u: '%s' vs '%s'", - a_first.first, a_first.second, describe_type(producer, a_it->second.type_id).c_str(), - describe_type(consumer, b_it->second.type_id).c_str()); - } - if (a_it->second.is_patch != b_it->second.is_patch) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, - SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, - "Decoration mismatch on location %u.%u: is per-%s in %s stage but per-%s in %s stage", - a_first.first, a_first.second, a_it->second.is_patch ? "patch" : "vertex", producer_stage->name, - b_it->second.is_patch ? "patch" : "vertex", consumer_stage->name); - } - if (a_it->second.is_relaxed_precision != b_it->second.is_relaxed_precision) { - skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, - SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, - "Decoration mismatch on location %u.%u: %s and %s stages differ in precision", a_first.first, - a_first.second, producer_stage->name, consumer_stage->name); - } - a_it++; - b_it++; - } - } - - return skip; -} - -// Validate that the shaders used by the given pipeline and store the active_slots -// that are actually used by the pipeline into pPipeline->active_slots -bool validate_and_capture_pipeline_shader_state(layer_data *dev_data, PIPELINE_STATE *pipeline) { - auto pCreateInfo = pipeline->graphicsPipelineCI.ptr(); - int vertex_stage = get_shader_stage_id(VK_SHADER_STAGE_VERTEX_BIT); - int fragment_stage = get_shader_stage_id(VK_SHADER_STAGE_FRAGMENT_BIT); - auto report_data = GetReportData(dev_data); - - shader_module const *shaders[5]; - memset(shaders, 0, sizeof(shaders)); - spirv_inst_iter entrypoints[5]; - memset(entrypoints, 0, sizeof(entrypoints)); - bool skip = false; - - for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) { - auto pStage = &pCreateInfo->pStages[i]; - auto stage_id = get_shader_stage_id(pStage->stage); - skip |= validate_pipeline_shader_stage(dev_data, pStage, pipeline, &shaders[stage_id], &entrypoints[stage_id]); - } - - // if the shader stages are no good individually, cross-stage validation is pointless. - if (skip) return true; - - auto vi = pCreateInfo->pVertexInputState; - - if (vi) { - skip |= validate_vi_consistency(report_data, vi); - } - - if (shaders[vertex_stage] && shaders[vertex_stage]->has_valid_spirv) { - skip |= validate_vi_against_vs_inputs(report_data, vi, shaders[vertex_stage], entrypoints[vertex_stage]); - } - - int producer = get_shader_stage_id(VK_SHADER_STAGE_VERTEX_BIT); - int consumer = get_shader_stage_id(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT); - - while (!shaders[producer] && producer != fragment_stage) { - producer++; - consumer++; - } - - for (; producer != fragment_stage && consumer <= fragment_stage; consumer++) { - assert(shaders[producer]); - if (shaders[consumer]) { - if (shaders[consumer]->has_valid_spirv && shaders[producer]->has_valid_spirv) { - skip |= validate_interface_between_stages(report_data, shaders[producer], entrypoints[producer], - &shader_stage_attribs[producer], shaders[consumer], entrypoints[consumer], - &shader_stage_attribs[consumer]); - } - - producer = consumer; - } - } - - if (shaders[fragment_stage] && shaders[fragment_stage]->has_valid_spirv) { - skip |= validate_fs_outputs_against_render_pass(report_data, shaders[fragment_stage], entrypoints[fragment_stage], pipeline, - pCreateInfo->subpass); - } - - return skip; -} - -bool validate_compute_pipeline(layer_data *dev_data, PIPELINE_STATE *pipeline) { - auto pCreateInfo = pipeline->computePipelineCI.ptr(); - - shader_module const *module; - spirv_inst_iter entrypoint; - - return validate_pipeline_shader_stage(dev_data, &pCreateInfo->stage, pipeline, &module, &entrypoint); -} - -uint32_t ValidationCache::MakeShaderHash(VkShaderModuleCreateInfo const *smci) { return XXH32(smci->pCode, smci->codeSize, 0); } - -static ValidationCache *GetValidationCacheInfo(VkShaderModuleCreateInfo const *pCreateInfo) { - while ((pCreateInfo = (VkShaderModuleCreateInfo const *)pCreateInfo->pNext) != nullptr) { - if (pCreateInfo->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT) - return (ValidationCache *)((VkShaderModuleValidationCacheCreateInfoEXT const *)pCreateInfo)->validationCache; - } - - return nullptr; -} - -bool PreCallValidateCreateShaderModule(layer_data *dev_data, VkShaderModuleCreateInfo const *pCreateInfo, bool *spirv_valid) { - bool skip = false; - spv_result_t spv_valid = SPV_SUCCESS; - auto report_data = GetReportData(dev_data); - - if (GetDisables(dev_data)->shader_validation) { - return false; - } - - auto have_glsl_shader = GetDeviceExtensions(dev_data)->vk_nv_glsl_shader; - - if (!have_glsl_shader && (pCreateInfo->codeSize % 4)) { - skip |= log_msg( - report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, VALIDATION_ERROR_12a00ac0, - "SPIR-V module not valid: Codesize must be a multiple of 4 but is " PRINTF_SIZE_T_SPECIFIER ".", pCreateInfo->codeSize); - } else { - auto cache = GetValidationCacheInfo(pCreateInfo); - uint32_t hash = 0; - if (cache) { - hash = ValidationCache::MakeShaderHash(pCreateInfo); - if (cache->Contains(hash)) return false; - } - - // Use SPIRV-Tools validator to try and catch any issues with the module itself - spv_context ctx = spvContextCreate(SPV_ENV_VULKAN_1_0); - spv_const_binary_t binary{pCreateInfo->pCode, pCreateInfo->codeSize / sizeof(uint32_t)}; - spv_diagnostic diag = nullptr; - - spv_valid = spvValidate(ctx, &binary, &diag); - if (spv_valid != SPV_SUCCESS) { - if (!have_glsl_shader || (pCreateInfo->pCode[0] == spv::MagicNumber)) { - skip |= - log_msg(report_data, spv_valid == SPV_WARNING ? VK_DEBUG_REPORT_WARNING_BIT_EXT : VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, SHADER_CHECKER_INCONSISTENT_SPIRV, - "SPIR-V module not valid: %s", diag && diag->error ? diag->error : "(no error text)"); - } - } else { - if (cache) { - cache->Insert(hash); - } - } - - spvDiagnosticDestroy(diag); - spvContextDestroy(ctx); - } - - *spirv_valid = (spv_valid == SPV_SUCCESS); - return skip; -} diff --git a/layers/shader_validation.h b/layers/shader_validation.h deleted file mode 100644 index 10d97655..00000000 --- a/layers/shader_validation.h +++ /dev/null @@ -1,200 +0,0 @@ -/* 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: Chris Forbes - */ -#ifndef VULKAN_SHADER_VALIDATION_H -#define VULKAN_SHADER_VALIDATION_H - -#include - -// A forward iterator over spirv instructions. Provides easy access to len, opcode, and content words -// without the caller needing to care too much about the physical SPIRV module layout. -struct spirv_inst_iter { - std::vector::const_iterator zero; - std::vector::const_iterator it; - - uint32_t len() { - auto result = *it >> 16; - assert(result > 0); - return result; - } - - uint32_t opcode() { return *it & 0x0ffffu; } - - uint32_t const &word(unsigned n) { - assert(n < len()); - return it[n]; - } - - uint32_t offset() { return (uint32_t)(it - zero); } - - spirv_inst_iter() {} - - spirv_inst_iter(std::vector::const_iterator zero, std::vector::const_iterator it) : zero(zero), it(it) {} - - bool operator==(spirv_inst_iter const &other) { return it == other.it; } - - bool operator!=(spirv_inst_iter const &other) { return it != other.it; } - - spirv_inst_iter operator++(int) { // x++ - spirv_inst_iter ii = *this; - it += len(); - return ii; - } - - spirv_inst_iter operator++() { // ++x; - it += len(); - return *this; - } - - // The iterator and the value are the same thing. - spirv_inst_iter &operator*() { return *this; } - spirv_inst_iter const &operator*() const { return *this; } -}; - -struct shader_module { - // The spirv image itself - std::vector words; - // A mapping of to the first word of its def. this is useful because walking type - // trees, constant expressions, etc requires jumping all over the instruction stream. - std::unordered_map def_index; - bool has_valid_spirv; - - shader_module(VkShaderModuleCreateInfo const *pCreateInfo) - : words((uint32_t *)pCreateInfo->pCode, (uint32_t *)pCreateInfo->pCode + pCreateInfo->codeSize / sizeof(uint32_t)), - def_index(), - has_valid_spirv(true) { - build_def_index(); - } - - shader_module() : has_valid_spirv(false) {} - - // Expose begin() / end() to enable range-based for - spirv_inst_iter begin() const { return spirv_inst_iter(words.begin(), words.begin() + 5); } // First insn - spirv_inst_iter end() const { return spirv_inst_iter(words.begin(), words.end()); } // Just past last insn - // Given an offset into the module, produce an iterator there. - spirv_inst_iter at(unsigned offset) const { return spirv_inst_iter(words.begin(), words.begin() + offset); } - - // Gets an iterator to the definition of an id - spirv_inst_iter get_def(unsigned id) const { - auto it = def_index.find(id); - if (it == def_index.end()) { - return end(); - } - return at(it->second); - } - - void build_def_index(); -}; - -class ValidationCache { - // hashes of shaders that have passed validation before, and can be skipped. - // we don't store negative results, as we would have to also store what was - // wrong with them; also, we expect they will get fixed, so we're less - // likely to see them again. - std::unordered_set good_shader_hashes; - ValidationCache() {} - - public: - static VkValidationCacheEXT Create(VkValidationCacheCreateInfoEXT const *pCreateInfo) { - auto cache = new ValidationCache(); - cache->Load(pCreateInfo); - return VkValidationCacheEXT(cache); - } - - void Load(VkValidationCacheCreateInfoEXT const *pCreateInfo) { - const auto headerSize = 2 * sizeof(uint32_t) + VK_UUID_SIZE; - auto size = headerSize; - if (!pCreateInfo->pInitialData || pCreateInfo->initialDataSize < size) return; - - uint32_t const *data = (uint32_t const *)pCreateInfo->pInitialData; - if (data[0] != size) return; - if (data[1] != VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT) return; - uint8_t expected_uuid[VK_UUID_SIZE]; - Sha1ToVkUuid(SPIRV_TOOLS_COMMIT_ID, expected_uuid); - if (memcmp(&data[2], expected_uuid, VK_UUID_SIZE) != 0) return; // different version - - data = (uint32_t const *)(reinterpret_cast(data) + headerSize); - - for (; size < pCreateInfo->initialDataSize; data++, size += sizeof(uint32_t)) { - good_shader_hashes.insert(*data); - } - } - - void Write(size_t *pDataSize, void *pData) { - const auto headerSize = 2 * sizeof(uint32_t) + VK_UUID_SIZE; // 4 bytes for header size + 4 bytes for version number + UUID - if (!pData) { - *pDataSize = headerSize + good_shader_hashes.size() * sizeof(uint32_t); - return; - } - - if (*pDataSize < headerSize) { - *pDataSize = 0; - return; // Too small for even the header! - } - - uint32_t *out = (uint32_t *)pData; - size_t actualSize = headerSize; - - // Write the header - *out++ = headerSize; - *out++ = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT; - Sha1ToVkUuid(SPIRV_TOOLS_COMMIT_ID, reinterpret_cast(out)); - out = (uint32_t *)(reinterpret_cast(out) + VK_UUID_SIZE); - - for (auto it = good_shader_hashes.begin(); it != good_shader_hashes.end() && actualSize < *pDataSize; - it++, out++, actualSize += sizeof(uint32_t)) { - *out = *it; - } - - *pDataSize = actualSize; - } - - void Merge(ValidationCache const *other) { - good_shader_hashes.reserve(good_shader_hashes.size() + other->good_shader_hashes.size()); - for (auto h : other->good_shader_hashes) good_shader_hashes.insert(h); - } - - static uint32_t MakeShaderHash(VkShaderModuleCreateInfo const *smci); - - bool Contains(uint32_t hash) { return good_shader_hashes.count(hash) != 0; } - - void Insert(uint32_t hash) { good_shader_hashes.insert(hash); } - - private: - void Sha1ToVkUuid(const char *sha1_str, uint8_t uuid[VK_UUID_SIZE]) { - // Convert sha1_str from a hex string to binary. We only need VK_UUID_BYTES of - // output, so pad with zeroes if the input string is shorter than that, and truncate - // if it's longer. - char padded_sha1_str[2 * VK_UUID_SIZE + 1] = {}; - strncpy(padded_sha1_str, sha1_str, 2 * VK_UUID_SIZE + 1); - char byte_str[3] = {}; - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - byte_str[0] = padded_sha1_str[2 * i + 0]; - byte_str[1] = padded_sha1_str[2 * i + 1]; - uuid[i] = static_cast(strtol(byte_str, NULL, 16)); - } - } -}; - -bool validate_and_capture_pipeline_shader_state(layer_data *dev_data, PIPELINE_STATE *pPipeline); -bool validate_compute_pipeline(layer_data *dev_data, PIPELINE_STATE *pPipeline); -typedef std::pair descriptor_slot_t; -bool PreCallValidateCreateShaderModule(layer_data *dev_data, VkShaderModuleCreateInfo const *pCreateInfo, bool *spirv_valid); - -#endif // VULKAN_SHADER_VALIDATION_H diff --git a/layers/threading.cpp b/layers/threading.cpp deleted file mode 100644 index ce5f8e3e..00000000 --- a/layers/threading.cpp +++ /dev/null @@ -1,566 +0,0 @@ -/* - * Vulkan - * - * Copyright (C) 2015 Valve, Inc. - * Copyright (C) 2016 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. - */ -#include -#include -#include -#include -#include - -#include "vk_loader_platform.h" -#include "vulkan/vk_layer.h" -#include "vk_layer_config.h" -#include "vk_layer_extension_utils.h" -#include "vk_layer_utils.h" -#include "vk_layer_table.h" -#include "vk_layer_logging.h" -#include "threading.h" -#include "vk_dispatch_table_helper.h" -#include "vk_enum_string_helper.h" -#include "vk_layer_data.h" -#include "vk_layer_utils.h" - -#include "thread_check.h" - -namespace threading { - -static uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - -static void initThreading(layer_data *my_data, const VkAllocationCallbacks *pAllocator) { - layer_debug_report_actions(my_data->report_data, my_data->logging_callback, pAllocator, "google_threading"); - layer_debug_messenger_actions(my_data->report_data, my_data->logging_messenger, pAllocator, "google_threading"); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) { - VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); - if (fpCreateInstance == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); - if (result != VK_SUCCESS) return result; - - layer_data *my_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map); - my_data->instance = *pInstance; - my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable; - layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr); - - my_data->report_data = debug_utils_create_instance(my_data->instance_dispatch_table, *pInstance, - pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames); - initThreading(my_data, pAllocator); - - // Look for one or more debug report create info structures, and copy the - // callback(s) for each one found (for use by vkDestroyInstance) - layer_copy_tmp_debug_messengers(pCreateInfo->pNext, &my_data->num_tmp_debug_messengers, &my_data->tmp_messenger_create_infos, - &my_data->tmp_debug_messengers); - layer_copy_tmp_report_callbacks(pCreateInfo->pNext, &my_data->num_tmp_report_callbacks, &my_data->tmp_report_create_infos, - &my_data->tmp_report_callbacks); - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - dispatch_key key = get_dispatch_key(instance); - layer_data *my_data = GetLayerDataPtr(key, layer_data_map); - VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; - - // Enable the temporary callback(s) here to catch cleanup issues: - bool callback_setup = false; - if (my_data->num_tmp_debug_messengers > 0) { - if (!layer_enable_tmp_debug_messengers(my_data->report_data, my_data->num_tmp_debug_messengers, - my_data->tmp_messenger_create_infos, my_data->tmp_debug_messengers)) { - callback_setup = true; - } - } - if (my_data->num_tmp_report_callbacks > 0) { - if (!layer_enable_tmp_report_callbacks(my_data->report_data, my_data->num_tmp_report_callbacks, - my_data->tmp_report_create_infos, my_data->tmp_report_callbacks)) { - callback_setup = true; - } - } - - bool threadChecks = startMultiThread(); - if (threadChecks) { - startWriteObject(my_data, instance); - } - pTable->DestroyInstance(instance, pAllocator); - if (threadChecks) { - finishWriteObject(my_data, instance); - } else { - finishMultiThread(); - } - - // Disable and cleanup the temporary callback(s): - if (callback_setup) { - layer_disable_tmp_debug_messengers(my_data->report_data, my_data->num_tmp_debug_messengers, my_data->tmp_debug_messengers); - layer_disable_tmp_report_callbacks(my_data->report_data, my_data->num_tmp_report_callbacks, my_data->tmp_report_callbacks); - } - if (my_data->num_tmp_debug_messengers > 0) { - layer_free_tmp_debug_messengers(my_data->tmp_messenger_create_infos, my_data->tmp_debug_messengers); - my_data->num_tmp_debug_messengers = 0; - } - if (my_data->num_tmp_report_callbacks > 0) { - layer_free_tmp_report_callbacks(my_data->tmp_report_create_infos, my_data->tmp_report_callbacks); - my_data->num_tmp_report_callbacks = 0; - } - - // Clean up logging callbacks, if any - while (my_data->logging_messenger.size() > 0) { - VkDebugUtilsMessengerEXT messenger = my_data->logging_messenger.back(); - layer_destroy_messenger_callback(my_data->report_data, messenger, pAllocator); - my_data->logging_messenger.pop_back(); - } - while (my_data->logging_callback.size() > 0) { - VkDebugReportCallbackEXT callback = my_data->logging_callback.back(); - layer_destroy_report_callback(my_data->report_data, callback, pAllocator); - my_data->logging_callback.pop_back(); - } - - layer_debug_utils_destroy_instance(my_data->report_data); - delete my_data->instance_dispatch_table; - FreeLayerDataPtr(key, layer_data_map); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map); - VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(my_instance_data->instance, "vkCreateDevice"); - if (fpCreateDevice == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); - if (result != VK_SUCCESS) { - return result; - } - - layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); - - // Setup device dispatch table - my_device_data->device_dispatch_table = new VkLayerDispatchTable; - layer_init_device_dispatch_table(*pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr); - - my_device_data->report_data = layer_debug_utils_create_device(my_instance_data->report_data, *pDevice); - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { - dispatch_key key = get_dispatch_key(device); - layer_data *dev_data = GetLayerDataPtr(key, layer_data_map); - bool threadChecks = startMultiThread(); - if (threadChecks) { - startWriteObject(dev_data, device); - } - dev_data->device_dispatch_table->DestroyDevice(device, pAllocator); - if (threadChecks) { - finishWriteObject(dev_data, device); - } else { - finishMultiThread(); - } - - delete dev_data->device_dispatch_table; - FreeLayerDataPtr(key, layer_data_map); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, - VkImage *pSwapchainImages) { - dispatch_key key = get_dispatch_key(device); - layer_data *my_data = GetLayerDataPtr(key, layer_data_map); - VkLayerDispatchTable *pTable = my_data->device_dispatch_table; - VkResult result; - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, device); - startReadObject(my_data, swapchain); - } - result = pTable->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); - if (threadChecks) { - finishReadObject(my_data, device); - finishReadObject(my_data, swapchain); - } else { - finishMultiThread(); - } - return result; -} - -static const VkExtensionProperties threading_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}, - {VK_EXT_DEBUG_UTILS_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_SPEC_VERSION}}; - -static const VkLayerProperties layerProps = { - "VK_LAYER_GOOGLE_threading", - VK_LAYER_API_VERSION, // specVersion - 1, - "Google Validation Layer", -}; - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &layerProps, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &layerProps, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, layerProps.layerName)) - return util_GetExtensionProperties(1, threading_extensions, pCount, pProperties); - - return VK_ERROR_LAYER_NOT_PRESENT; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, - uint32_t *pCount, VkExtensionProperties *pProperties) { - // Threading layer does not have any device extensions - if (pLayerName && !strcmp(pLayerName, layerProps.layerName)) - return util_GetExtensionProperties(0, nullptr, pCount, pProperties); - - assert(physicalDevice); - - dispatch_key key = get_dispatch_key(physicalDevice); - layer_data *my_data = GetLayerDataPtr(key, layer_data_map); - return my_data->instance_dispatch_table->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties); -} - -// Need to prototype this call because it's internal and does not show up in vk.xml -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - auto &table = device_data->device_dispatch_table; - if (!table->GetDeviceProcAddr) return nullptr; - return table->GetDeviceProcAddr(device, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - auto &table = instance_data->instance_dispatch_table; - if (!table->GetInstanceProcAddr) return nullptr; - return table->GetInstanceProcAddr(instance, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { - assert(instance); - - layer_data *my_data; - my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; - - if (pTable->GetPhysicalDeviceProcAddr == NULL) return NULL; - return pTable->GetPhysicalDeviceProcAddr(instance, funcName); -} - -// VK_EXT_debug_utils commands -VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger) { - layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, instance); - } - VkResult result = my_data->instance_dispatch_table->CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); - - if (VK_SUCCESS == result) { - result = layer_create_messenger_callback(my_data->report_data, false, pCreateInfo, pAllocator, pMessenger); - // If something happened during this call, clean up the message callback that was created earlier in the lower levels - if (VK_SUCCESS != result) { - my_data->instance_dispatch_table->DestroyDebugUtilsMessengerEXT(instance, *pMessenger, pAllocator); - } - } - if (threadChecks) { - finishReadObject(my_data, instance); - } else { - finishMultiThread(); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, instance); - startWriteObject(my_data, messenger); - } - my_data->instance_dispatch_table->DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); - layer_destroy_messenger_callback(my_data->report_data, messenger, pAllocator); - if (threadChecks) { - finishReadObject(my_data, instance); - finishWriteObject(my_data, messenger); - } else { - finishMultiThread(); - } -} - -// VK_EXT_debug_report commands -VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pMsgCallback) { - layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, instance); - } - VkResult result = - my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); - if (VK_SUCCESS == result) { - result = layer_create_report_callback(my_data->report_data, false, pCreateInfo, pAllocator, pMsgCallback); - // If something happened during this call, clean up the message callback that was created earlier in the lower levels - if (VK_SUCCESS != result) { - my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, *pMsgCallback, pAllocator); - } - } - if (threadChecks) { - finishReadObject(my_data, instance); - } else { - finishMultiThread(); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks *pAllocator) { - layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, instance); - startWriteObject(my_data, callback); - } - my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, callback, pAllocator); - layer_destroy_report_callback(my_data->report_data, callback, pAllocator); - if (threadChecks) { - finishReadObject(my_data, instance); - finishWriteObject(my_data, callback); - } else { - finishMultiThread(); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, - VkCommandBuffer *pCommandBuffers) { - dispatch_key key = get_dispatch_key(device); - layer_data *my_data = GetLayerDataPtr(key, layer_data_map); - VkLayerDispatchTable *pTable = my_data->device_dispatch_table; - VkResult result; - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, device); - startWriteObject(my_data, pAllocateInfo->commandPool); - } - - result = pTable->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); - if (threadChecks) { - finishReadObject(my_data, device); - finishWriteObject(my_data, pAllocateInfo->commandPool); - } else { - finishMultiThread(); - } - - // Record mapping from command buffer to command pool - if (VK_SUCCESS == result) { - for (uint32_t index = 0; index < pAllocateInfo->commandBufferCount; index++) { - std::lock_guard lock(command_pool_lock); - command_pool_map[pCommandBuffers[index]] = pAllocateInfo->commandPool; - } - } - - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, - VkDescriptorSet *pDescriptorSets) { - dispatch_key key = get_dispatch_key(device); - layer_data *my_data = GetLayerDataPtr(key, layer_data_map); - VkLayerDispatchTable *pTable = my_data->device_dispatch_table; - VkResult result; - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, device); - startWriteObject(my_data, pAllocateInfo->descriptorPool); - // Host access to pAllocateInfo::descriptorPool must be externally synchronized - } - result = pTable->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); - if (threadChecks) { - finishReadObject(my_data, device); - finishWriteObject(my_data, pAllocateInfo->descriptorPool); - // Host access to pAllocateInfo::descriptorPool must be externally synchronized - } else { - finishMultiThread(); - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, - const VkCommandBuffer *pCommandBuffers) { - dispatch_key key = get_dispatch_key(device); - layer_data *my_data = GetLayerDataPtr(key, layer_data_map); - VkLayerDispatchTable *pTable = my_data->device_dispatch_table; - const bool lockCommandPool = false; // pool is already directly locked - bool threadChecks = startMultiThread(); - if (threadChecks) { - startReadObject(my_data, device); - startWriteObject(my_data, commandPool); - for (uint32_t index = 0; index < commandBufferCount; index++) { - startWriteObject(my_data, pCommandBuffers[index], lockCommandPool); - } - // The driver may immediately reuse command buffers in another thread. - // These updates need to be done before calling down to the driver. - for (uint32_t index = 0; index < commandBufferCount; index++) { - finishWriteObject(my_data, pCommandBuffers[index], lockCommandPool); - std::lock_guard lock(command_pool_lock); - command_pool_map.erase(pCommandBuffers[index]); - } - } - - pTable->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); - if (threadChecks) { - finishReadObject(my_data, device); - finishWriteObject(my_data, commandPool); - } else { - finishMultiThread(); - } -} - -} // namespace threading - -// vk_layer_logging.h expects these to be defined -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger) { - return threading::CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - threading::DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); -} - -VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) { - threading::SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pMsgCallback) { - return threading::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, - const VkAllocationCallbacks *pAllocator) { - threading::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); -} - -VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, - int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { - threading::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); -} - -// loader-layer interface v0, just wrappers since there is only a layer - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - return threading::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, - VkLayerProperties *pProperties) { - return threading::EnumerateInstanceLayerProperties(pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - // the layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return threading::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - // the layer command handles VK_NULL_HANDLE just fine internally - assert(physicalDevice == VK_NULL_HANDLE); - return threading::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { - return threading::GetDeviceProcAddr(dev, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { - return threading::GetInstanceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, - const char *funcName) { - return threading::GetPhysicalDeviceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { - assert(pVersionStruct != NULL); - assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); - - // Fill in the function pointers if our version is at least capable of having the structure contain them. - if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { - pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; - pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; - pVersionStruct->pfnGetPhysicalDeviceProcAddr = vk_layerGetPhysicalDeviceProcAddr; - } - - if (pVersionStruct->loaderLayerInterfaceVersion < CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - threading::loader_layer_if_version = pVersionStruct->loaderLayerInterfaceVersion; - } else if (pVersionStruct->loaderLayerInterfaceVersion > CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - pVersionStruct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - } - - return VK_SUCCESS; -} diff --git a/layers/threading.h b/layers/threading.h deleted file mode 100644 index 68f0f5db..00000000 --- a/layers/threading.h +++ /dev/null @@ -1,431 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Cody Northrop - * Author: Mike Stroyan - */ - -#ifndef THREADING_H -#define THREADING_H -#include -#include -#include -#include "vk_layer_config.h" -#include "vk_layer_logging.h" - -VK_DEFINE_NON_DISPATCHABLE_HANDLE(DISTINCT_NONDISPATCHABLE_PHONY_HANDLE) -// The following line must match the vulkan_core.h condition guarding VK_DEFINE_NON_DISPATCHABLE_HANDLE -#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \ - defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) -// If pointers are 64-bit, then there can be separate counters for each -// NONDISPATCHABLE_HANDLE type. Otherwise they are all typedef uint64_t. -#define DISTINCT_NONDISPATCHABLE_HANDLES -// Make sure we catch any disagreement between us and the vulkan definition -static_assert(std::is_pointer::value, - "Mismatched non-dispatchable handle handle, expected pointer type."); -#else -// Make sure we catch any disagreement between us and the vulkan definition -static_assert(std::is_same::value, - "Mismatched non-dispatchable handle handle, expected uint64_t."); -#endif - -// Draw State ERROR codes -enum THREADING_CHECKER_ERROR { - THREADING_CHECKER_NONE, // Used for INFO & other non-error messages - THREADING_CHECKER_MULTIPLE_THREADS, // Object used simultaneously by multiple threads - THREADING_CHECKER_SINGLE_THREAD_REUSE, // Object used simultaneously by recursion in single thread -}; - -struct object_use_data { - loader_platform_thread_id thread; - int reader_count; - int writer_count; -}; - -struct layer_data; - -namespace threading { -volatile bool vulkan_in_use = false; -volatile bool vulkan_multi_threaded = false; -// starting check if an application is using vulkan from multiple threads. -inline bool startMultiThread() { - if (vulkan_multi_threaded) { - return true; - } - if (vulkan_in_use) { - vulkan_multi_threaded = true; - return true; - } - vulkan_in_use = true; - return false; -} - -// finishing check if an application is using vulkan from multiple threads. -inline void finishMultiThread() { vulkan_in_use = false; } -} // namespace threading - -template -class counter { - public: - const char *typeName; - VkDebugReportObjectTypeEXT objectType; - std::unordered_map uses; - std::mutex counter_lock; - std::condition_variable counter_condition; - void startWrite(debug_report_data *report_data, T object) { - if (object == VK_NULL_HANDLE) { - return; - } - bool skipCall = false; - loader_platform_thread_id tid = loader_platform_get_thread_id(); - std::unique_lock lock(counter_lock); - if (uses.find(object) == uses.end()) { - // There is no current use of the object. Record writer thread. - struct object_use_data *use_data = &uses[object]; - use_data->reader_count = 0; - use_data->writer_count = 1; - use_data->thread = tid; - } else { - struct object_use_data *use_data = &uses[object]; - if (use_data->reader_count == 0) { - // There are no readers. Two writers just collided. - if (use_data->thread != tid) { - skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), - THREADING_CHECKER_MULTIPLE_THREADS, - "THREADING ERROR : object of type %s is simultaneously used in " - "thread 0x%" PRIx64 " and thread 0x%" PRIx64, - typeName, (uint64_t)use_data->thread, (uint64_t)tid); - if (skipCall) { - // Wait for thread-safe access to object instead of skipping call. - while (uses.find(object) != uses.end()) { - counter_condition.wait(lock); - } - // There is now no current use of the object. Record writer thread. - struct object_use_data *new_use_data = &uses[object]; - new_use_data->thread = tid; - new_use_data->reader_count = 0; - new_use_data->writer_count = 1; - } else { - // Continue with an unsafe use of the object. - use_data->thread = tid; - use_data->writer_count += 1; - } - } else { - // This is either safe multiple use in one call, or recursive use. - // There is no way to make recursion safe. Just forge ahead. - use_data->writer_count += 1; - } - } else { - // There are readers. This writer collided with them. - if (use_data->thread != tid) { - skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), - THREADING_CHECKER_MULTIPLE_THREADS, - "THREADING ERROR : object of type %s is simultaneously used in " - "thread 0x%" PRIx64 " and thread 0x%" PRIx64, - typeName, (uint64_t)use_data->thread, (uint64_t)tid); - if (skipCall) { - // Wait for thread-safe access to object instead of skipping call. - while (uses.find(object) != uses.end()) { - counter_condition.wait(lock); - } - // There is now no current use of the object. Record writer thread. - struct object_use_data *new_use_data = &uses[object]; - new_use_data->thread = tid; - new_use_data->reader_count = 0; - new_use_data->writer_count = 1; - } else { - // Continue with an unsafe use of the object. - use_data->thread = tid; - use_data->writer_count += 1; - } - } else { - // This is either safe multiple use in one call, or recursive use. - // There is no way to make recursion safe. Just forge ahead. - use_data->writer_count += 1; - } - } - } - } - - void finishWrite(T object) { - if (object == VK_NULL_HANDLE) { - return; - } - // Object is no longer in use - std::unique_lock lock(counter_lock); - uses[object].writer_count -= 1; - if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) { - uses.erase(object); - } - // Notify any waiting threads that this object may be safe to use - lock.unlock(); - counter_condition.notify_all(); - } - - void startRead(debug_report_data *report_data, T object) { - if (object == VK_NULL_HANDLE) { - return; - } - bool skipCall = false; - loader_platform_thread_id tid = loader_platform_get_thread_id(); - std::unique_lock lock(counter_lock); - if (uses.find(object) == uses.end()) { - // There is no current use of the object. Record reader count - struct object_use_data *use_data = &uses[object]; - use_data->reader_count = 1; - use_data->writer_count = 0; - use_data->thread = tid; - } else if (uses[object].writer_count > 0 && uses[object].thread != tid) { - // There is a writer of the object. - skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), - THREADING_CHECKER_MULTIPLE_THREADS, - "THREADING ERROR : object of type %s is simultaneously used in " - "thread 0x%" PRIx64 " and thread 0x%" PRIx64, - typeName, (uint64_t)uses[object].thread, (uint64_t)tid); - if (skipCall) { - // Wait for thread-safe access to object instead of skipping call. - while (uses.find(object) != uses.end()) { - counter_condition.wait(lock); - } - // There is no current use of the object. Record reader count - struct object_use_data *use_data = &uses[object]; - use_data->reader_count = 1; - use_data->writer_count = 0; - use_data->thread = tid; - } else { - uses[object].reader_count += 1; - } - } else { - // There are other readers of the object. Increase reader count - uses[object].reader_count += 1; - } - } - void finishRead(T object) { - if (object == VK_NULL_HANDLE) { - return; - } - std::unique_lock lock(counter_lock); - uses[object].reader_count -= 1; - if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) { - uses.erase(object); - } - // Notify any waiting threads that this object may be safe to use - lock.unlock(); - counter_condition.notify_all(); - } - counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) { - typeName = name; - objectType = type; - } -}; - -struct layer_data { - VkInstance instance; - - debug_report_data *report_data; - std::vector logging_callback; - std::vector logging_messenger; - VkLayerDispatchTable *device_dispatch_table; - VkLayerInstanceDispatchTable *instance_dispatch_table; - - // The following are for keeping track of the temporary callbacks that can - // be used in vkCreateInstance and vkDestroyInstance: - uint32_t num_tmp_report_callbacks; - VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos; - VkDebugReportCallbackEXT *tmp_report_callbacks; - uint32_t num_tmp_debug_messengers; - VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos; - VkDebugUtilsMessengerEXT *tmp_debug_messengers; - - counter c_VkCommandBuffer; - counter c_VkDevice; - counter c_VkInstance; - counter c_VkQueue; -#ifdef DISTINCT_NONDISPATCHABLE_HANDLES - counter c_VkBuffer; - counter c_VkBufferView; - counter c_VkCommandPool; - counter c_VkDescriptorPool; - counter c_VkDescriptorSet; - counter c_VkDescriptorSetLayout; - counter c_VkDeviceMemory; - counter c_VkEvent; - counter c_VkFence; - counter c_VkFramebuffer; - counter c_VkImage; - counter c_VkImageView; - counter c_VkPipeline; - counter c_VkPipelineCache; - counter c_VkPipelineLayout; - counter c_VkQueryPool; - counter c_VkRenderPass; - counter c_VkSampler; - counter c_VkSemaphore; - counter c_VkShaderModule; - counter c_VkDebugReportCallbackEXT; - counter c_VkObjectTableNVX; - counter c_VkIndirectCommandsLayoutNVX; - counter c_VkDisplayKHR; - counter c_VkDisplayModeKHR; - counter c_VkSurfaceKHR; - counter c_VkSwapchainKHR; - counter c_VkDescriptorUpdateTemplateKHR; - counter c_VkValidationCacheEXT; - counter c_VkSamplerYcbcrConversionKHR; - counter c_VkDebugUtilsMessengerEXT; -#else // DISTINCT_NONDISPATCHABLE_HANDLES - counter c_uint64_t; -#endif // DISTINCT_NONDISPATCHABLE_HANDLES - - layer_data() - : report_data(nullptr), - num_tmp_report_callbacks(0), - tmp_report_create_infos(nullptr), - tmp_report_callbacks(nullptr), - num_tmp_debug_messengers(0), - tmp_messenger_create_infos(nullptr), - tmp_debug_messengers(nullptr), - c_VkCommandBuffer("VkCommandBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT), - c_VkDevice("VkDevice", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT), - c_VkInstance("VkInstance", VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT), - c_VkQueue("VkQueue", VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT), -#ifdef DISTINCT_NONDISPATCHABLE_HANDLES - c_VkBuffer("VkBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT), - c_VkBufferView("VkBufferView", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT), - c_VkCommandPool("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT), - c_VkDescriptorPool("VkDescriptorPool", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT), - c_VkDescriptorSet("VkDescriptorSet", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT), - c_VkDescriptorSetLayout("VkDescriptorSetLayout", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT), - c_VkDeviceMemory("VkDeviceMemory", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT), - c_VkEvent("VkEvent", VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT), - c_VkFence("VkFence", VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT), - c_VkFramebuffer("VkFramebuffer", VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT), - c_VkImage("VkImage", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT), - c_VkImageView("VkImageView", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT), - c_VkPipeline("VkPipeline", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT), - c_VkPipelineCache("VkPipelineCache", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT), - c_VkPipelineLayout("VkPipelineLayout", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT), - c_VkQueryPool("VkQueryPool", VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT), - c_VkRenderPass("VkRenderPass", VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT), - c_VkSampler("VkSampler", VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT), - c_VkSemaphore("VkSemaphore", VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT), - c_VkShaderModule("VkShaderModule", VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT), - c_VkDebugReportCallbackEXT("VkDebugReportCallbackEXT", VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT), - c_VkObjectTableNVX("VkObjectTableNVX", VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT), - c_VkIndirectCommandsLayoutNVX("VkIndirectCommandsLayoutNVX", - VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT), - c_VkDisplayKHR("VkDisplayKHR", VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT), - c_VkDisplayModeKHR("VkDisplayModeKHR", VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT), - c_VkSurfaceKHR("VkSurfaceKHR", VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT), - c_VkSwapchainKHR("VkSwapchainKHR", VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT), - c_VkDescriptorUpdateTemplateKHR("VkDescriptorUpdateTemplateKHR", - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT), - c_VkSamplerYcbcrConversionKHR("VkSamplerYcbcrConversionKHR", - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT), - c_VkDebugUtilsMessengerEXT("VkDebugUtilsMessengerEXT", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) -#else // DISTINCT_NONDISPATCHABLE_HANDLES - c_uint64_t("NON_DISPATCHABLE_HANDLE", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) -#endif // DISTINCT_NONDISPATCHABLE_HANDLES - {}; -}; - -#define WRAPPER(type) \ - static void startWriteObject(struct layer_data *my_data, type object) { \ - my_data->c_##type.startWrite(my_data->report_data, object); \ - } \ - static void finishWriteObject(struct layer_data *my_data, type object) { my_data->c_##type.finishWrite(object); } \ - static void startReadObject(struct layer_data *my_data, type object) { \ - my_data->c_##type.startRead(my_data->report_data, object); \ - } \ - static void finishReadObject(struct layer_data *my_data, type object) { my_data->c_##type.finishRead(object); } - -WRAPPER(VkDevice) -WRAPPER(VkInstance) -WRAPPER(VkQueue) -#ifdef DISTINCT_NONDISPATCHABLE_HANDLES -WRAPPER(VkBuffer) -WRAPPER(VkBufferView) -WRAPPER(VkCommandPool) -WRAPPER(VkDescriptorPool) -WRAPPER(VkDescriptorSet) -WRAPPER(VkDescriptorSetLayout) -WRAPPER(VkDeviceMemory) -WRAPPER(VkEvent) -WRAPPER(VkFence) -WRAPPER(VkFramebuffer) -WRAPPER(VkImage) -WRAPPER(VkImageView) -WRAPPER(VkPipeline) -WRAPPER(VkPipelineCache) -WRAPPER(VkPipelineLayout) -WRAPPER(VkQueryPool) -WRAPPER(VkRenderPass) -WRAPPER(VkSampler) -WRAPPER(VkSemaphore) -WRAPPER(VkShaderModule) -WRAPPER(VkDebugReportCallbackEXT) -WRAPPER(VkObjectTableNVX) -WRAPPER(VkIndirectCommandsLayoutNVX) -WRAPPER(VkDisplayKHR) -WRAPPER(VkDisplayModeKHR) -WRAPPER(VkSurfaceKHR) -WRAPPER(VkSwapchainKHR) -WRAPPER(VkDescriptorUpdateTemplateKHR) -WRAPPER(VkValidationCacheEXT) -WRAPPER(VkSamplerYcbcrConversionKHR) -WRAPPER(VkDebugUtilsMessengerEXT) -#else // DISTINCT_NONDISPATCHABLE_HANDLES -WRAPPER(uint64_t) -#endif // DISTINCT_NONDISPATCHABLE_HANDLES - -static std::unordered_map layer_data_map; -static std::mutex command_pool_lock; -static std::unordered_map command_pool_map; - -// VkCommandBuffer needs check for implicit use of command pool -static void startWriteObject(struct layer_data *my_data, VkCommandBuffer object, bool lockPool = true) { - if (lockPool) { - std::unique_lock lock(command_pool_lock); - VkCommandPool pool = command_pool_map[object]; - lock.unlock(); - startWriteObject(my_data, pool); - } - my_data->c_VkCommandBuffer.startWrite(my_data->report_data, object); -} -static void finishWriteObject(struct layer_data *my_data, VkCommandBuffer object, bool lockPool = true) { - my_data->c_VkCommandBuffer.finishWrite(object); - if (lockPool) { - std::unique_lock lock(command_pool_lock); - VkCommandPool pool = command_pool_map[object]; - lock.unlock(); - finishWriteObject(my_data, pool); - } -} -static void startReadObject(struct layer_data *my_data, VkCommandBuffer object) { - std::unique_lock lock(command_pool_lock); - VkCommandPool pool = command_pool_map[object]; - lock.unlock(); - startReadObject(my_data, pool); - my_data->c_VkCommandBuffer.startRead(my_data->report_data, object); -} -static void finishReadObject(struct layer_data *my_data, VkCommandBuffer object) { - my_data->c_VkCommandBuffer.finishRead(object); - std::unique_lock lock(command_pool_lock); - VkCommandPool pool = command_pool_map[object]; - lock.unlock(); - finishReadObject(my_data, pool); -} -#endif // THREADING_H diff --git a/layers/threading_layer.md b/layers/threading_layer.md deleted file mode 100644 index 9babd2b2..00000000 --- a/layers/threading_layer.md +++ /dev/null @@ -1,2 +0,0 @@ -# VK\_LAYER\_GOOGLE\_threading -The `VK_LAYER_GOOGLE_threading` layer checks multi-threading of API calls for validity. Checks performed by this layer include ensuring that only one thread at a time uses an object in free-threaded API calls. diff --git a/layers/unique_objects.cpp b/layers/unique_objects.cpp deleted file mode 100644 index 6b6c0615..00000000 --- a/layers/unique_objects.cpp +++ /dev/null @@ -1,990 +0,0 @@ -/* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (c) 2015-2016 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 - * Author: Mark Lobodzinski - */ - -#define NOMINMAX - -#include -#include -#include -#include -#include -#include -#include -#include - -// For Windows, this #include must come before other Vk headers. -#include "vk_loader_platform.h" - -#include "unique_objects.h" -#include "vk_dispatch_table_helper.h" -#include "vk_layer_config.h" -#include "vk_layer_data.h" -#include "vk_layer_extension_utils.h" -#include "vk_layer_logging.h" -#include "vk_layer_table.h" -#include "vk_layer_utils.h" -#include "vk_layer_utils.h" -#include "vk_enum_string_helper.h" -#include "vk_validation_error_messages.h" -#include "vk_object_types.h" -#include "vk_extension_helper.h" -#include "vulkan/vk_layer.h" - -// This intentionally includes a cpp file -#include "vk_safe_struct.cpp" - -#include "unique_objects_wrappers.h" - -namespace unique_objects { - -static uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - -static void initUniqueObjects(instance_layer_data *instance_data, const VkAllocationCallbacks *pAllocator) { - layer_debug_report_actions(instance_data->report_data, instance_data->logging_callback, pAllocator, "google_unique_objects"); - layer_debug_messenger_actions(instance_data->report_data, instance_data->logging_messenger, pAllocator, - "google_unique_objects"); -} - -// Check enabled instance extensions against supported instance extension whitelist -static void InstanceExtensionWhitelist(const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - // Check for recognized instance extensions - if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kInstanceExtensionNames)) { - log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_UNDEFINED, - "Instance Extension %s is not supported by this layer. Using this extension may adversely affect validation " - "results and/or produce undefined behavior.", - pCreateInfo->ppEnabledExtensionNames[i]); - } - } -} - -// Check enabled device extensions against supported device extension whitelist -static void DeviceExtensionWhitelist(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - // Check for recognized device extensions - if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kDeviceExtensionNames)) { - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, - VALIDATION_ERROR_UNDEFINED, - "Device Extension %s is not supported by this layer. Using this extension may adversely affect validation " - "results and/or produce undefined behavior.", - pCreateInfo->ppEnabledExtensionNames[i]); - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) { - VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); - if (fpCreateInstance == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); - if (result != VK_SUCCESS) { - return result; - } - - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), instance_layer_data_map); - instance_data->instance = *pInstance; - layer_init_instance_dispatch_table(*pInstance, &instance_data->dispatch_table, fpGetInstanceProcAddr); - - instance_data->instance = *pInstance; - instance_data->report_data = debug_utils_create_instance( - &instance_data->dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames); - - // Set up temporary debug callbacks to output messages at CreateInstance-time - if (!layer_copy_tmp_debug_messengers(pCreateInfo->pNext, &instance_data->num_tmp_debug_messengers, - &instance_data->tmp_messenger_create_infos, &instance_data->tmp_debug_messengers)) { - if (instance_data->num_tmp_debug_messengers > 0) { - if (layer_enable_tmp_debug_messengers(instance_data->report_data, instance_data->num_tmp_debug_messengers, - instance_data->tmp_messenger_create_infos, instance_data->tmp_debug_messengers)) { - layer_free_tmp_debug_messengers(instance_data->tmp_messenger_create_infos, instance_data->tmp_debug_messengers); - instance_data->num_tmp_debug_messengers = 0; - } - } - } - if (!layer_copy_tmp_report_callbacks(pCreateInfo->pNext, &instance_data->num_tmp_report_callbacks, - &instance_data->tmp_report_create_infos, &instance_data->tmp_report_callbacks)) { - if (instance_data->num_tmp_report_callbacks > 0) { - if (layer_enable_tmp_report_callbacks(instance_data->report_data, instance_data->num_tmp_report_callbacks, - instance_data->tmp_report_create_infos, instance_data->tmp_report_callbacks)) { - layer_free_tmp_report_callbacks(instance_data->tmp_report_create_infos, instance_data->tmp_report_callbacks); - instance_data->num_tmp_report_callbacks = 0; - } - } - } - - initUniqueObjects(instance_data, pAllocator); - InstanceExtensionWhitelist(pCreateInfo, *pInstance); - - // Disable and free tmp callbacks, no longer necessary - if (instance_data->num_tmp_debug_messengers > 0) { - layer_disable_tmp_debug_messengers(instance_data->report_data, instance_data->num_tmp_debug_messengers, - instance_data->tmp_debug_messengers); - layer_free_tmp_debug_messengers(instance_data->tmp_messenger_create_infos, instance_data->tmp_debug_messengers); - instance_data->num_tmp_debug_messengers = 0; - } - if (instance_data->num_tmp_report_callbacks > 0) { - layer_disable_tmp_report_callbacks(instance_data->report_data, instance_data->num_tmp_report_callbacks, - instance_data->tmp_report_callbacks); - layer_free_tmp_report_callbacks(instance_data->tmp_report_create_infos, instance_data->tmp_report_callbacks); - instance_data->num_tmp_report_callbacks = 0; - } - - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - dispatch_key key = get_dispatch_key(instance); - instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map); - VkLayerInstanceDispatchTable *disp_table = &instance_data->dispatch_table; - disp_table->DestroyInstance(instance, pAllocator); - - // Clean up logging callback, if any - while (instance_data->logging_messenger.size() > 0) { - VkDebugUtilsMessengerEXT messenger = instance_data->logging_messenger.back(); - layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator); - instance_data->logging_messenger.pop_back(); - } - while (instance_data->logging_callback.size() > 0) { - VkDebugReportCallbackEXT callback = instance_data->logging_callback.back(); - layer_destroy_report_callback(instance_data->report_data, callback, pAllocator); - instance_data->logging_callback.pop_back(); - } - - layer_debug_utils_destroy_instance(instance_data->report_data); - FreeLayerDataPtr(key, instance_layer_data_map); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - instance_layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(gpu), instance_layer_data_map); - VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(my_instance_data->instance, "vkCreateDevice"); - if (fpCreateDevice == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); - if (result != VK_SUCCESS) { - return result; - } - - layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); - my_device_data->report_data = layer_debug_utils_create_device(my_instance_data->report_data, *pDevice); - - // Setup layer's device dispatch table - layer_init_device_dispatch_table(*pDevice, &my_device_data->dispatch_table, fpGetDeviceProcAddr); - - DeviceExtensionWhitelist(pCreateInfo, *pDevice); - - // Set gpu for this device in order to get at any objects mapped at instance level - my_device_data->instance_data = my_instance_data; - - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { - dispatch_key key = get_dispatch_key(device); - layer_data *dev_data = GetLayerDataPtr(key, layer_data_map); - - layer_debug_utils_destroy_device(device); - dev_data->dispatch_table.DestroyDevice(device, pAllocator); - - FreeLayerDataPtr(key, layer_data_map); -} - -static const VkLayerProperties globalLayerProps = {"VK_LAYER_GOOGLE_unique_objects", - VK_LAYER_API_VERSION, // specVersion - 1, // implementationVersion - "Google Validation Layer"}; - -/// Declare prototype for these functions -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName); - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName)) - return util_GetExtensionProperties(0, NULL, pCount, pProperties); - - return VK_ERROR_LAYER_NOT_PRESENT; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, - uint32_t *pCount, VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName)) - return util_GetExtensionProperties(0, nullptr, pCount, pProperties); - - assert(physicalDevice); - - dispatch_key key = get_dispatch_key(physicalDevice); - instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map); - return instance_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - const auto &table = device_data->dispatch_table; - if (!table.GetDeviceProcAddr) return nullptr; - return table.GetDeviceProcAddr(device, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { - const auto item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - const auto &table = instance_data->dispatch_table; - if (!table.GetInstanceProcAddr) return nullptr; - return table.GetInstanceProcAddr(instance, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - VkLayerInstanceDispatchTable *disp_table = &instance_data->dispatch_table; - if (disp_table->GetPhysicalDeviceProcAddr == NULL) { - return NULL; - } - return disp_table->GetPhysicalDeviceProcAddr(instance, funcName); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, - const VkComputePipelineCreateInfo *pCreateInfos, - const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkComputePipelineCreateInfo *local_pCreateInfos = NULL; - if (pCreateInfos) { - std::lock_guard lock(global_lock); - local_pCreateInfos = new safe_VkComputePipelineCreateInfo[createInfoCount]; - for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) { - local_pCreateInfos[idx0].initialize(&pCreateInfos[idx0]); - if (pCreateInfos[idx0].basePipelineHandle) { - local_pCreateInfos[idx0].basePipelineHandle = Unwrap(pCreateInfos[idx0].basePipelineHandle); - } - if (pCreateInfos[idx0].layout) { - local_pCreateInfos[idx0].layout = Unwrap(pCreateInfos[idx0].layout); - } - if (pCreateInfos[idx0].stage.module) { - local_pCreateInfos[idx0].stage.module = Unwrap(pCreateInfos[idx0].stage.module); - } - } - } - if (pipelineCache) { - std::lock_guard lock(global_lock); - pipelineCache = Unwrap(pipelineCache); - } - - VkResult result = device_data->dispatch_table.CreateComputePipelines(device, pipelineCache, createInfoCount, - local_pCreateInfos->ptr(), pAllocator, pPipelines); - delete[] local_pCreateInfos; - { - std::lock_guard lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - if (pPipelines[i] != VK_NULL_HANDLE) { - pPipelines[i] = WrapNew(pPipelines[i]); - } - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo *pCreateInfos, - const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkGraphicsPipelineCreateInfo *local_pCreateInfos = nullptr; - if (pCreateInfos) { - local_pCreateInfos = new safe_VkGraphicsPipelineCreateInfo[createInfoCount]; - std::lock_guard lock(global_lock); - for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) { - bool uses_color_attachment = false; - bool uses_depthstencil_attachment = false; - { - const auto subpasses_uses_it = device_data->renderpasses_states.find(Unwrap(pCreateInfos[idx0].renderPass)); - if (subpasses_uses_it != device_data->renderpasses_states.end()) { - const auto &subpasses_uses = subpasses_uses_it->second; - if (subpasses_uses.subpasses_using_color_attachment.count(pCreateInfos[idx0].subpass)) - uses_color_attachment = true; - if (subpasses_uses.subpasses_using_depthstencil_attachment.count(pCreateInfos[idx0].subpass)) - uses_depthstencil_attachment = true; - } - } - - local_pCreateInfos[idx0].initialize(&pCreateInfos[idx0], uses_color_attachment, uses_depthstencil_attachment); - - if (pCreateInfos[idx0].basePipelineHandle) { - local_pCreateInfos[idx0].basePipelineHandle = Unwrap(pCreateInfos[idx0].basePipelineHandle); - } - if (pCreateInfos[idx0].layout) { - local_pCreateInfos[idx0].layout = Unwrap(pCreateInfos[idx0].layout); - } - if (pCreateInfos[idx0].pStages) { - for (uint32_t idx1 = 0; idx1 < pCreateInfos[idx0].stageCount; ++idx1) { - if (pCreateInfos[idx0].pStages[idx1].module) { - local_pCreateInfos[idx0].pStages[idx1].module = Unwrap(pCreateInfos[idx0].pStages[idx1].module); - } - } - } - if (pCreateInfos[idx0].renderPass) { - local_pCreateInfos[idx0].renderPass = Unwrap(pCreateInfos[idx0].renderPass); - } - } - } - if (pipelineCache) { - std::lock_guard lock(global_lock); - pipelineCache = Unwrap(pipelineCache); - } - - VkResult result = device_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, - local_pCreateInfos->ptr(), pAllocator, pPipelines); - delete[] local_pCreateInfos; - { - std::lock_guard lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - if (pPipelines[i] != VK_NULL_HANDLE) { - pPipelines[i] = WrapNew(pPipelines[i]); - } - } - } - return result; -} - -static void PostCallCreateRenderPass(layer_data *dev_data, const VkRenderPassCreateInfo *pCreateInfo, VkRenderPass renderPass) { - auto &renderpass_state = dev_data->renderpasses_states[renderPass]; - - for (uint32_t subpass = 0; subpass < pCreateInfo->subpassCount; ++subpass) { - bool uses_color = false; - for (uint32_t i = 0; i < pCreateInfo->pSubpasses[subpass].colorAttachmentCount && !uses_color; ++i) - if (pCreateInfo->pSubpasses[subpass].pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED) uses_color = true; - - bool uses_depthstencil = false; - if (pCreateInfo->pSubpasses[subpass].pDepthStencilAttachment) - if (pCreateInfo->pSubpasses[subpass].pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) - uses_depthstencil = true; - - if (uses_color) renderpass_state.subpasses_using_color_attachment.insert(subpass); - if (uses_depthstencil) renderpass_state.subpasses_using_depthstencil_attachment.insert(subpass); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkResult result = dev_data->dispatch_table.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); - if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); - - PostCallCreateRenderPass(dev_data, pCreateInfo, *pRenderPass); - - *pRenderPass = WrapNew(*pRenderPass); - } - return result; -} - -static void PostCallDestroyRenderPass(layer_data *dev_data, VkRenderPass renderPass) { - dev_data->renderpasses_states.erase(renderPass); -} - -VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); - uint64_t renderPass_id = reinterpret_cast(renderPass); - renderPass = (VkRenderPass)unique_id_mapping[renderPass_id]; - unique_id_mapping.erase(renderPass_id); - lock.unlock(); - dev_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator); - - lock.lock(); - PostCallDestroyRenderPass(dev_data, renderPass); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { - layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkSwapchainCreateInfoKHR *local_pCreateInfo = NULL; - if (pCreateInfo) { - std::lock_guard lock(global_lock); - local_pCreateInfo = new safe_VkSwapchainCreateInfoKHR(pCreateInfo); - local_pCreateInfo->oldSwapchain = Unwrap(pCreateInfo->oldSwapchain); - // Surface is instance-level object - local_pCreateInfo->surface = Unwrap(pCreateInfo->surface); - } - - VkResult result = my_map_data->dispatch_table.CreateSwapchainKHR(device, local_pCreateInfo->ptr(), pAllocator, pSwapchain); - delete local_pCreateInfo; - - if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); - *pSwapchain = WrapNew(*pSwapchain); - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR *pCreateInfos, - const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkSwapchainCreateInfoKHR *local_pCreateInfos = NULL; - { - std::lock_guard lock(global_lock); - if (pCreateInfos) { - local_pCreateInfos = new safe_VkSwapchainCreateInfoKHR[swapchainCount]; - for (uint32_t i = 0; i < swapchainCount; ++i) { - local_pCreateInfos[i].initialize(&pCreateInfos[i]); - if (pCreateInfos[i].surface) { - // Surface is instance-level object - local_pCreateInfos[i].surface = Unwrap(pCreateInfos[i].surface); - } - if (pCreateInfos[i].oldSwapchain) { - local_pCreateInfos[i].oldSwapchain = Unwrap(pCreateInfos[i].oldSwapchain); - } - } - } - } - VkResult result = dev_data->dispatch_table.CreateSharedSwapchainsKHR(device, swapchainCount, local_pCreateInfos->ptr(), - pAllocator, pSwapchains); - delete[] local_pCreateInfos; - if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); - for (uint32_t i = 0; i < swapchainCount; i++) { - pSwapchains[i] = WrapNew(pSwapchains[i]); - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, - VkImage *pSwapchainImages) { - layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - VkSwapchainKHR wrapped_swapchain_handle = swapchain; - if (VK_NULL_HANDLE != swapchain) { - std::lock_guard lock(global_lock); - swapchain = Unwrap(swapchain); - } - VkResult result = - my_device_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); - if ((VK_SUCCESS == result) || (VK_INCOMPLETE == result)) { - if ((*pSwapchainImageCount > 0) && pSwapchainImages) { - std::lock_guard lock(global_lock); - auto &wrapped_swapchain_image_handles = my_device_data->swapchain_wrapped_image_handle_map[wrapped_swapchain_handle]; - for (uint32_t i = static_cast(wrapped_swapchain_image_handles.size()); i < *pSwapchainImageCount; i++) { - wrapped_swapchain_image_handles.emplace_back(WrapNew(pSwapchainImages[i])); - } - for (uint32_t i = 0; i < *pSwapchainImageCount; i++) { - pSwapchainImages[i] = wrapped_swapchain_image_handles[i]; - } - } - } - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); - - auto &image_array = dev_data->swapchain_wrapped_image_handle_map[swapchain]; - for (auto &image_handle : image_array) { - unique_id_mapping.erase(HandleToUint64(image_handle)); - } - dev_data->swapchain_wrapped_image_handle_map.erase(swapchain); - - uint64_t swapchain_id = HandleToUint64(swapchain); - swapchain = (VkSwapchainKHR)unique_id_mapping[swapchain_id]; - unique_id_mapping.erase(swapchain_id); - lock.unlock(); - dev_data->dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator); -} - -VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - safe_VkPresentInfoKHR *local_pPresentInfo = NULL; - { - std::lock_guard lock(global_lock); - if (pPresentInfo) { - local_pPresentInfo = new safe_VkPresentInfoKHR(pPresentInfo); - if (local_pPresentInfo->pWaitSemaphores) { - for (uint32_t index1 = 0; index1 < local_pPresentInfo->waitSemaphoreCount; ++index1) { - local_pPresentInfo->pWaitSemaphores[index1] = Unwrap(pPresentInfo->pWaitSemaphores[index1]); - } - } - if (local_pPresentInfo->pSwapchains) { - for (uint32_t index1 = 0; index1 < local_pPresentInfo->swapchainCount; ++index1) { - local_pPresentInfo->pSwapchains[index1] = Unwrap(pPresentInfo->pSwapchains[index1]); - } - } - } - } - VkResult result = dev_data->dispatch_table.QueuePresentKHR(queue, local_pPresentInfo->ptr()); - - // pResults is an output array embedded in a structure. The code generator neglects to copy back from the safe_* version, - // so handle it as a special case here: - if (pPresentInfo && pPresentInfo->pResults) { - for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) { - pPresentInfo->pResults[i] = local_pPresentInfo->pResults[i]; - } - } - - delete local_pPresentInfo; - return result; -} - -// This is the core version of this routine. The extension version is below. -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(VkDevice device, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkDescriptorUpdateTemplateCreateInfo *local_create_info = NULL; - { - std::lock_guard lock(global_lock); - if (pCreateInfo) { - local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo); - if (pCreateInfo->descriptorSetLayout) { - local_create_info->descriptorSetLayout = Unwrap(pCreateInfo->descriptorSetLayout); - } - if (pCreateInfo->pipelineLayout) { - local_create_info->pipelineLayout = Unwrap(pCreateInfo->pipelineLayout); - } - } - } - VkResult result = dev_data->dispatch_table.CreateDescriptorUpdateTemplate(device, local_create_info->ptr(), pAllocator, - pDescriptorUpdateTemplate); - if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); - *pDescriptorUpdateTemplate = WrapNew(*pDescriptorUpdateTemplate); - - // Shadow template createInfo for later updates - std::unique_ptr template_state(new TEMPLATE_STATE(*pDescriptorUpdateTemplate, local_create_info)); - dev_data->desc_template_map[(uint64_t)*pDescriptorUpdateTemplate] = std::move(template_state); - } - return result; -} - -// This is the extension version of this routine. The core version is above. -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkDescriptorUpdateTemplateCreateInfo *local_create_info = NULL; - { - std::lock_guard lock(global_lock); - if (pCreateInfo) { - local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo); - if (pCreateInfo->descriptorSetLayout) { - local_create_info->descriptorSetLayout = Unwrap(pCreateInfo->descriptorSetLayout); - } - if (pCreateInfo->pipelineLayout) { - local_create_info->pipelineLayout = Unwrap(pCreateInfo->pipelineLayout); - } - } - } - VkResult result = dev_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(device, local_create_info->ptr(), pAllocator, - pDescriptorUpdateTemplate); - if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); - *pDescriptorUpdateTemplate = WrapNew(*pDescriptorUpdateTemplate); - - // Shadow template createInfo for later updates - std::unique_ptr template_state(new TEMPLATE_STATE(*pDescriptorUpdateTemplate, local_create_info)); - dev_data->desc_template_map[(uint64_t)*pDescriptorUpdateTemplate] = std::move(template_state); - } - return result; -} - -// This is the core version of this routine. The extension version is below. -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); - uint64_t descriptor_update_template_id = reinterpret_cast(descriptorUpdateTemplate); - dev_data->desc_template_map.erase(descriptor_update_template_id); - descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[descriptor_update_template_id]; - unique_id_mapping.erase(descriptor_update_template_id); - lock.unlock(); - dev_data->dispatch_table.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); -} - -// This is the extension version of this routine. The core version is above. -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); - uint64_t descriptor_update_template_id = reinterpret_cast(descriptorUpdateTemplate); - dev_data->desc_template_map.erase(descriptor_update_template_id); - descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[descriptor_update_template_id]; - unique_id_mapping.erase(descriptor_update_template_id); - lock.unlock(); - dev_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); -} - -void *BuildUnwrappedUpdateTemplateBuffer(layer_data *dev_data, uint64_t descriptorUpdateTemplate, const void *pData) { - auto const template_map_entry = dev_data->desc_template_map.find(descriptorUpdateTemplate); - if (template_map_entry == dev_data->desc_template_map.end()) { - assert(0); - } - auto const &create_info = template_map_entry->second->create_info; - size_t allocation_size = 0; - std::vector> template_entries; - - for (uint32_t i = 0; i < create_info.descriptorUpdateEntryCount; i++) { - for (uint32_t j = 0; j < create_info.pDescriptorUpdateEntries[i].descriptorCount; j++) { - size_t offset = create_info.pDescriptorUpdateEntries[i].offset + j * create_info.pDescriptorUpdateEntries[i].stride; - char *update_entry = (char *)(pData) + offset; - - switch (create_info.pDescriptorUpdateEntries[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: { - auto image_entry = reinterpret_cast(update_entry); - allocation_size = std::max(allocation_size, offset + sizeof(VkDescriptorImageInfo)); - - VkDescriptorImageInfo *wrapped_entry = new VkDescriptorImageInfo(*image_entry); - wrapped_entry->sampler = Unwrap(image_entry->sampler); - wrapped_entry->imageView = Unwrap(image_entry->imageView); - template_entries.emplace_back(offset, kVulkanObjectTypeImage, reinterpret_cast(wrapped_entry)); - } break; - - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: { - auto buffer_entry = reinterpret_cast(update_entry); - allocation_size = std::max(allocation_size, offset + sizeof(VkDescriptorBufferInfo)); - - VkDescriptorBufferInfo *wrapped_entry = new VkDescriptorBufferInfo(*buffer_entry); - wrapped_entry->buffer = Unwrap(buffer_entry->buffer); - template_entries.emplace_back(offset, kVulkanObjectTypeBuffer, reinterpret_cast(wrapped_entry)); - } break; - - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: { - auto buffer_view_handle = reinterpret_cast(update_entry); - allocation_size = std::max(allocation_size, offset + sizeof(VkBufferView)); - - VkBufferView wrapped_entry = Unwrap(*buffer_view_handle); - template_entries.emplace_back(offset, kVulkanObjectTypeBufferView, reinterpret_cast(wrapped_entry)); - } break; - default: - assert(0); - break; - } - } - } - // Allocate required buffer size and populate with source/unwrapped data - void *unwrapped_data = malloc(allocation_size); - for (auto &this_entry : template_entries) { - VulkanObjectType type = std::get<1>(this_entry); - void *destination = (char *)unwrapped_data + std::get<0>(this_entry); - void *source = (char *)std::get<2>(this_entry); - - switch (type) { - case kVulkanObjectTypeImage: - *(reinterpret_cast(destination)) = *(reinterpret_cast(source)); - delete reinterpret_cast(source); - break; - case kVulkanObjectTypeBuffer: - *(reinterpret_cast(destination)) = *(reinterpret_cast(source)); - delete reinterpret_cast(source); - break; - case kVulkanObjectTypeBufferView: - *(reinterpret_cast(destination)) = reinterpret_cast(source); - break; - default: - assert(0); - break; - } - } - return (void *)unwrapped_data; -} - -// This is the core version of this routine. The extension version is below. -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void *pData) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - uint64_t template_handle = reinterpret_cast(descriptorUpdateTemplate); - { - std::lock_guard lock(global_lock); - descriptorSet = Unwrap(descriptorSet); - descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[template_handle]; - } - void *unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(dev_data, template_handle, pData); - dev_data->dispatch_table.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, unwrapped_buffer); - free(unwrapped_buffer); -} - -// This is the extension version of this routine. The core version is above. -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void *pData) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - uint64_t template_handle = reinterpret_cast(descriptorUpdateTemplate); - void *unwrapped_buffer = nullptr; - { - std::lock_guard lock(global_lock); - descriptorSet = Unwrap(descriptorSet); - descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[template_handle]; - unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(dev_data, template_handle, pData); - } - dev_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, unwrapped_buffer); - free(unwrapped_buffer); -} - -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - VkPipelineLayout layout, uint32_t set, const void *pData) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - uint64_t template_handle = reinterpret_cast(descriptorUpdateTemplate); - void *unwrapped_buffer = nullptr; - { - std::lock_guard lock(global_lock); - descriptorUpdateTemplate = Unwrap(descriptorUpdateTemplate); - layout = Unwrap(layout); - unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(dev_data, template_handle, pData); - } - dev_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, - unwrapped_buffer); - free(unwrapped_buffer); -} - -#ifndef __ANDROID__ -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, - VkDisplayPropertiesKHR *pProperties) { - instance_layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - - VkResult result = - my_map_data->dispatch_table.GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); - if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) { - std::lock_guard lock(global_lock); - for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) { - pProperties[idx0].display = WrapNew(pProperties[idx0].display); - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, - uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) { - instance_layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - VkResult result = - my_map_data->dispatch_table.GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); - if (VK_SUCCESS == result) { - if ((*pDisplayCount > 0) && pDisplays) { - std::lock_guard lock(global_lock); - for (uint32_t i = 0; i < *pDisplayCount; i++) { - // TODO: this looks like it really wants a /reverse/ mapping. What's going on here? - auto it = unique_id_mapping.find(reinterpret_cast(pDisplays[i])); - assert(it != unique_id_mapping.end()); - pDisplays[i] = reinterpret_cast(it->second); - } - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) { - instance_layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - { - std::lock_guard lock(global_lock); - display = Unwrap(display); - } - - VkResult result = my_map_data->dispatch_table.GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); - if (result == VK_SUCCESS && pProperties) { - std::lock_guard lock(global_lock); - for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) { - pProperties[idx0].displayMode = WrapNew(pProperties[idx0].displayMode); - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, - uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) { - instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - { - std::lock_guard lock(global_lock); - mode = Unwrap(mode); - } - VkResult result = dev_data->dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); - return result; -} -#endif - -VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkDebugMarkerObjectTagInfoEXT local_tag_info(pTagInfo); - { - std::lock_guard lock(global_lock); - auto it = unique_id_mapping.find(reinterpret_cast(local_tag_info.object)); - if (it != unique_id_mapping.end()) { - local_tag_info.object = it->second; - } - } - VkResult result = device_data->dispatch_table.DebugMarkerSetObjectTagEXT( - device, reinterpret_cast(&local_tag_info)); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkDebugMarkerObjectNameInfoEXT local_name_info(pNameInfo); - { - std::lock_guard lock(global_lock); - auto it = unique_id_mapping.find(reinterpret_cast(local_name_info.object)); - if (it != unique_id_mapping.end()) { - local_name_info.object = it->second; - } - } - VkResult result = device_data->dispatch_table.DebugMarkerSetObjectNameEXT( - device, reinterpret_cast(&local_name_info)); - return result; -} - -// VK_EXT_debug_utils -VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkDebugUtilsObjectTagInfoEXT local_tag_info(pTagInfo); - { - std::lock_guard lock(global_lock); - auto it = unique_id_mapping.find(reinterpret_cast(local_tag_info.objectHandle)); - if (it != unique_id_mapping.end()) { - local_tag_info.objectHandle = it->second; - } - } - VkResult result = device_data->dispatch_table.SetDebugUtilsObjectTagEXT( - device, reinterpret_cast(&local_tag_info)); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) { - layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - safe_VkDebugUtilsObjectNameInfoEXT local_name_info(pNameInfo); - { - std::lock_guard lock(global_lock); - auto it = unique_id_mapping.find(reinterpret_cast(local_name_info.objectHandle)); - if (it != unique_id_mapping.end()) { - local_name_info.objectHandle = it->second; - } - } - VkResult result = device_data->dispatch_table.SetDebugUtilsObjectNameEXT( - device, reinterpret_cast(&local_name_info)); - return result; -} - -} // namespace unique_objects - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - return unique_objects::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, - VkLayerProperties *pProperties) { - return unique_objects::EnumerateInstanceLayerProperties(pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - assert(physicalDevice == VK_NULL_HANDLE); - return unique_objects::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { - return unique_objects::GetDeviceProcAddr(dev, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { - return unique_objects::GetInstanceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - assert(physicalDevice == VK_NULL_HANDLE); - return unique_objects::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); -} - -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, - const char *funcName) { - return unique_objects::GetPhysicalDeviceProcAddr(instance, funcName); -} - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { - assert(pVersionStruct != NULL); - assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); - - // Fill in the function pointers if our version is at least capable of having the structure contain them. - if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { - pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; - pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; - pVersionStruct->pfnGetPhysicalDeviceProcAddr = vk_layerGetPhysicalDeviceProcAddr; - } - - if (pVersionStruct->loaderLayerInterfaceVersion < CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - unique_objects::loader_layer_if_version = pVersionStruct->loaderLayerInterfaceVersion; - } else if (pVersionStruct->loaderLayerInterfaceVersion > CURRENT_LOADER_LAYER_INTERFACE_VERSION) { - pVersionStruct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - } - - return VK_SUCCESS; -} diff --git a/layers/unique_objects.h b/layers/unique_objects.h deleted file mode 100644 index cbb4c053..00000000 --- a/layers/unique_objects.h +++ /dev/null @@ -1,135 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015-2016 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 - * Author: Mark Lobodzinski - */ - -#include "vulkan/vulkan.h" - -#include -#include - -#include "vk_layer_data.h" -#include "vk_safe_struct.h" -#include "vk_layer_utils.h" -#include "mutex" - -#pragma once - -namespace unique_objects { - -// All increments must be guarded by global_lock -static uint64_t global_unique_id = 1; -static std::unordered_map unique_id_mapping; // Map uniqueID to actual object handle - -struct TEMPLATE_STATE { - VkDescriptorUpdateTemplateKHR desc_update_template; - safe_VkDescriptorUpdateTemplateCreateInfo create_info; - - TEMPLATE_STATE(VkDescriptorUpdateTemplateKHR update_template, safe_VkDescriptorUpdateTemplateCreateInfo *pCreateInfo) - : desc_update_template(update_template), create_info(*pCreateInfo) {} -}; - -struct instance_layer_data { - - VkInstance instance; - - debug_report_data *report_data; - std::vector logging_callback; - std::vector logging_messenger; - VkLayerInstanceDispatchTable dispatch_table = {}; - - // The following are for keeping track of the temporary callbacks that can - // be used in vkCreateInstance and vkDestroyInstance: - uint32_t num_tmp_report_callbacks; - VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos; - VkDebugReportCallbackEXT *tmp_report_callbacks; - uint32_t num_tmp_debug_messengers; - VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos; - VkDebugUtilsMessengerEXT *tmp_debug_messengers; -}; - -struct layer_data { - instance_layer_data *instance_data; - - debug_report_data *report_data; - VkLayerDispatchTable dispatch_table = {}; - - std::unordered_map> desc_template_map; - - bool wsi_enabled; - VkPhysicalDevice gpu; - - struct SubpassesUsageStates { - std::unordered_set subpasses_using_color_attachment; - std::unordered_set subpasses_using_depthstencil_attachment; - }; - // Uses unwrapped handles - std::unordered_map renderpasses_states; - - // Map of wrapped swapchain handles to arrays of wrapped swapchain image IDs - // Each swapchain has an immutable list of wrapped swapchain image IDs -- always return these IDs if they exist - std::unordered_map> swapchain_wrapped_image_handle_map; - - layer_data() : wsi_enabled(false), gpu(VK_NULL_HANDLE){}; -}; - -static std::unordered_map instance_layer_data_map; -static std::unordered_map layer_data_map; - -static std::mutex global_lock; // Protect map accesses and unique_id increments - -struct GenericHeader { - VkStructureType sType; - void *pNext; -}; - -template -bool ContainsExtStruct(const T *target, VkStructureType ext_type) { - assert(target != nullptr); - - const GenericHeader *ext_struct = reinterpret_cast(target->pNext); - - while (ext_struct != nullptr) { - if (ext_struct->sType == ext_type) { - return true; - } - - ext_struct = reinterpret_cast(ext_struct->pNext); - } - - return false; -} - -/* Unwrap a handle. */ -// must hold lock! -template -HandleType Unwrap(HandleType wrappedHandle) { - // TODO: don't use operator[] here. - return (HandleType)unique_id_mapping[reinterpret_cast(wrappedHandle)]; -} - -// Wrap a newly created handle with a new unique ID, and return the new ID -- must hold lock! -template -HandleType WrapNew(HandleType newlyCreatedHandle) { - auto unique_id = global_unique_id++; - unique_id_mapping[unique_id] = reinterpret_cast(newlyCreatedHandle); - return (HandleType)unique_id; -} - -} // namespace unique_objects diff --git a/layers/unique_objects_layer.md b/layers/unique_objects_layer.md deleted file mode 100644 index 45626441..00000000 --- a/layers/unique_objects_layer.md +++ /dev/null @@ -1,7 +0,0 @@ -# VK\_LAYER\_GOOGLE\_unique\_objects -The `VK_LAYER_LUNARG_unique_objects` is a validation-supporting utility layer which enables consistent and coherent validation in addition to proper operation on systems which return non-unique object handles. This layer aliases all non-dispatchable Vulkan objects with a unique identifier at object-creation time. The aliased handles are used during validation to ensure that duplicate object handles are correctly managed and tracked by the validation layers. - -Note: - -* For optimal efficiency, this layer MUST be last in the chain (closest to the display driver). -* If you are developing Vulkan extensions which include new APIs taking one or more Vulkan dispatchable objects as parameters, you may find it necessary to disable the unique objects layer in order use the validation layers. The best way to do this is to explicitly load the layers in the optimal order specified earlier but without this layer. This should result in a minimal decrease in functionality but still allow you to benefit from using the validation layers. diff --git a/layers/vk_format_utils.cpp b/layers/vk_format_utils.cpp deleted file mode 100644 index 1a5a08f3..00000000 --- a/layers/vk_format_utils.cpp +++ /dev/null @@ -1,1084 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Mark Lobodzinski - * Author: Dave Houlton - * - */ - -#include -#include -#include -#include -#include "vulkan/vulkan.h" -#include "vk_format_utils.h" - -struct VULKAN_FORMAT_INFO { - size_t size; - uint32_t channel_count; - VkFormatCompatibilityClass format_class; -}; - -// Disable auto-formatting for this large table -// clang-format off - -// Set up data structure with number of bytes and number of channels for each Vulkan format -const std::map vk_format_table = { - {VK_FORMAT_UNDEFINED, {0, 0, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT }}, - {VK_FORMAT_R4G4_UNORM_PACK8, {1, 2, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R4G4B4A4_UNORM_PACK16, {2, 4, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_B4G4R4A4_UNORM_PACK16, {2, 4, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R5G6B5_UNORM_PACK16, {2, 3, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_B5G6R5_UNORM_PACK16, {2, 3, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R5G5B5A1_UNORM_PACK16, {2, 4, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_B5G5R5A1_UNORM_PACK16, {2, 4, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_A1R5G5B5_UNORM_PACK16, {2, 4, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8_UNORM, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R8_SNORM, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R8_USCALED, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R8_SSCALED, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R8_UINT, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R8_SINT, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R8_SRGB, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_8_BIT}}, - {VK_FORMAT_R8G8_UNORM, {2, 2, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8G8_SNORM, {2, 2, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8G8_USCALED, {2, 2, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8G8_SSCALED, {2, 2, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8G8_UINT, {2, 2, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8G8_SINT, {2, 2, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8G8_SRGB, {2, 2, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R8G8B8_UNORM, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_R8G8B8_SNORM, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_R8G8B8_USCALED, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_R8G8B8_SSCALED, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_R8G8B8_UINT, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_R8G8B8_SINT, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_R8G8B8_SRGB, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_B8G8R8_UNORM, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_B8G8R8_SNORM, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_B8G8R8_USCALED, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_B8G8R8_SSCALED, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_B8G8R8_UINT, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_B8G8R8_SINT, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_B8G8R8_SRGB, {3, 3, VK_FORMAT_COMPATIBILITY_CLASS_24_BIT}}, - {VK_FORMAT_R8G8B8A8_UNORM, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R8G8B8A8_SNORM, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R8G8B8A8_USCALED, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R8G8B8A8_SSCALED, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R8G8B8A8_UINT, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R8G8B8A8_SINT, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R8G8B8A8_SRGB, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_B8G8R8A8_UNORM, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_B8G8R8A8_SNORM, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_B8G8R8A8_USCALED, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_B8G8R8A8_SSCALED, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_B8G8R8A8_UINT, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_B8G8R8A8_SINT, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_B8G8R8A8_SRGB, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A8B8G8R8_UNORM_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A8B8G8R8_SNORM_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A8B8G8R8_USCALED_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A8B8G8R8_SSCALED_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A8B8G8R8_UINT_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A8B8G8R8_SINT_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A8B8G8R8_SRGB_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2R10G10B10_UNORM_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2R10G10B10_SNORM_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2R10G10B10_USCALED_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2R10G10B10_SSCALED_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2R10G10B10_UINT_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2R10G10B10_SINT_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2B10G10R10_UNORM_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2B10G10R10_SNORM_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2B10G10R10_USCALED_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2B10G10R10_SSCALED_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2B10G10R10_UINT_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_A2B10G10R10_SINT_PACK32, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16_UNORM, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R16_SNORM, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R16_USCALED, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R16_SSCALED, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R16_UINT, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R16_SINT, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R16_SFLOAT, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_16_BIT}}, - {VK_FORMAT_R16G16_UNORM, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16G16_SNORM, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16G16_USCALED, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16G16_SSCALED, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16G16_UINT, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16G16_SINT, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16G16_SFLOAT, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R16G16B16_UNORM, {6, 3, VK_FORMAT_COMPATIBILITY_CLASS_48_BIT}}, - {VK_FORMAT_R16G16B16_SNORM, {6, 3, VK_FORMAT_COMPATIBILITY_CLASS_48_BIT}}, - {VK_FORMAT_R16G16B16_USCALED, {6, 3, VK_FORMAT_COMPATIBILITY_CLASS_48_BIT}}, - {VK_FORMAT_R16G16B16_SSCALED, {6, 3, VK_FORMAT_COMPATIBILITY_CLASS_48_BIT}}, - {VK_FORMAT_R16G16B16_UINT, {6, 3, VK_FORMAT_COMPATIBILITY_CLASS_48_BIT}}, - {VK_FORMAT_R16G16B16_SINT, {6, 3, VK_FORMAT_COMPATIBILITY_CLASS_48_BIT}}, - {VK_FORMAT_R16G16B16_SFLOAT, {6, 3, VK_FORMAT_COMPATIBILITY_CLASS_48_BIT}}, - {VK_FORMAT_R16G16B16A16_UNORM, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R16G16B16A16_SNORM, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R16G16B16A16_USCALED, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R16G16B16A16_SSCALED, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R16G16B16A16_UINT, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R16G16B16A16_SINT, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R16G16B16A16_SFLOAT, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R32_UINT, {4, 1, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R32_SINT, {4, 1, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R32_SFLOAT, {4, 1, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_R32G32_UINT, {8, 2, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R32G32_SINT, {8, 2, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R32G32_SFLOAT, {8, 2, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R32G32B32_UINT, {12, 3, VK_FORMAT_COMPATIBILITY_CLASS_96_BIT}}, - {VK_FORMAT_R32G32B32_SINT, {12, 3, VK_FORMAT_COMPATIBILITY_CLASS_96_BIT}}, - {VK_FORMAT_R32G32B32_SFLOAT, {12, 3, VK_FORMAT_COMPATIBILITY_CLASS_96_BIT}}, - {VK_FORMAT_R32G32B32A32_UINT, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_128_BIT}}, - {VK_FORMAT_R32G32B32A32_SINT, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_128_BIT}}, - {VK_FORMAT_R32G32B32A32_SFLOAT, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_128_BIT}}, - {VK_FORMAT_R64_UINT, {8, 1, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R64_SINT, {8, 1, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R64_SFLOAT, {8, 1, VK_FORMAT_COMPATIBILITY_CLASS_64_BIT}}, - {VK_FORMAT_R64G64_UINT, {16, 2, VK_FORMAT_COMPATIBILITY_CLASS_128_BIT}}, - {VK_FORMAT_R64G64_SINT, {16, 2, VK_FORMAT_COMPATIBILITY_CLASS_128_BIT}}, - {VK_FORMAT_R64G64_SFLOAT, {16, 2, VK_FORMAT_COMPATIBILITY_CLASS_128_BIT}}, - {VK_FORMAT_R64G64B64_UINT, {24, 3, VK_FORMAT_COMPATIBILITY_CLASS_192_BIT}}, - {VK_FORMAT_R64G64B64_SINT, {24, 3, VK_FORMAT_COMPATIBILITY_CLASS_192_BIT}}, - {VK_FORMAT_R64G64B64_SFLOAT, {24, 3, VK_FORMAT_COMPATIBILITY_CLASS_192_BIT}}, - {VK_FORMAT_R64G64B64A64_UINT, {32, 4, VK_FORMAT_COMPATIBILITY_CLASS_256_BIT}}, - {VK_FORMAT_R64G64B64A64_SINT, {32, 4, VK_FORMAT_COMPATIBILITY_CLASS_256_BIT}}, - {VK_FORMAT_R64G64B64A64_SFLOAT, {32, 4, VK_FORMAT_COMPATIBILITY_CLASS_256_BIT}}, - {VK_FORMAT_B10G11R11_UFLOAT_PACK32, {4, 3, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, {4, 3, VK_FORMAT_COMPATIBILITY_CLASS_32_BIT}}, - {VK_FORMAT_D16_UNORM, {2, 1, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT}}, - {VK_FORMAT_X8_D24_UNORM_PACK32, {4, 1, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT}}, - {VK_FORMAT_D32_SFLOAT, {4, 1, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT}}, - {VK_FORMAT_S8_UINT, {1, 1, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT}}, - {VK_FORMAT_D16_UNORM_S8_UINT, {3, 2, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT}}, - {VK_FORMAT_D24_UNORM_S8_UINT, {4, 2, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT}}, - {VK_FORMAT_D32_SFLOAT_S8_UINT, {8, 2, VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT}}, - {VK_FORMAT_BC1_RGB_UNORM_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC1_RGB_BIT}}, - {VK_FORMAT_BC1_RGB_SRGB_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC1_RGB_BIT}}, - {VK_FORMAT_BC1_RGBA_UNORM_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC1_RGBA_BIT}}, - {VK_FORMAT_BC1_RGBA_SRGB_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC1_RGBA_BIT}}, - {VK_FORMAT_BC2_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC2_BIT}}, - {VK_FORMAT_BC2_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC2_BIT}}, - {VK_FORMAT_BC3_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC3_BIT}}, - {VK_FORMAT_BC3_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC3_BIT}}, - {VK_FORMAT_BC4_UNORM_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC4_BIT}}, - {VK_FORMAT_BC4_SNORM_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC4_BIT}}, - {VK_FORMAT_BC5_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC5_BIT}}, - {VK_FORMAT_BC5_SNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC5_BIT}}, - {VK_FORMAT_BC6H_UFLOAT_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC6H_BIT}}, - {VK_FORMAT_BC6H_SFLOAT_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC6H_BIT}}, - {VK_FORMAT_BC7_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC7_BIT}}, - {VK_FORMAT_BC7_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_BC7_BIT}}, - {VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, {8, 3, VK_FORMAT_COMPATIBILITY_CLASS_ETC2_RGB_BIT}}, - {VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, {8, 3, VK_FORMAT_COMPATIBILITY_CLASS_ETC2_RGB_BIT}}, - {VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_ETC2_RGBA_BIT}}, - {VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_ETC2_RGBA_BIT}}, - {VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ETC2_EAC_RGBA_BIT}}, - {VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ETC2_EAC_RGBA_BIT}}, - {VK_FORMAT_EAC_R11_UNORM_BLOCK, {8, 1, VK_FORMAT_COMPATIBILITY_CLASS_EAC_R_BIT}}, - {VK_FORMAT_EAC_R11_SNORM_BLOCK, {8, 1, VK_FORMAT_COMPATIBILITY_CLASS_EAC_R_BIT}}, - {VK_FORMAT_EAC_R11G11_UNORM_BLOCK, {16, 2, VK_FORMAT_COMPATIBILITY_CLASS_EAC_RG_BIT}}, - {VK_FORMAT_EAC_R11G11_SNORM_BLOCK, {16, 2, VK_FORMAT_COMPATIBILITY_CLASS_EAC_RG_BIT}}, - {VK_FORMAT_ASTC_4x4_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4_BIT}}, - {VK_FORMAT_ASTC_4x4_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4_BIT}}, - {VK_FORMAT_ASTC_5x4_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4_BIT}}, - {VK_FORMAT_ASTC_5x4_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4_BIT}}, - {VK_FORMAT_ASTC_5x5_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5_BIT}}, - {VK_FORMAT_ASTC_5x5_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5_BIT}}, - {VK_FORMAT_ASTC_6x5_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5_BIT}}, - {VK_FORMAT_ASTC_6x5_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5_BIT}}, - {VK_FORMAT_ASTC_6x6_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6_BIT}}, - {VK_FORMAT_ASTC_6x6_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6_BIT}}, - {VK_FORMAT_ASTC_8x5_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5_BIT}}, - {VK_FORMAT_ASTC_8x5_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5_BIT}}, - {VK_FORMAT_ASTC_8x6_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6_BIT}}, - {VK_FORMAT_ASTC_8x6_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6_BIT}}, - {VK_FORMAT_ASTC_8x8_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8_BIT}}, - {VK_FORMAT_ASTC_8x8_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8_BIT}}, - {VK_FORMAT_ASTC_10x5_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5_BIT}}, - {VK_FORMAT_ASTC_10x5_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5_BIT}}, - {VK_FORMAT_ASTC_10x6_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6_BIT}}, - {VK_FORMAT_ASTC_10x6_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6_BIT}}, - {VK_FORMAT_ASTC_10x8_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8_BIT}}, - {VK_FORMAT_ASTC_10x8_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8_BIT}}, - {VK_FORMAT_ASTC_10x10_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10_BIT}}, - {VK_FORMAT_ASTC_10x10_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10_BIT}}, - {VK_FORMAT_ASTC_12x10_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10_BIT}}, - {VK_FORMAT_ASTC_12x10_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10_BIT}}, - {VK_FORMAT_ASTC_12x12_UNORM_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12_BIT}}, - {VK_FORMAT_ASTC_12x12_SRGB_BLOCK, {16, 4, VK_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12_BIT}}, - {VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC1_2BPP_BIT}}, - {VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC1_4BPP_BIT}}, - {VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC2_2BPP_BIT}}, - {VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC2_4BPP_BIT}}, - {VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC1_2BPP_BIT}}, - {VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC1_4BPP_BIT}}, - {VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC2_2BPP_BIT}}, - {VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_PVRTC2_4BPP_BIT}}, - /* KHR_sampler_YCbCr_conversion */ - {VK_FORMAT_G8B8G8R8_422_UNORM_KHR, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32BIT_G8B8G8R8}}, - {VK_FORMAT_B8G8R8G8_422_UNORM_KHR, {4, 4, VK_FORMAT_COMPATIBILITY_CLASS_32BIT_B8G8R8G8}}, - {VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_R10G10B10A10}}, - {VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_G10B10G10R10}}, - {VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_B10G10R10G10}}, - {VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_R12G12B12A12}}, - {VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_G12B12G12R12}}, - {VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_B12G12R12G12}}, - {VK_FORMAT_G16B16G16R16_422_UNORM_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_G16B16G16R16}}, - {VK_FORMAT_B16G16R16G16_422_UNORM_KHR, {8, 4, VK_FORMAT_COMPATIBILITY_CLASS_64BIT_B16G16R16G16}} -#if 0 // TBD - Figure out what 'size' means for multi-planar formats - {VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_420}}, - {VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_420}}, - {VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_422}}, - {VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_422}}, - {VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_444}}, - {VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_420}}, - {VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_420}}, - {VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_422}}, - {VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_422}}, - {VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_444}}, - {VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_420}}, - {VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_420}}, - {VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_422}}, - {VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_422}}, - {VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_444}}, - {VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_420}}, - {VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_420}}, - {VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_422}}, - {VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_422}}, - {VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, {0, 3, VK_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_444}} -#endif -}; - -// Renable formatting -// clang-format on - -// Return true if format is an ETC2 or EAC compressed texture format -VK_LAYER_EXPORT bool FormatIsCompressed_ETC2_EAC(VkFormat format) { - bool found = false; - - switch (format) { - case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: - case VK_FORMAT_EAC_R11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11_SNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: - found = true; - break; - default: - break; - } - return found; -} - -// Return true if format is an ASTC compressed texture format -VK_LAYER_EXPORT bool FormatIsCompressed_ASTC_LDR(VkFormat format) { - bool found = false; - - switch (format) { - case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: - found = true; - break; - default: - break; - } - return found; -} - -// Return true if format is a BC compressed texture format -VK_LAYER_EXPORT bool FormatIsCompressed_BC(VkFormat format) { - bool found = false; - - switch (format) { - case VK_FORMAT_BC1_RGB_UNORM_BLOCK: - case VK_FORMAT_BC1_RGB_SRGB_BLOCK: - case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: - case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: - case VK_FORMAT_BC2_UNORM_BLOCK: - case VK_FORMAT_BC2_SRGB_BLOCK: - case VK_FORMAT_BC3_UNORM_BLOCK: - case VK_FORMAT_BC3_SRGB_BLOCK: - case VK_FORMAT_BC4_UNORM_BLOCK: - case VK_FORMAT_BC4_SNORM_BLOCK: - case VK_FORMAT_BC5_UNORM_BLOCK: - case VK_FORMAT_BC5_SNORM_BLOCK: - case VK_FORMAT_BC6H_UFLOAT_BLOCK: - case VK_FORMAT_BC6H_SFLOAT_BLOCK: - case VK_FORMAT_BC7_UNORM_BLOCK: - case VK_FORMAT_BC7_SRGB_BLOCK: - found = true; - break; - default: - break; - } - return found; -} - -// Return true if format is a PVRTC compressed texture format -VK_LAYER_EXPORT bool FormatIsCompressed_PVRTC(VkFormat format) { - bool found = false; - - switch (format) { - case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: - found = true; - break; - default: - break; - } - return found; -} - -// Single-plane "_422" formats are treated as 2x1 compressed (for copies) -VK_LAYER_EXPORT bool FormatIsSinglePlane_422(VkFormat format) { - bool found = false; - - switch (format) { - case VK_FORMAT_G8B8G8R8_422_UNORM_KHR: - case VK_FORMAT_B8G8R8G8_422_UNORM_KHR: - case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: - case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: - case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: - case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: - case VK_FORMAT_G16B16G16R16_422_UNORM_KHR: - case VK_FORMAT_B16G16R16G16_422_UNORM_KHR: - found = true; - break; - default: - break; - } - return found; -} - -// Return true if format is compressed -VK_LAYER_EXPORT bool FormatIsCompressed(VkFormat format) { - return (FormatIsCompressed_ASTC_LDR(format) || FormatIsCompressed_BC(format) || FormatIsCompressed_ETC2_EAC(format) || - FormatIsCompressed_PVRTC(format)); -} - -// Return true if format is a depth or stencil format -VK_LAYER_EXPORT bool FormatIsDepthOrStencil(VkFormat format) { - return (FormatIsDepthAndStencil(format) || FormatIsDepthOnly(format) || FormatIsStencilOnly(format)); -} - -// Return true if format contains depth and stencil information -VK_LAYER_EXPORT bool FormatIsDepthAndStencil(VkFormat format) { - bool is_ds = false; - - switch (format) { - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - is_ds = true; - break; - default: - break; - } - return is_ds; -} - -// Return true if format is a stencil-only format -VK_LAYER_EXPORT bool FormatIsStencilOnly(VkFormat format) { return (format == VK_FORMAT_S8_UINT); } - -// Return true if format is a depth-only format -VK_LAYER_EXPORT bool FormatIsDepthOnly(VkFormat format) { - bool is_depth = false; - - switch (format) { - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D32_SFLOAT: - is_depth = true; - break; - default: - break; - } - - return is_depth; -} - -// Return true if format is of type NORM -VK_LAYER_EXPORT bool FormatIsNorm(VkFormat format) { - bool is_norm = false; - - switch (format) { - case VK_FORMAT_R4G4_UNORM_PACK8: - case VK_FORMAT_R4G4B4A4_UNORM_PACK16: - case VK_FORMAT_R5G6B5_UNORM_PACK16: - case VK_FORMAT_R5G5B5A1_UNORM_PACK16: - case VK_FORMAT_A1R5G5B5_UNORM_PACK16: - case VK_FORMAT_R8_UNORM: - case VK_FORMAT_R8_SNORM: - case VK_FORMAT_R8G8_UNORM: - case VK_FORMAT_R8G8_SNORM: - case VK_FORMAT_R8G8B8_UNORM: - case VK_FORMAT_R8G8B8_SNORM: - case VK_FORMAT_R8G8B8A8_UNORM: - case VK_FORMAT_R8G8B8A8_SNORM: - case VK_FORMAT_A8B8G8R8_UNORM_PACK32: - case VK_FORMAT_A8B8G8R8_SNORM_PACK32: - case VK_FORMAT_A2B10G10R10_UNORM_PACK32: - case VK_FORMAT_A2B10G10R10_SNORM_PACK32: - case VK_FORMAT_R16_UNORM: - case VK_FORMAT_R16_SNORM: - case VK_FORMAT_R16G16_UNORM: - case VK_FORMAT_R16G16_SNORM: - case VK_FORMAT_R16G16B16_UNORM: - case VK_FORMAT_R16G16B16_SNORM: - case VK_FORMAT_R16G16B16A16_UNORM: - case VK_FORMAT_R16G16B16A16_SNORM: - case VK_FORMAT_BC1_RGB_UNORM_BLOCK: - case VK_FORMAT_BC2_UNORM_BLOCK: - case VK_FORMAT_BC3_UNORM_BLOCK: - case VK_FORMAT_BC4_UNORM_BLOCK: - case VK_FORMAT_BC4_SNORM_BLOCK: - case VK_FORMAT_BC5_UNORM_BLOCK: - case VK_FORMAT_BC5_SNORM_BLOCK: - case VK_FORMAT_BC7_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: - case VK_FORMAT_EAC_R11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11_SNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: - case VK_FORMAT_B5G6R5_UNORM_PACK16: - case VK_FORMAT_B8G8R8_UNORM: - case VK_FORMAT_B8G8R8_SNORM: - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_B8G8R8A8_SNORM: - case VK_FORMAT_A2R10G10B10_UNORM_PACK32: - case VK_FORMAT_A2R10G10B10_SNORM_PACK32: - is_norm = true; - break; - default: - break; - } - - return is_norm; -} - -// Return true if format is of type UNORM -VK_LAYER_EXPORT bool FormatIsUNorm(VkFormat format) { - bool is_unorm = false; - - switch (format) { - case VK_FORMAT_R4G4_UNORM_PACK8: - case VK_FORMAT_R4G4B4A4_UNORM_PACK16: - case VK_FORMAT_R5G6B5_UNORM_PACK16: - case VK_FORMAT_R5G5B5A1_UNORM_PACK16: - case VK_FORMAT_A1R5G5B5_UNORM_PACK16: - case VK_FORMAT_R8_UNORM: - case VK_FORMAT_R8G8_UNORM: - case VK_FORMAT_R8G8B8_UNORM: - case VK_FORMAT_R8G8B8A8_UNORM: - case VK_FORMAT_A8B8G8R8_UNORM_PACK32: - case VK_FORMAT_A2B10G10R10_UNORM_PACK32: - case VK_FORMAT_R16_UNORM: - case VK_FORMAT_R16G16_UNORM: - case VK_FORMAT_R16G16B16_UNORM: - case VK_FORMAT_R16G16B16A16_UNORM: - case VK_FORMAT_BC1_RGB_UNORM_BLOCK: - case VK_FORMAT_BC2_UNORM_BLOCK: - case VK_FORMAT_BC3_UNORM_BLOCK: - case VK_FORMAT_BC4_UNORM_BLOCK: - case VK_FORMAT_BC5_UNORM_BLOCK: - case VK_FORMAT_BC7_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: - case VK_FORMAT_EAC_R11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: - case VK_FORMAT_B5G6R5_UNORM_PACK16: - case VK_FORMAT_B8G8R8_UNORM: - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_A2R10G10B10_UNORM_PACK32: - is_unorm = true; - break; - default: - break; - } - - return is_unorm; -} - -// Return true if format is of type SNORM -VK_LAYER_EXPORT bool FormatIsSNorm(VkFormat format) { - bool is_snorm = false; - - switch (format) { - case VK_FORMAT_R8_SNORM: - case VK_FORMAT_R8G8_SNORM: - case VK_FORMAT_R8G8B8_SNORM: - case VK_FORMAT_R8G8B8A8_SNORM: - case VK_FORMAT_A8B8G8R8_SNORM_PACK32: - case VK_FORMAT_A2B10G10R10_SNORM_PACK32: - case VK_FORMAT_R16_SNORM: - case VK_FORMAT_R16G16_SNORM: - case VK_FORMAT_R16G16B16_SNORM: - case VK_FORMAT_R16G16B16A16_SNORM: - case VK_FORMAT_BC4_SNORM_BLOCK: - case VK_FORMAT_BC5_SNORM_BLOCK: - case VK_FORMAT_EAC_R11_SNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: - case VK_FORMAT_B8G8R8_SNORM: - case VK_FORMAT_B8G8R8A8_SNORM: - case VK_FORMAT_A2R10G10B10_SNORM_PACK32: - is_snorm = true; - break; - default: - break; - } - - return is_snorm; -} - -// Return true if format is an integer format -VK_LAYER_EXPORT bool FormatIsInt(VkFormat format) { return (FormatIsSInt(format) || FormatIsUInt(format)); } - -// Return true if format is an unsigned integer format -VK_LAYER_EXPORT bool FormatIsUInt(VkFormat format) { - bool is_uint = false; - - switch (format) { - case VK_FORMAT_R8_UINT: - case VK_FORMAT_S8_UINT: - case VK_FORMAT_R8G8_UINT: - case VK_FORMAT_R8G8B8_UINT: - case VK_FORMAT_R8G8B8A8_UINT: - case VK_FORMAT_A8B8G8R8_UINT_PACK32: - case VK_FORMAT_A2B10G10R10_UINT_PACK32: - case VK_FORMAT_R16_UINT: - case VK_FORMAT_R16G16_UINT: - case VK_FORMAT_R16G16B16_UINT: - case VK_FORMAT_R16G16B16A16_UINT: - case VK_FORMAT_R32_UINT: - case VK_FORMAT_R32G32_UINT: - case VK_FORMAT_R32G32B32_UINT: - case VK_FORMAT_R32G32B32A32_UINT: - case VK_FORMAT_R64_UINT: - case VK_FORMAT_R64G64_UINT: - case VK_FORMAT_R64G64B64_UINT: - case VK_FORMAT_R64G64B64A64_UINT: - case VK_FORMAT_B8G8R8_UINT: - case VK_FORMAT_B8G8R8A8_UINT: - case VK_FORMAT_A2R10G10B10_UINT_PACK32: - is_uint = true; - break; - default: - break; - } - - return is_uint; -} - -// Return true if format is a signed integer format -VK_LAYER_EXPORT bool FormatIsSInt(VkFormat format) { - bool is_sint = false; - - switch (format) { - case VK_FORMAT_R8_SINT: - case VK_FORMAT_R8G8_SINT: - case VK_FORMAT_R8G8B8_SINT: - case VK_FORMAT_R8G8B8A8_SINT: - case VK_FORMAT_A8B8G8R8_SINT_PACK32: - case VK_FORMAT_A2B10G10R10_SINT_PACK32: - case VK_FORMAT_R16_SINT: - case VK_FORMAT_R16G16_SINT: - case VK_FORMAT_R16G16B16_SINT: - case VK_FORMAT_R16G16B16A16_SINT: - case VK_FORMAT_R32_SINT: - case VK_FORMAT_R32G32_SINT: - case VK_FORMAT_R32G32B32_SINT: - case VK_FORMAT_R32G32B32A32_SINT: - case VK_FORMAT_R64_SINT: - case VK_FORMAT_R64G64_SINT: - case VK_FORMAT_R64G64B64_SINT: - case VK_FORMAT_R64G64B64A64_SINT: - case VK_FORMAT_B8G8R8_SINT: - case VK_FORMAT_B8G8R8A8_SINT: - case VK_FORMAT_A2R10G10B10_SINT_PACK32: - is_sint = true; - break; - default: - break; - } - - return is_sint; -} - -// Return true if format is a floating-point format -VK_LAYER_EXPORT bool FormatIsFloat(VkFormat format) { - bool is_float = false; - - switch (format) { - case VK_FORMAT_R16_SFLOAT: - case VK_FORMAT_R16G16_SFLOAT: - case VK_FORMAT_R16G16B16_SFLOAT: - case VK_FORMAT_R16G16B16A16_SFLOAT: - case VK_FORMAT_R32_SFLOAT: - case VK_FORMAT_R32G32_SFLOAT: - case VK_FORMAT_R32G32B32_SFLOAT: - case VK_FORMAT_R32G32B32A32_SFLOAT: - case VK_FORMAT_R64_SFLOAT: - case VK_FORMAT_R64G64_SFLOAT: - case VK_FORMAT_R64G64B64_SFLOAT: - case VK_FORMAT_R64G64B64A64_SFLOAT: - case VK_FORMAT_B10G11R11_UFLOAT_PACK32: - case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: - case VK_FORMAT_BC6H_UFLOAT_BLOCK: - case VK_FORMAT_BC6H_SFLOAT_BLOCK: - is_float = true; - break; - default: - break; - } - - return is_float; -} - -// Return true if format is in the SRGB colorspace -VK_LAYER_EXPORT bool FormatIsSRGB(VkFormat format) { - bool is_srgb = false; - - switch (format) { - case VK_FORMAT_R8_SRGB: - case VK_FORMAT_R8G8_SRGB: - case VK_FORMAT_R8G8B8_SRGB: - case VK_FORMAT_R8G8B8A8_SRGB: - case VK_FORMAT_A8B8G8R8_SRGB_PACK32: - case VK_FORMAT_BC1_RGB_SRGB_BLOCK: - case VK_FORMAT_BC2_SRGB_BLOCK: - case VK_FORMAT_BC3_SRGB_BLOCK: - case VK_FORMAT_BC7_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: - case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: - case VK_FORMAT_B8G8R8_SRGB: - case VK_FORMAT_B8G8R8A8_SRGB: - is_srgb = true; - break; - default: - break; - } - - return is_srgb; -} - -// Return true if format is a USCALED format -VK_LAYER_EXPORT bool FormatIsUScaled(VkFormat format) { - bool is_uscaled = false; - - switch (format) { - case VK_FORMAT_R8_USCALED: - case VK_FORMAT_R8G8_USCALED: - case VK_FORMAT_R8G8B8_USCALED: - case VK_FORMAT_B8G8R8_USCALED: - case VK_FORMAT_R8G8B8A8_USCALED: - case VK_FORMAT_B8G8R8A8_USCALED: - case VK_FORMAT_A8B8G8R8_USCALED_PACK32: - case VK_FORMAT_A2R10G10B10_USCALED_PACK32: - case VK_FORMAT_A2B10G10R10_USCALED_PACK32: - case VK_FORMAT_R16_USCALED: - case VK_FORMAT_R16G16_USCALED: - case VK_FORMAT_R16G16B16_USCALED: - case VK_FORMAT_R16G16B16A16_USCALED: - is_uscaled = true; - break; - default: - break; - } - - return is_uscaled; -} - -// Return true if format is a SSCALED format -VK_LAYER_EXPORT bool FormatIsSScaled(VkFormat format) { - bool is_sscaled = false; - - switch (format) { - case VK_FORMAT_R8_SSCALED: - case VK_FORMAT_R8G8_SSCALED: - case VK_FORMAT_R8G8B8_SSCALED: - case VK_FORMAT_B8G8R8_SSCALED: - case VK_FORMAT_R8G8B8A8_SSCALED: - case VK_FORMAT_B8G8R8A8_SSCALED: - case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: - case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: - case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: - case VK_FORMAT_R16_SSCALED: - case VK_FORMAT_R16G16_SSCALED: - case VK_FORMAT_R16G16B16_SSCALED: - case VK_FORMAT_R16G16B16A16_SSCALED: - is_sscaled = true; - break; - default: - break; - } - - return is_sscaled; -} - -// Return compressed texel block sizes for block compressed formats -VK_LAYER_EXPORT VkExtent3D FormatCompressedTexelBlockExtent(VkFormat format) { - VkExtent3D block_size = {1, 1, 1}; - switch (format) { - case VK_FORMAT_BC1_RGB_UNORM_BLOCK: - case VK_FORMAT_BC1_RGB_SRGB_BLOCK: - case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: - case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: - case VK_FORMAT_BC2_UNORM_BLOCK: - case VK_FORMAT_BC2_SRGB_BLOCK: - case VK_FORMAT_BC3_UNORM_BLOCK: - case VK_FORMAT_BC3_SRGB_BLOCK: - case VK_FORMAT_BC4_UNORM_BLOCK: - case VK_FORMAT_BC4_SNORM_BLOCK: - case VK_FORMAT_BC5_UNORM_BLOCK: - case VK_FORMAT_BC5_SNORM_BLOCK: - case VK_FORMAT_BC6H_UFLOAT_BLOCK: - case VK_FORMAT_BC6H_SFLOAT_BLOCK: - case VK_FORMAT_BC7_UNORM_BLOCK: - case VK_FORMAT_BC7_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: - case VK_FORMAT_EAC_R11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11_SNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: - block_size = {4, 4, 1}; - break; - case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: - block_size = {5, 4, 1}; - break; - case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: - block_size = {5, 5, 1}; - break; - case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: - block_size = {6, 5, 1}; - break; - case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: - block_size = {6, 6, 1}; - break; - case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: - block_size = {8, 5, 1}; - break; - case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: - block_size = {8, 6, 1}; - break; - case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: - block_size = {8, 8, 1}; - break; - case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: - block_size = {10, 5, 1}; - break; - case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: - block_size = {10, 6, 1}; - break; - case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: - block_size = {10, 8, 1}; - break; - case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: - block_size = {10, 10, 1}; - break; - case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: - block_size = {12, 10, 1}; - break; - case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: - block_size = {12, 12, 1}; - break; - case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: - block_size = {8, 4, 1}; - break; - case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: - block_size = {4, 4, 1}; - break; - // With KHR_sampler_ycbcr_conversion, these formats are treated as 2x1 compressed (for copies) - case VK_FORMAT_G8B8G8R8_422_UNORM_KHR: - case VK_FORMAT_B8G8R8G8_422_UNORM_KHR: - case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: - case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: - case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: - case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: - case VK_FORMAT_G16B16G16R16_422_UNORM_KHR: - case VK_FORMAT_B16G16R16G16_422_UNORM_KHR: - block_size = {2, 1, 1}; - break; - - default: - break; - } - return block_size; -} - -VK_LAYER_EXPORT uint32_t FormatPlaneCount(VkFormat format) { - switch (format) { - case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: - case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: - case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: - case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: - case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: - case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: - case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: - case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: - case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: - case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: - case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: - case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: - return 3; - break; - case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: - case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: - case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: - case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: - case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: - case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: - case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: - case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: - return 2; - break; - default: - return 1; - break; - } -} - -// Return format class of the specified format -VK_LAYER_EXPORT VkFormatCompatibilityClass FormatCompatibilityClass(VkFormat format) { - auto item = vk_format_table.find(format); - if (item != vk_format_table.end()) { - return item->second.format_class; - } - return VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT; -} - -// Return size, in bytes, of a pixel of the specified format -VK_LAYER_EXPORT size_t FormatSize(VkFormat format) { - auto item = vk_format_table.find(format); - if (item != vk_format_table.end()) { - return item->second.size; - } - return 0; -} - -// Return the number of channels for a given format -uint32_t FormatChannelCount(VkFormat format) { - auto item = vk_format_table.find(format); - if (item != vk_format_table.end()) { - return item->second.channel_count; - } - return 0; -} - -// Perform a zero-tolerant modulo operation -VK_LAYER_EXPORT VkDeviceSize SafeModulo(VkDeviceSize dividend, VkDeviceSize divisor) { - VkDeviceSize result = 0; - if (divisor != 0) { - result = dividend % divisor; - } - return result; -} - -struct VULKAN_PER_PLANE_COMPATIBILITY { - uint32_t width_divisor; - uint32_t height_divisor; - VkFormat compatible_format; -}; - -struct VULKAN_MULTIPLANE_COMPATIBILITY { - VULKAN_PER_PLANE_COMPATIBILITY per_plane[VK_MULTIPLANE_FORMAT_MAX_PLANES]; -}; - -// Source: Vulkan spec Table 45. Plane Format Compatibility Table -// clang-format off -const std::map vk_multiplane_compatibility_map { - { VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, { { { 1, 1, VK_FORMAT_R8_UNORM }, - { 2, 2, VK_FORMAT_R8_UNORM }, - { 2, 2, VK_FORMAT_R8_UNORM } } } }, - { VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, { { { 1, 1, VK_FORMAT_R8_UNORM }, - { 2, 2, VK_FORMAT_R8G8_UNORM }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, { { { 1, 1, VK_FORMAT_R8_UNORM }, - { 2, 1, VK_FORMAT_R8_UNORM }, - { 2, 1, VK_FORMAT_R8_UNORM } } } }, - { VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, { { { 1, 1, VK_FORMAT_R8_UNORM }, - { 2, 1, VK_FORMAT_R8G8_UNORM }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, { { { 1, 1, VK_FORMAT_R8_UNORM }, - { 1, 1, VK_FORMAT_R8_UNORM }, - { 1, 1, VK_FORMAT_R8_UNORM } } } }, - { VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 2, 2, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 2, 2, VK_FORMAT_R10X6_UNORM_PACK16_KHR } } } }, - { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 2, 2, VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 2, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 2, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR } } } }, - { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 2, 1, VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 1, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR }, - { 1, 1, VK_FORMAT_R10X6_UNORM_PACK16_KHR } } } }, - { VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 2, 2, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 2, 2, VK_FORMAT_R12X4_UNORM_PACK16_KHR } } } }, - { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 2, 2, VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 2, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 2, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR } } } }, - { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 2, 1, VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, { { { 1, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 1, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR }, - { 1, 1, VK_FORMAT_R12X4_UNORM_PACK16_KHR } } } }, - { VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, { { { 1, 1, VK_FORMAT_R16_UNORM }, - { 2, 2, VK_FORMAT_R16_UNORM }, - { 2, 2, VK_FORMAT_R16_UNORM } } } }, - { VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, { { { 1, 1, VK_FORMAT_R16_UNORM }, - { 2, 2, VK_FORMAT_R16G16_UNORM }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, { { { 1, 1, VK_FORMAT_R16_UNORM }, - { 2, 1, VK_FORMAT_R16_UNORM }, - { 2, 1, VK_FORMAT_R16_UNORM } } } }, - { VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, { { { 1, 1, VK_FORMAT_R16_UNORM }, - { 2, 1, VK_FORMAT_R16G16_UNORM }, - { 1, 1, VK_FORMAT_UNDEFINED } } } }, - { VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, { { { 1, 1, VK_FORMAT_R16_UNORM }, - { 1, 1, VK_FORMAT_R16_UNORM }, - { 1, 1, VK_FORMAT_R16_UNORM } } } } -}; -// clang-format on - -VK_LAYER_EXPORT VkFormat FindMultiplaneCompatibleFormat(VkFormat mp_fmt, uint32_t plane) { - auto it = vk_multiplane_compatibility_map.find(mp_fmt); - if ((it == vk_multiplane_compatibility_map.end()) || (plane >= VK_MULTIPLANE_FORMAT_MAX_PLANES)) { - return VK_FORMAT_UNDEFINED; - } - - return it->second.per_plane[plane].compatible_format; -} diff --git a/layers/vk_format_utils.h b/layers/vk_format_utils.h deleted file mode 100644 index e76f9ec2..00000000 --- a/layers/vk_format_utils.h +++ /dev/null @@ -1,166 +0,0 @@ -/* Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Mark Lobodzinski - * Author: Courtney Goeltzenleuchter - * Author: Dave Houlton - */ - -#pragma once -#include -#include -#include "vulkan/vulkan.h" - -#if !defined(VK_LAYER_EXPORT) -#if defined(__GNUC__) && __GNUC__ >= 4 -#define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -#define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#else -#define VK_LAYER_EXPORT -#endif -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -#define VK_MULTIPLANE_FORMAT_MAX_PLANES 3 - -typedef enum VkFormatCompatibilityClass { - VK_FORMAT_COMPATIBILITY_CLASS_NONE_BIT = 0, - VK_FORMAT_COMPATIBILITY_CLASS_8_BIT = 1, - VK_FORMAT_COMPATIBILITY_CLASS_16_BIT = 2, - VK_FORMAT_COMPATIBILITY_CLASS_24_BIT = 3, - VK_FORMAT_COMPATIBILITY_CLASS_32_BIT = 4, - VK_FORMAT_COMPATIBILITY_CLASS_48_BIT = 5, - VK_FORMAT_COMPATIBILITY_CLASS_64_BIT = 6, - VK_FORMAT_COMPATIBILITY_CLASS_96_BIT = 7, - VK_FORMAT_COMPATIBILITY_CLASS_128_BIT = 8, - VK_FORMAT_COMPATIBILITY_CLASS_192_BIT = 9, - VK_FORMAT_COMPATIBILITY_CLASS_256_BIT = 10, - VK_FORMAT_COMPATIBILITY_CLASS_BC1_RGB_BIT = 11, - VK_FORMAT_COMPATIBILITY_CLASS_BC1_RGBA_BIT = 12, - VK_FORMAT_COMPATIBILITY_CLASS_BC2_BIT = 13, - VK_FORMAT_COMPATIBILITY_CLASS_BC3_BIT = 14, - VK_FORMAT_COMPATIBILITY_CLASS_BC4_BIT = 15, - VK_FORMAT_COMPATIBILITY_CLASS_BC5_BIT = 16, - VK_FORMAT_COMPATIBILITY_CLASS_BC6H_BIT = 17, - VK_FORMAT_COMPATIBILITY_CLASS_BC7_BIT = 18, - VK_FORMAT_COMPATIBILITY_CLASS_ETC2_RGB_BIT = 19, - VK_FORMAT_COMPATIBILITY_CLASS_ETC2_RGBA_BIT = 20, - VK_FORMAT_COMPATIBILITY_CLASS_ETC2_EAC_RGBA_BIT = 21, - VK_FORMAT_COMPATIBILITY_CLASS_EAC_R_BIT = 22, - VK_FORMAT_COMPATIBILITY_CLASS_EAC_RG_BIT = 23, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4_BIT = 24, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4_BIT = 25, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5_BIT = 26, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5_BIT = 27, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6_BIT = 28, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5_BIT = 29, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6_BIT = 20, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8_BIT = 31, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5_BIT = 32, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6_BIT = 33, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8_BIT = 34, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10_BIT = 35, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10_BIT = 36, - VK_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12_BIT = 37, - VK_FORMAT_COMPATIBILITY_CLASS_D16_BIT = 38, - VK_FORMAT_COMPATIBILITY_CLASS_D24_BIT = 39, - VK_FORMAT_COMPATIBILITY_CLASS_D32_BIT = 30, - VK_FORMAT_COMPATIBILITY_CLASS_S8_BIT = 41, - VK_FORMAT_COMPATIBILITY_CLASS_D16S8_BIT = 42, - VK_FORMAT_COMPATIBILITY_CLASS_D24S8_BIT = 43, - VK_FORMAT_COMPATIBILITY_CLASS_D32S8_BIT = 44, - VK_FORMAT_COMPATIBILITY_CLASS_PVRTC1_2BPP_BIT = 45, - VK_FORMAT_COMPATIBILITY_CLASS_PVRTC1_4BPP_BIT = 46, - VK_FORMAT_COMPATIBILITY_CLASS_PVRTC2_2BPP_BIT = 47, - VK_FORMAT_COMPATIBILITY_CLASS_PVRTC2_4BPP_BIT = 48, - /* KHR_sampler_YCbCr_conversion */ - VK_FORMAT_COMPATIBILITY_CLASS_32BIT_G8B8G8R8 = 49, - VK_FORMAT_COMPATIBILITY_CLASS_32BIT_B8G8R8G8 = 50, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_R10G10B10A10 = 51, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_G10B10G10R10 = 52, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_B10G10R10G10 = 53, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_R12G12B12A12 = 54, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_G12B12G12R12 = 55, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_B12G12R12G12 = 56, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_G16B16G16R16 = 57, - VK_FORMAT_COMPATIBILITY_CLASS_64BIT_B16G16R16G16 = 58, - VK_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_420 = 59, - VK_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_420 = 60, - VK_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_422 = 61, - VK_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_422 = 62, - VK_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_444 = 63, - VK_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_420 = 64, - VK_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_420 = 65, - VK_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_422 = 66, - VK_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_422 = 67, - VK_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_444 = 68, - VK_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_420 = 69, - VK_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_420 = 70, - VK_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_422 = 71, - VK_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_422 = 72, - VK_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_444 = 73, - VK_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_420 = 74, - VK_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_420 = 75, - VK_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_422 = 76, - VK_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_422 = 77, - VK_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_444 = 78, - VK_FORMAT_COMPATIBILITY_CLASS_MAX_ENUM = 79 -} VkFormatCompatibilityClass; - -VK_LAYER_EXPORT bool FormatIsDepthOrStencil(VkFormat format); -VK_LAYER_EXPORT bool FormatIsDepthAndStencil(VkFormat format); -VK_LAYER_EXPORT bool FormatIsDepthOnly(VkFormat format); -VK_LAYER_EXPORT bool FormatIsStencilOnly(VkFormat format); -VK_LAYER_EXPORT bool FormatIsCompressed_ETC2_EAC(VkFormat format); -VK_LAYER_EXPORT bool FormatIsCompressed_ASTC_LDR(VkFormat format); -VK_LAYER_EXPORT bool FormatIsCompressed_BC(VkFormat format); -VK_LAYER_EXPORT bool FormatIsCompressed_PVRTC(VkFormat format); -VK_LAYER_EXPORT bool FormatIsSinglePlane_422(VkFormat format); -VK_LAYER_EXPORT bool FormatIsNorm(VkFormat format); -VK_LAYER_EXPORT bool FormatIsUNorm(VkFormat format); -VK_LAYER_EXPORT bool FormatIsSNorm(VkFormat format); -VK_LAYER_EXPORT bool FormatIsInt(VkFormat format); -VK_LAYER_EXPORT bool FormatIsSInt(VkFormat format); -VK_LAYER_EXPORT bool FormatIsUInt(VkFormat format); -VK_LAYER_EXPORT bool FormatIsFloat(VkFormat format); -VK_LAYER_EXPORT bool FormatIsSRGB(VkFormat format); -VK_LAYER_EXPORT bool FormatIsUScaled(VkFormat format); -VK_LAYER_EXPORT bool FormatIsSScaled(VkFormat format); -VK_LAYER_EXPORT bool FormatIsCompressed(VkFormat format); - -VK_LAYER_EXPORT uint32_t FormatPlaneCount(VkFormat format); -VK_LAYER_EXPORT uint32_t FormatChannelCount(VkFormat format); -VK_LAYER_EXPORT VkExtent3D FormatCompressedTexelBlockExtent(VkFormat format); -VK_LAYER_EXPORT size_t FormatSize(VkFormat format); -VK_LAYER_EXPORT VkFormatCompatibilityClass FormatCompatibilityClass(VkFormat format); -VK_LAYER_EXPORT VkDeviceSize SafeModulo(VkDeviceSize dividend, VkDeviceSize divisor); -VK_LAYER_EXPORT VkFormat FindMultiplaneCompatibleFormat(VkFormat fmt, uint32_t plane); - -static inline bool FormatIsUndef(VkFormat format) { return (format == VK_FORMAT_UNDEFINED); } -static inline bool FormatHasDepth(VkFormat format) { return (FormatIsDepthOnly(format) || FormatIsDepthAndStencil(format)); } -static inline bool FormatHasStencil(VkFormat format) { return (FormatIsStencilOnly(format) || FormatIsDepthAndStencil(format)); } -static inline bool FormatIsMultiplane(VkFormat format) { return ((FormatPlaneCount(format)) > 1u); } -static inline bool FormatIsColor(VkFormat format) { - return !(FormatIsUndef(format) || FormatIsDepthOrStencil(format) || FormatIsMultiplane(format)); -} - -#ifdef __cplusplus -} -#endif diff --git a/layers/vk_layer_config.cpp b/layers/vk_layer_config.cpp deleted file mode 100644 index 51f42780..00000000 --- a/layers/vk_layer_config.cpp +++ /dev/null @@ -1,321 +0,0 @@ -/************************************************************************** - * - * Copyright 2014 Valve Software - * Copyright 2015 Google Inc. - * All Rights Reserved. - * - * 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: Jon Ashburn - * Author: Courtney Goeltzenleuchter - * Author: Tobin Ehlis - * Author: Mark Lobodzinski - **************************************************************************/ -#include "vk_layer_config.h" -#include "vulkan/vk_sdk_platform.h" -#include -#include -#include -#include -#include -#include -#include - -#if defined(_WIN32) -#include -#endif - -#define MAX_CHARS_PER_LINE 4096 - -class ConfigFile { - public: - ConfigFile(); - ~ConfigFile(); - - const char *getOption(const std::string &_option); - void setOption(const std::string &_option, const std::string &_val); - - private: - bool m_fileIsParsed; - std::map m_valueMap; - - void parseFile(const char *filename); -}; - -static ConfigFile g_configFileObj; - -std::string getEnvironment(const char *variable) { -#if !defined(__ANDROID__) && !defined(_WIN32) - const char *output = getenv(variable); - return output == NULL ? "" : output; -#elif defined(_WIN32) - int size = GetEnvironmentVariable(variable, NULL, 0); - if (size == 0) { - return ""; - } - char *buffer = new char[size]; - GetEnvironmentVariable(variable, buffer, size); - std::string output = buffer; - delete[] buffer; - return output; -#else - return ""; -#endif -} - -VK_LAYER_EXPORT const char *getLayerOption(const char *_option) { return g_configFileObj.getOption(_option); } - -// If option is NULL or stdout, return stdout, otherwise try to open option -// as a filename. If successful, return file handle, otherwise stdout -VK_LAYER_EXPORT FILE *getLayerLogOutput(const char *_option, const char *layerName) { - FILE *log_output = NULL; - if (!_option || !strcmp("stdout", _option)) - log_output = stdout; - else { - log_output = fopen(_option, "w"); - if (log_output == NULL) { - if (_option) - std::cout << std::endl - << layerName << " ERROR: Bad output filename specified: " << _option << ". Writing to STDOUT instead" - << std::endl - << std::endl; - log_output = stdout; - } - } - return log_output; -} - -// Map option strings to flag enum values -VK_LAYER_EXPORT VkFlags GetLayerOptionFlags(std::string _option, std::unordered_map const &enum_data, - uint32_t option_default) { - VkDebugReportFlagsEXT flags = option_default; - std::string option_list = g_configFileObj.getOption(_option.c_str()); - - while (option_list.length() != 0) { - // Find length of option string - std::size_t option_length = option_list.find(","); - if (option_length == option_list.npos) { - option_length = option_list.size(); - } - - // Get first option in list - const std::string option = option_list.substr(0, option_length); - - auto enum_value = enum_data.find(option); - if (enum_value != enum_data.end()) { - flags |= enum_value->second; - } - - // Remove first option from option_list - option_list.erase(0, option_length); - // Remove possible comma separator - std::size_t char_position = option_list.find(","); - if (char_position == 0) { - option_list.erase(char_position, 1); - } - // Remove possible space - char_position = option_list.find(" "); - if (char_position == 0) { - option_list.erase(char_position, 1); - } - } - return flags; -} - -VK_LAYER_EXPORT void setLayerOption(const char *_option, const char *_val) { g_configFileObj.setOption(_option, _val); } - -// Constructor for ConfigFile. Initialize layers to log error messages to stdout by default. If a vk_layer_settings file is present, -// its settings will override the defaults. -ConfigFile::ConfigFile() : m_fileIsParsed(false) { - m_valueMap["lunarg_core_validation.report_flags"] = "error"; - m_valueMap["lunarg_object_tracker.report_flags"] = "error"; - m_valueMap["lunarg_parameter_validation.report_flags"] = "error"; - m_valueMap["google_threading.report_flags"] = "error"; - m_valueMap["google_unique_objects.report_flags"] = "error"; - -#ifdef WIN32 - // For Windows, enable message logging AND OutputDebugString - m_valueMap["lunarg_core_validation.debug_action"] = - "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"; - m_valueMap["lunarg_object_tracker.debug_action"] = - "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"; - m_valueMap["lunarg_parameter_validation.debug_action"] = - "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"; - m_valueMap["google_threading.debug_action"] = - "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"; - m_valueMap["google_unique_objects.debug_action"] = - "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"; -#else // WIN32 - m_valueMap["lunarg_core_validation.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG"; - m_valueMap["lunarg_object_tracker.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG"; - m_valueMap["lunarg_parameter_validation.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG"; - m_valueMap["google_threading.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG"; - m_valueMap["google_unique_objects.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG"; -#endif // WIN32 - - m_valueMap["lunarg_core_validation.log_filename"] = "stdout"; - m_valueMap["lunarg_object_tracker.log_filename"] = "stdout"; - m_valueMap["lunarg_parameter_validation.log_filename"] = "stdout"; - m_valueMap["google_threading.log_filename"] = "stdout"; - m_valueMap["google_unique_objects.log_filename"] = "stdout"; -} - -ConfigFile::~ConfigFile() {} - -const char *ConfigFile::getOption(const std::string &_option) { - std::map::const_iterator it; - if (!m_fileIsParsed) { - std::string envPath = getEnvironment("VK_LAYER_SETTINGS_PATH"); - - // If the path exists use it, else use vk_layer_settings - struct stat info; - if (stat(envPath.c_str(), &info) == 0) { - // If this is a directory, look for vk_layer_settings within the directory - if (info.st_mode & S_IFDIR) { - envPath += "/vk_layer_settings.txt"; - } - parseFile(envPath.c_str()); - } else { - parseFile("vk_layer_settings.txt"); - } - } - - if ((it = m_valueMap.find(_option)) == m_valueMap.end()) - return ""; - else - return it->second.c_str(); -} - -void ConfigFile::setOption(const std::string &_option, const std::string &_val) { - if (!m_fileIsParsed) { - std::string envPath = getEnvironment("VK_LAYER_SETTINGS_PATH"); - - // If the path exists use it, else use vk_layer_settings - struct stat info; - if (stat(envPath.c_str(), &info) == 0) { - // If this is a directory, look for vk_layer_settings within the directory - if (info.st_mode & S_IFDIR) { - envPath += "/vk_layer_settings.txt"; - } - parseFile(envPath.c_str()); - } else { - parseFile("vk_layer_settings.txt"); - } - } - - m_valueMap[_option] = _val; -} - -void ConfigFile::parseFile(const char *filename) { - std::ifstream file; - char buf[MAX_CHARS_PER_LINE]; - - m_fileIsParsed = true; - - file.open(filename); - if (!file.good()) { - return; - } - - // read tokens from the file and form option, value pairs - file.getline(buf, MAX_CHARS_PER_LINE); - while (!file.eof()) { - char option[512]; - char value[512]; - - char *pComment; - - // discard any comments delimited by '#' in the line - pComment = strchr(buf, '#'); - if (pComment) *pComment = '\0'; - - if (sscanf(buf, " %511[^\n\t =] = %511[^\n \t]", option, value) == 2) { - std::string optStr(option); - std::string valStr(value); - m_valueMap[optStr] = valStr; - } - file.getline(buf, MAX_CHARS_PER_LINE); - } -} - -VK_LAYER_EXPORT void PrintMessageFlags(VkFlags vk_flags, char *msg_flags) { - bool separator = false; - - msg_flags[0] = 0; - if (vk_flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) { - strcat(msg_flags, "DEBUG"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "INFO"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "WARN"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "PERF"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "ERROR"); - } -} - -VK_LAYER_EXPORT void PrintMessageSeverity(VkFlags vk_flags, char *msg_flags) { - bool separator = false; - - msg_flags[0] = 0; - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) { - strcat(msg_flags, "VERBOSE"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "INFO"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "WARN"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "ERROR"); - } -} - -VK_LAYER_EXPORT void PrintMessageType(VkFlags vk_flags, char *msg_flags) { - bool separator = false; - - msg_flags[0] = 0; - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) { - strcat(msg_flags, "GEN"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) { - strcat(msg_flags, "SPEC"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "PERF"); - separator = true; - } -} diff --git a/layers/vk_layer_config.h b/layers/vk_layer_config.h deleted file mode 100644 index e0b9d326..00000000 --- a/layers/vk_layer_config.h +++ /dev/null @@ -1,72 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Jon Ashburn - * Author: Mark Lobodzinski - **************************************************************************/ -#pragma once -#include "vulkan/vulkan.h" -#include "vulkan/vk_layer.h" -#include -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -// Definitions for Debug Actions -typedef enum VkLayerDbgActionBits { - VK_DBG_LAYER_ACTION_IGNORE = 0x00000000, - VK_DBG_LAYER_ACTION_CALLBACK = 0x00000001, - VK_DBG_LAYER_ACTION_LOG_MSG = 0x00000002, - VK_DBG_LAYER_ACTION_BREAK = 0x00000004, - VK_DBG_LAYER_ACTION_DEBUG_OUTPUT = 0x00000008, - VK_DBG_LAYER_ACTION_DEFAULT = 0x40000000, -} VkLayerDbgActionBits; -typedef VkFlags VkLayerDbgActionFlags; - -const std::unordered_map debug_actions_option_definitions = { - {std::string("VK_DBG_LAYER_ACTION_IGNORE"), VK_DBG_LAYER_ACTION_IGNORE}, - {std::string("VK_DBG_LAYER_ACTION_CALLBACK"), VK_DBG_LAYER_ACTION_CALLBACK}, - {std::string("VK_DBG_LAYER_ACTION_LOG_MSG"), VK_DBG_LAYER_ACTION_LOG_MSG}, - {std::string("VK_DBG_LAYER_ACTION_BREAK"), VK_DBG_LAYER_ACTION_BREAK}, -#if defined(WIN32) - {std::string("VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"), VK_DBG_LAYER_ACTION_DEBUG_OUTPUT}, -#endif - {std::string("VK_DBG_LAYER_ACTION_DEFAULT"), VK_DBG_LAYER_ACTION_DEFAULT}}; - -const std::unordered_map report_flags_option_definitions = { - {std::string("warn"), VK_DEBUG_REPORT_WARNING_BIT_EXT}, - {std::string("info"), VK_DEBUG_REPORT_INFORMATION_BIT_EXT}, - {std::string("perf"), VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT}, - {std::string("error"), VK_DEBUG_REPORT_ERROR_BIT_EXT}, - {std::string("debug"), VK_DEBUG_REPORT_DEBUG_BIT_EXT}}; - -VK_LAYER_EXPORT const char *getLayerOption(const char *_option); -VK_LAYER_EXPORT FILE *getLayerLogOutput(const char *_option, const char *layerName); -VK_LAYER_EXPORT VkFlags GetLayerOptionFlags(std::string _option, std::unordered_map const &enum_data, - uint32_t option_default); - -VK_LAYER_EXPORT void setLayerOption(const char *_option, const char *_val); -VK_LAYER_EXPORT void PrintMessageFlags(VkFlags vk_flags, char *msg_flags); -VK_LAYER_EXPORT void PrintMessageSeverity(VkFlags vk_flags, char *msg_flags); -VK_LAYER_EXPORT void PrintMessageType(VkFlags vk_flags, char *msg_flags); - -#ifdef __cplusplus -} -#endif diff --git a/layers/vk_layer_data.h b/layers/vk_layer_data.h deleted file mode 100644 index 046d2f48..00000000 --- a/layers/vk_layer_data.h +++ /dev/null @@ -1,55 +0,0 @@ -/* Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Tobin Ehlis - */ - -#ifndef LAYER_DATA_H -#define LAYER_DATA_H - -#include -#include -#include "vk_layer_table.h" - -// For the given data key, look up the layer_data instance from given layer_data_map -template -DATA_T *GetLayerDataPtr(void *data_key, std::unordered_map &layer_data_map) { - DATA_T *debug_data; - typename std::unordered_map::const_iterator got; - - /* TODO: We probably should lock here, or have caller lock */ - got = layer_data_map.find(data_key); - - if (got == layer_data_map.end()) { - debug_data = new DATA_T; - layer_data_map[(void *)data_key] = debug_data; - } else { - debug_data = got->second; - } - - return debug_data; -} - -template -void FreeLayerDataPtr(void *data_key, std::unordered_map &layer_data_map) { - auto got = layer_data_map.find(data_key); - assert(got != layer_data_map.end()); - - delete got->second; - layer_data_map.erase(got); -} - -#endif // LAYER_DATA_H diff --git a/layers/vk_layer_extension_utils.cpp b/layers/vk_layer_extension_utils.cpp deleted file mode 100644 index 4c1e3963..00000000 --- a/layers/vk_layer_extension_utils.cpp +++ /dev/null @@ -1,66 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Courtney Goeltzenleuchter - * - */ - -#include "string.h" -#include "vk_layer_extension_utils.h" - -#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) - -/* - * This file contains utility functions for layers - */ - -VK_LAYER_EXPORT VkResult util_GetExtensionProperties(const uint32_t count, const VkExtensionProperties *layer_extensions, - uint32_t *pCount, VkExtensionProperties *pProperties) { - uint32_t copy_size; - - if (pProperties == NULL || layer_extensions == NULL) { - *pCount = count; - return VK_SUCCESS; - } - - copy_size = *pCount < count ? *pCount : count; - memcpy(pProperties, layer_extensions, copy_size * sizeof(VkExtensionProperties)); - *pCount = copy_size; - if (copy_size < count) { - return VK_INCOMPLETE; - } - - return VK_SUCCESS; -} - -VK_LAYER_EXPORT VkResult util_GetLayerProperties(const uint32_t count, const VkLayerProperties *layer_properties, uint32_t *pCount, - VkLayerProperties *pProperties) { - uint32_t copy_size; - - if (pProperties == NULL || layer_properties == NULL) { - *pCount = count; - return VK_SUCCESS; - } - - copy_size = *pCount < count ? *pCount : count; - memcpy(pProperties, layer_properties, copy_size * sizeof(VkLayerProperties)); - *pCount = copy_size; - if (copy_size < count) { - return VK_INCOMPLETE; - } - - return VK_SUCCESS; -} diff --git a/layers/vk_layer_extension_utils.h b/layers/vk_layer_extension_utils.h deleted file mode 100644 index 4a51c166..00000000 --- a/layers/vk_layer_extension_utils.h +++ /dev/null @@ -1,40 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Courtney Goeltzenleuchter - * - */ - -#include "vulkan/vk_layer.h" - -#ifndef LAYER_EXTENSION_UTILS_H -#define LAYER_EXTENSION_UTILS_H - -#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) - -/* - * This file contains static functions for the generated layers - */ -extern "C" { - -VK_LAYER_EXPORT VkResult util_GetExtensionProperties(const uint32_t count, const VkExtensionProperties *layer_extensions, - uint32_t *pCount, VkExtensionProperties *pProperties); - -VK_LAYER_EXPORT VkResult util_GetLayerProperties(const uint32_t count, const VkLayerProperties *layer_properties, uint32_t *pCount, - VkLayerProperties *pProperties); - -} // extern "C" -#endif // LAYER_EXTENSION_UTILS_H diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h deleted file mode 100644 index ba0206fd..00000000 --- a/layers/vk_layer_logging.h +++ /dev/null @@ -1,1133 +0,0 @@ -/* Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Courtney Goeltzenleuchter - * Author: Tobin Ehlis - * Author: Mark Young - * - */ - -#ifndef LAYER_LOGGING_H -#define LAYER_LOGGING_H - -#include "vk_loader_layer.h" -#include "vk_layer_config.h" -#include "vk_layer_data.h" -#include "vk_layer_table.h" -#include "vk_loader_platform.h" -#include "vulkan/vk_layer.h" -#include "vk_object_types.h" -#include "vk_validation_error_messages.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// TODO: Could be autogenerated for the specific handles for extra type safety... -template -static inline uint64_t HandleToUint64(HANDLE_T *h) { - return reinterpret_cast(h); -} - -static inline uint64_t HandleToUint64(uint64_t h) { return h; } - -// Data we store per label for logging -typedef struct _LoggingLabelData { - std::string name; - float color[4]; -} LoggingLabelData; - -typedef struct _debug_report_data { - VkLayerDbgFunctionNode *debug_callback_list; - VkLayerDbgFunctionNode *default_debug_callback_list; - VkDebugUtilsMessageSeverityFlagsEXT active_severities; - VkDebugUtilsMessageTypeFlagsEXT active_types; - bool g_DEBUG_REPORT; - bool g_DEBUG_UTILS; - std::unordered_map *debugObjectNameMap; - std::unordered_map *debugUtilsObjectNameMap; - std::unordered_map> *debugUtilsQueueLabels; - bool queueLabelHasInsert; - std::unordered_map> *debugUtilsCmdBufLabels; - bool cmdBufLabelHasInsert; -} debug_report_data; - -template debug_report_data *GetLayerDataPtr(void *data_key, - std::unordered_map &data_map); - -static inline void DebugReportFlagsToAnnotFlags(VkDebugReportFlagsEXT dr_flags, bool default_flag_is_spec, - VkDebugUtilsMessageSeverityFlagsEXT *da_severity, - VkDebugUtilsMessageTypeFlagsEXT *da_type) { - // All layer warnings are spec warnings currently. At least as far as anything not specifically - // called out. In the future, we'll label things using the new split severity and type values. - *da_type = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT; - *da_severity = 0; - if ((dr_flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) != 0) { - *da_severity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT; - } - if ((dr_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) != 0) { - *da_severity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT; - } - if ((dr_flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) != 0) { - *da_severity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; - } - if ((dr_flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) != 0) { - *da_severity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - } - if ((dr_flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) != 0) { - *da_severity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; - } -} - -// Forward Declarations -static inline bool debug_log_msg(const debug_report_data *debug_data, VkFlags msg_flags, VkDebugReportObjectTypeEXT object_type, - uint64_t src_object, size_t location, int32_t msg_code, const char *layer_prefix, - const char *message, const char *text_vuid = NULL); - -// Add a debug message callback node structure to the specified callback linked list -static inline void AddDebugCallbackNode(debug_report_data *debug_data, VkLayerDbgFunctionNode **list_head, - VkLayerDbgFunctionNode *new_node) { - new_node->pNext = *list_head; - *list_head = new_node; -} - -// Remove specified debug messenger node structure from the specified linked list -static inline void RemoveDebugUtilsMessenger(debug_report_data *debug_data, VkLayerDbgFunctionNode **list_head, - VkDebugUtilsMessengerEXT messenger) { - VkLayerDbgFunctionNode *cur_callback = *list_head; - VkLayerDbgFunctionNode *prev_callback = cur_callback; - bool matched = false; - VkFlags local_severities = 0; - VkFlags local_types = 0; - - while (cur_callback) { - if (cur_callback->is_messenger && cur_callback->messenger.messenger == messenger) { - matched = true; - prev_callback->pNext = cur_callback->pNext; - if (*list_head == cur_callback) { - *list_head = cur_callback->pNext; - } - debug_log_msg(debug_data, VK_DEBUG_REPORT_DEBUG_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, - reinterpret_cast(cur_callback->messenger.messenger), 0, 0, "DebugUtilsMessenger", - "Destroyed messenger\n"); - } else { - matched = false; - local_severities |= cur_callback->messenger.messageSeverity; - local_types |= cur_callback->messenger.messageType; - } - prev_callback = cur_callback; - cur_callback = cur_callback->pNext; - if (matched) { - free(prev_callback); - } - } - debug_data->active_severities = local_severities; - debug_data->active_types = local_types; -} - -// Remove specified debug message callback node structure from the specified callback linked list -static inline void RemoveDebugUtilsMessageCallback(debug_report_data *debug_data, VkLayerDbgFunctionNode **list_head, - VkDebugReportCallbackEXT callback) { - VkLayerDbgFunctionNode *cur_callback = *list_head; - VkLayerDbgFunctionNode *prev_callback = cur_callback; - bool matched = false; - VkFlags local_severities = 0; - VkFlags local_types = 0; - - while (cur_callback) { - if (!cur_callback->is_messenger && cur_callback->report.msgCallback == callback) { - matched = true; - prev_callback->pNext = cur_callback->pNext; - if (*list_head == cur_callback) { - *list_head = cur_callback->pNext; - } - debug_log_msg(debug_data, VK_DEBUG_REPORT_DEBUG_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, - reinterpret_cast(cur_callback->report.msgCallback), 0, 0, "DebugReport", - "Destroyed callback\n"); - } else { - matched = false; - VkFlags this_severities = 0; - VkFlags this_types = 0; - DebugReportFlagsToAnnotFlags(cur_callback->report.msgFlags, true, &this_severities, &this_types); - local_severities |= this_severities; - local_types |= this_types; - } - prev_callback = cur_callback; - cur_callback = cur_callback->pNext; - if (matched) { - free(prev_callback); - } - } - debug_data->active_severities = local_severities; - debug_data->active_types = local_types; -} - -// Removes all debug callback function nodes from the specified callback linked lists and frees their resources -static inline void RemoveAllMessageCallbacks(debug_report_data *debug_data, VkLayerDbgFunctionNode **list_head) { - VkLayerDbgFunctionNode *current_callback = *list_head; - VkLayerDbgFunctionNode *prev_callback = current_callback; - - while (current_callback) { - prev_callback = current_callback->pNext; - if (!current_callback->is_messenger) { - debug_log_msg(debug_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, - (uint64_t)current_callback->report.msgCallback, 0, 0, "DebugReport", - "Debug Report callbacks not removed before DestroyInstance"); - } else { - debug_log_msg(debug_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, - (uint64_t)current_callback->messenger.messenger, 0, 0, "Messenger", - "Debug messengers not removed before DestroyInstance"); - } - free(current_callback); - current_callback = prev_callback; - } - *list_head = NULL; -} - -// Note that text_vuid is a default parameter, and is optional. See the above forward declaration -static inline bool debug_log_msg(const debug_report_data *debug_data, VkFlags msg_flags, VkDebugReportObjectTypeEXT object_type, - uint64_t src_object, size_t location, int32_t msg_code, const char *layer_prefix, - const char *message, const char *text_vuid) { - bool bail = false; - VkLayerDbgFunctionNode *layer_dbg_node = NULL; - - if (debug_data->debug_callback_list != NULL) { - layer_dbg_node = debug_data->debug_callback_list; - } else { - layer_dbg_node = debug_data->default_debug_callback_list; - } - - VkDebugUtilsMessageSeverityFlagsEXT severity; - VkDebugUtilsMessageTypeFlagsEXT types; - VkDebugUtilsMessengerCallbackDataEXT callback_data; - VkDebugUtilsObjectNameInfoEXT object_name_info; - - // Convert the info to the VK_EXT_debug_utils form in case we need it. - DebugReportFlagsToAnnotFlags(msg_flags, true, &severity, &types); - object_name_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; - object_name_info.pNext = NULL; - object_name_info.objectType = convertDebugReportObjectToCoreObject(object_type); - object_name_info.objectHandle = (uint64_t)(uintptr_t)src_object; - object_name_info.pObjectName = NULL; - - callback_data.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; - callback_data.pNext = NULL; - callback_data.flags = 0; - callback_data.pMessageIdName = text_vuid; - callback_data.messageIdNumber = msg_code; - callback_data.pMessage = message; - callback_data.queueLabelCount = 0; - callback_data.pQueueLabels = NULL; - callback_data.cmdBufLabelCount = 0; - callback_data.pCmdBufLabels = NULL; - callback_data.objectCount = 1; - callback_data.pObjects = &object_name_info; - - VkDebugUtilsLabelEXT *queue_labels = nullptr; - VkDebugUtilsLabelEXT *cmd_buf_labels = nullptr; - std::string new_debug_report_message = ""; - std::ostringstream oss; - - if (0 != src_object) { - oss << "Object: 0x" << std::hex << src_object; - // If this is a queue, add any queue labels to the callback data. - if (VK_OBJECT_TYPE_QUEUE == object_name_info.objectType) { - auto label_iter = debug_data->debugUtilsQueueLabels->find(reinterpret_cast(src_object)); - if (label_iter != debug_data->debugUtilsQueueLabels->end()) { - queue_labels = new VkDebugUtilsLabelEXT[label_iter->second.size()]; - if (nullptr != queue_labels) { - // Record the labels, but record them in reverse order since we want the - // most recent at the top. - uint32_t label_size = static_cast(label_iter->second.size()); - uint32_t last_index = label_size - 1; - for (uint32_t label = 0; label < label_size; ++label) { - queue_labels[last_index - label].sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; - queue_labels[last_index - label].pNext = nullptr; - queue_labels[last_index - label].pLabelName = label_iter->second[label].name.c_str(); - queue_labels[last_index - label].color[0] = label_iter->second[label].color[0]; - queue_labels[last_index - label].color[1] = label_iter->second[label].color[1]; - queue_labels[last_index - label].color[2] = label_iter->second[label].color[2]; - queue_labels[last_index - label].color[3] = label_iter->second[label].color[3]; - } - callback_data.queueLabelCount = label_size; - callback_data.pQueueLabels = queue_labels; - } - } - // If this is a command buffer, add any command buffer labels to the callback data. - } else if (VK_OBJECT_TYPE_COMMAND_BUFFER == object_name_info.objectType) { - auto label_iter = debug_data->debugUtilsCmdBufLabels->find(reinterpret_cast(src_object)); - if (label_iter != debug_data->debugUtilsCmdBufLabels->end()) { - cmd_buf_labels = new VkDebugUtilsLabelEXT[label_iter->second.size()]; - if (nullptr != cmd_buf_labels) { - // Record the labels, but record them in reverse order since we want the - // most recent at the top. - uint32_t label_size = static_cast(label_iter->second.size()); - uint32_t last_index = label_size - 1; - for (uint32_t label = 0; label < label_size; ++label) { - cmd_buf_labels[last_index - label].sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; - cmd_buf_labels[last_index - label].pNext = nullptr; - cmd_buf_labels[last_index - label].pLabelName = label_iter->second[label].name.c_str(); - cmd_buf_labels[last_index - label].color[0] = label_iter->second[label].color[0]; - cmd_buf_labels[last_index - label].color[1] = label_iter->second[label].color[1]; - cmd_buf_labels[last_index - label].color[2] = label_iter->second[label].color[2]; - cmd_buf_labels[last_index - label].color[3] = label_iter->second[label].color[3]; - } - callback_data.cmdBufLabelCount = label_size; - callback_data.pCmdBufLabels = cmd_buf_labels; - } - } - } - // Look for any debug utils or marker names to use for this object - callback_data.pObjects[0].pObjectName = NULL; - auto utils_name_iter = debug_data->debugUtilsObjectNameMap->find(src_object); - if (utils_name_iter != debug_data->debugUtilsObjectNameMap->end()) { - callback_data.pObjects[0].pObjectName = utils_name_iter->second.c_str(); - } else { - auto marker_name_iter = debug_data->debugObjectNameMap->find(src_object); - if (marker_name_iter != debug_data->debugObjectNameMap->end()) { - callback_data.pObjects[0].pObjectName = marker_name_iter->second.c_str(); - } - } - if (NULL != callback_data.pObjects[0].pObjectName) { - oss << " (Name = " << callback_data.pObjects[0].pObjectName << " : Type = "; - } else { - oss << " (Type = "; - } - oss << std::to_string(object_type) << ")"; - } else { - oss << "Object: VK_NULL_HANDLE (Type = " << std::to_string(object_type) << ")"; - } - new_debug_report_message += oss.str(); - new_debug_report_message += " | "; - new_debug_report_message += message; - - while (layer_dbg_node) { - // If the app uses the VK_EXT_debug_report extension, call all of those registered callbacks. - if (!layer_dbg_node->is_messenger && (layer_dbg_node->report.msgFlags & msg_flags)) { - if (text_vuid != nullptr) { - // If a text vuid is supplied for the old debug report extension, prepend it to the message string - new_debug_report_message.insert(0, " ] "); - new_debug_report_message.insert(0, text_vuid); - new_debug_report_message.insert(0, " [ "); - } - - if (layer_dbg_node->report.pfnMsgCallback(msg_flags, object_type, src_object, location, msg_code, layer_prefix, - new_debug_report_message.c_str(), layer_dbg_node->pUserData)) { - bail = true; - } - // If the app uses the VK_EXT_debug_utils extension, call all of those registered callbacks. - } else if (layer_dbg_node->is_messenger && (layer_dbg_node->messenger.messageSeverity & severity) && - (layer_dbg_node->messenger.messageType & types)) { - if (layer_dbg_node->messenger.pfnUserCallback(static_cast(severity), types, - &callback_data, layer_dbg_node->pUserData)) { - bail = true; - } - } - layer_dbg_node = layer_dbg_node->pNext; - } - - if (nullptr != queue_labels) { - delete[] queue_labels; - } - if (nullptr != cmd_buf_labels) { - delete[] cmd_buf_labels; - } - - return bail; -} - -static inline void DebugAnnotFlagsToReportFlags(VkDebugUtilsMessageSeverityFlagBitsEXT da_severity, - VkDebugUtilsMessageTypeFlagsEXT da_type, VkDebugReportFlagsEXT *dr_flags) { - *dr_flags = 0; - - if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_ERROR_BIT_EXT; - } else if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) != 0) { - if ((da_type & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; - } else { - *dr_flags |= VK_DEBUG_REPORT_WARNING_BIT_EXT; - } - } else if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT; - } else if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_DEBUG_BIT_EXT; - } -} - -static inline bool debug_messenger_log_msg(const debug_report_data *debug_data, - VkDebugUtilsMessageSeverityFlagBitsEXT message_severity, - VkDebugUtilsMessageTypeFlagsEXT message_type, - VkDebugUtilsMessengerCallbackDataEXT *callback_data) { - bool bail = false; - VkLayerDbgFunctionNode *layer_dbg_node = NULL; - - if (debug_data->debug_callback_list != NULL) { - layer_dbg_node = debug_data->debug_callback_list; - } else { - layer_dbg_node = debug_data->default_debug_callback_list; - } - - VkDebugReportFlagsEXT object_flags = 0; - - DebugAnnotFlagsToReportFlags(message_severity, message_type, &object_flags); - - while (layer_dbg_node) { - if (layer_dbg_node->is_messenger && (layer_dbg_node->messenger.messageSeverity & message_severity) && - (layer_dbg_node->messenger.messageType & message_type)) { - // Loop through each object and give it the proper name if it was set. - for (uint32_t obj = 0; obj < callback_data->objectCount; obj++) { - auto it = debug_data->debugUtilsObjectNameMap->find(callback_data->pObjects[obj].objectHandle); - if (it == debug_data->debugUtilsObjectNameMap->end()) { - continue; - } - callback_data->pObjects[obj].pObjectName = it->second.c_str(); - } - if (layer_dbg_node->messenger.pfnUserCallback(message_severity, message_type, callback_data, - layer_dbg_node->pUserData)) { - bail = true; - } - } else if (!layer_dbg_node->is_messenger && layer_dbg_node->report.msgFlags & object_flags) { - auto it = debug_data->debugObjectNameMap->find(callback_data->pObjects[0].objectHandle); - VkDebugReportObjectTypeEXT object_type = convertCoreObjectToDebugReportObject(callback_data->pObjects[0].objectType); - if (it == debug_data->debugObjectNameMap->end()) { - if (layer_dbg_node->report.pfnMsgCallback(object_flags, object_type, callback_data->pObjects[0].objectHandle, 0, - callback_data->messageIdNumber, callback_data->pMessageIdName, - callback_data->pMessage, layer_dbg_node->pUserData)) { - bail = true; - } - } else { - std::string newMsg = "SrcObject name = "; - newMsg.append(it->second.c_str()); - newMsg.append(" "); - newMsg.append(callback_data->pMessage); - if (layer_dbg_node->report.pfnMsgCallback(object_flags, object_type, callback_data->pObjects[0].objectHandle, 0, - callback_data->messageIdNumber, callback_data->pMessageIdName, - newMsg.c_str(), layer_dbg_node->pUserData)) { - bail = true; - } - } - } - layer_dbg_node = layer_dbg_node->pNext; - } - - return bail; -} - -static inline debug_report_data *debug_utils_create_instance( - VkLayerInstanceDispatchTable *table, VkInstance inst, uint32_t extension_count, - const char *const *enabled_extensions) // layer or extension name to be enabled -{ - debug_report_data *debug_data = (debug_report_data *)malloc(sizeof(debug_report_data)); - if (!debug_data) return NULL; - - memset(debug_data, 0, sizeof(debug_report_data)); - for (uint32_t i = 0; i < extension_count; i++) { - // TODO: Check other property fields - if (strcmp(enabled_extensions[i], VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) { - debug_data->g_DEBUG_REPORT = true; - } else if (strcmp(enabled_extensions[i], VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) { - debug_data->g_DEBUG_UTILS = true; - } - } - debug_data->debugObjectNameMap = new std::unordered_map; - debug_data->debugUtilsObjectNameMap = new std::unordered_map; - debug_data->debugUtilsQueueLabels = new std::unordered_map>; - debug_data->debugUtilsCmdBufLabels = new std::unordered_map>; - debug_data->queueLabelHasInsert = false; - debug_data->cmdBufLabelHasInsert = false; - return debug_data; -} - -static inline void layer_debug_utils_destroy_instance(debug_report_data *debug_data) { - if (debug_data) { - RemoveAllMessageCallbacks(debug_data, &debug_data->default_debug_callback_list); - RemoveAllMessageCallbacks(debug_data, &debug_data->debug_callback_list); - delete debug_data->debugObjectNameMap; - delete debug_data->debugUtilsObjectNameMap; - delete debug_data->debugUtilsQueueLabels; - delete debug_data->debugUtilsCmdBufLabels; - free(debug_data); - } -} - -static inline debug_report_data *layer_debug_utils_create_device(debug_report_data *instance_debug_data, VkDevice device) { - // DEBUG_REPORT shares data between Instance and Device, - // so just return instance's data pointer - return instance_debug_data; -} - -static inline void layer_debug_utils_destroy_device(VkDevice device) { - // Nothing to do since we're using instance data record -} - -static inline void layer_destroy_messenger_callback(debug_report_data *debug_data, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *allocator) { - RemoveDebugUtilsMessenger(debug_data, &debug_data->debug_callback_list, messenger); - RemoveDebugUtilsMessenger(debug_data, &debug_data->default_debug_callback_list, messenger); -} - -static inline VkResult layer_create_messenger_callback(debug_report_data *debug_data, bool default_callback, - const VkDebugUtilsMessengerCreateInfoEXT *create_info, - const VkAllocationCallbacks *allocator, - VkDebugUtilsMessengerEXT *messenger) { - VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *)malloc(sizeof(VkLayerDbgFunctionNode)); - if (!pNewDbgFuncNode) return VK_ERROR_OUT_OF_HOST_MEMORY; - memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode)); - pNewDbgFuncNode->is_messenger = true; - - // Handle of 0 is logging_callback so use allocated Node address as unique handle - if (!(*messenger)) *messenger = (VkDebugUtilsMessengerEXT)pNewDbgFuncNode; - pNewDbgFuncNode->messenger.messenger = *messenger; - pNewDbgFuncNode->messenger.pfnUserCallback = create_info->pfnUserCallback; - pNewDbgFuncNode->messenger.messageSeverity = create_info->messageSeverity; - pNewDbgFuncNode->messenger.messageType = create_info->messageType; - pNewDbgFuncNode->pUserData = create_info->pUserData; - - debug_data->active_severities |= create_info->messageSeverity; - debug_data->active_types |= create_info->messageType; - if (default_callback) { - AddDebugCallbackNode(debug_data, &debug_data->default_debug_callback_list, pNewDbgFuncNode); - } else { - AddDebugCallbackNode(debug_data, &debug_data->debug_callback_list, pNewDbgFuncNode); - } - - VkDebugUtilsMessengerCallbackDataEXT callback_data = {}; - VkDebugUtilsObjectNameInfoEXT blank_object = {}; - callback_data.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; - callback_data.pNext = NULL; - callback_data.flags = 0; - callback_data.pMessageIdName = "Layer Internal Message"; - callback_data.messageIdNumber = 0; - callback_data.pMessage = "Added messenger"; - callback_data.queueLabelCount = 0; - callback_data.pQueueLabels = NULL; - callback_data.cmdBufLabelCount = 0; - callback_data.pCmdBufLabels = NULL; - callback_data.objectCount = 1; - callback_data.pObjects = &blank_object; - blank_object.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; - blank_object.pNext = NULL; - blank_object.objectType = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT; - blank_object.objectHandle = HandleToUint64(*messenger); - blank_object.pObjectName = NULL; - debug_messenger_log_msg(debug_data, VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, - VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, &callback_data); - return VK_SUCCESS; -} - -static inline void layer_destroy_report_callback(debug_report_data *debug_data, VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks *allocator) { - RemoveDebugUtilsMessageCallback(debug_data, &debug_data->debug_callback_list, callback); - RemoveDebugUtilsMessageCallback(debug_data, &debug_data->default_debug_callback_list, callback); -} - -static inline VkResult layer_create_report_callback(debug_report_data *debug_data, bool default_callback, - const VkDebugReportCallbackCreateInfoEXT *create_info, - const VkAllocationCallbacks *allocator, VkDebugReportCallbackEXT *callback) { - VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *)malloc(sizeof(VkLayerDbgFunctionNode)); - if (!pNewDbgFuncNode) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode)); - pNewDbgFuncNode->is_messenger = false; - - // Handle of 0 is logging_callback so use allocated Node address as unique handle - if (!(*callback)) *callback = (VkDebugReportCallbackEXT)pNewDbgFuncNode; - pNewDbgFuncNode->report.msgCallback = *callback; - pNewDbgFuncNode->report.pfnMsgCallback = create_info->pfnCallback; - pNewDbgFuncNode->report.msgFlags = create_info->flags; - pNewDbgFuncNode->pUserData = create_info->pUserData; - - VkFlags local_severity = 0; - VkFlags local_type = 0; - DebugReportFlagsToAnnotFlags(create_info->flags, true, &local_severity, &local_type); - debug_data->active_severities |= local_severity; - debug_data->active_types |= local_type; - if (default_callback) { - AddDebugCallbackNode(debug_data, &debug_data->default_debug_callback_list, pNewDbgFuncNode); - } else { - AddDebugCallbackNode(debug_data, &debug_data->debug_callback_list, pNewDbgFuncNode); - } - - debug_log_msg(debug_data, VK_DEBUG_REPORT_DEBUG_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, (uint64_t)*callback, 0, - 0, "DebugReport", "Added callback"); - return VK_SUCCESS; -} - -static inline PFN_vkVoidFunction debug_utils_get_instance_proc_addr(debug_report_data *debug_data, const char *func_name) { - if (!debug_data) { - return NULL; - } - if (debug_data->g_DEBUG_REPORT) { - if (!strcmp(func_name, "vkCreateDebugReportCallbackEXT")) { - return (PFN_vkVoidFunction)vkCreateDebugReportCallbackEXT; - } - if (!strcmp(func_name, "vkDestroyDebugReportCallbackEXT")) { - return (PFN_vkVoidFunction)vkDestroyDebugReportCallbackEXT; - } - if (!strcmp(func_name, "vkDebugReportMessageEXT")) { - return (PFN_vkVoidFunction)vkDebugReportMessageEXT; - } - } - if (debug_data->g_DEBUG_UTILS) { - if (!strcmp(func_name, "vkCreateDebugUtilsMessengerEXT")) { - return (PFN_vkVoidFunction)vkCreateDebugUtilsMessengerEXT; - } - if (!strcmp(func_name, "vkDestroyDebugUtilsMessengerEXT")) { - return (PFN_vkVoidFunction)vkDestroyDebugUtilsMessengerEXT; - } - if (!strcmp(func_name, "vkSubmitDebugUtilsMessageEXT")) { - return (PFN_vkVoidFunction)vkSubmitDebugUtilsMessageEXT; - } - } - return NULL; -} - -// This utility (called at vkCreateInstance() time), looks at a pNext chain. -// It counts any VkDebugReportCallbackCreateInfoEXT structs that it finds. It -// then allocates an array that can hold that many structs, as well as that -// many VkDebugReportCallbackEXT handles. It then copies each -// VkDebugReportCallbackCreateInfoEXT, and initializes each handle. -static inline VkResult layer_copy_tmp_report_callbacks(const void *pChain, uint32_t *num_callbacks, - VkDebugReportCallbackCreateInfoEXT **infos, - VkDebugReportCallbackEXT **callbacks) { - uint32_t n = *num_callbacks = 0; - - const void *pNext = pChain; - while (pNext) { - // 1st, count the number VkDebugReportCallbackCreateInfoEXT: - if (((VkDebugReportCallbackCreateInfoEXT *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) { - n++; - } - pNext = (void *)((VkDebugReportCallbackCreateInfoEXT *)pNext)->pNext; - } - if (n == 0) { - return VK_SUCCESS; - } - - // 2nd, allocate memory for each VkDebugReportCallbackCreateInfoEXT: - VkDebugReportCallbackCreateInfoEXT *pInfos = *infos = - ((VkDebugReportCallbackCreateInfoEXT *)malloc(n * sizeof(VkDebugReportCallbackCreateInfoEXT))); - if (!pInfos) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - // 3rd, allocate memory for a unique handle for each callback: - VkDebugReportCallbackEXT *pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)malloc(n * sizeof(VkDebugReportCallbackEXT))); - if (!pCallbacks) { - free(pInfos); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - // 4th, copy each VkDebugReportCallbackCreateInfoEXT for use by - // vkDestroyInstance, and assign a unique handle to each callback (just - // use the address of the copied VkDebugReportCallbackCreateInfoEXT): - pNext = pChain; - while (pNext) { - if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) { - memcpy(pInfos, pNext, sizeof(VkDebugReportCallbackCreateInfoEXT)); - *pCallbacks++ = (VkDebugReportCallbackEXT)pInfos++; - } - pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext; - } - - *num_callbacks = n; - return VK_SUCCESS; -} - -// This utility frees the arrays allocated by layer_copy_tmp_report_callbacks() -static inline void layer_free_tmp_report_callbacks(VkDebugReportCallbackCreateInfoEXT *infos, VkDebugReportCallbackEXT *callbacks) { - free(infos); - free(callbacks); -} - -// This utility enables all of the VkDebugReportCallbackCreateInfoEXT structs -// that were copied by layer_copy_tmp_report_callbacks() -static inline VkResult layer_enable_tmp_report_callbacks(debug_report_data *debug_data, uint32_t num_callbacks, - VkDebugReportCallbackCreateInfoEXT *infos, - VkDebugReportCallbackEXT *callbacks) { - VkResult rtn = VK_SUCCESS; - for (uint32_t i = 0; i < num_callbacks; i++) { - rtn = layer_create_report_callback(debug_data, false, &infos[i], NULL, &callbacks[i]); - if (rtn != VK_SUCCESS) { - for (uint32_t j = 0; j < i; j++) { - layer_destroy_report_callback(debug_data, callbacks[j], NULL); - } - return rtn; - } - } - return rtn; -} - -// This utility disables all of the VkDebugReportCallbackCreateInfoEXT structs -// that were copied by layer_copy_tmp_report_callbacks() -static inline void layer_disable_tmp_report_callbacks(debug_report_data *debug_data, uint32_t num_callbacks, - VkDebugReportCallbackEXT *callbacks) { - for (uint32_t i = 0; i < num_callbacks; i++) { - layer_destroy_report_callback(debug_data, callbacks[i], NULL); - } -} - -// This utility (called at vkCreateInstance() time), looks at a pNext chain. -// It counts any VkDebugUtilsMessengerCreateInfoEXT structs that it finds. It -// then allocates an array that can hold that many structs, as well as that -// many VkDebugUtilsMessengerEXT handles. It then copies each -// VkDebugUtilsMessengerCreateInfoEXT, and initializes each handle. -static inline VkResult layer_copy_tmp_debug_messengers(const void *pChain, uint32_t *num_messengers, - VkDebugUtilsMessengerCreateInfoEXT **infos, - VkDebugUtilsMessengerEXT **messengers) { - uint32_t n = *num_messengers = 0; - - const void *pNext = pChain; - while (pNext) { - // 1st, count the number VkDebugUtilsMessengerCreateInfoEXT: - if (((VkDebugUtilsMessengerCreateInfoEXT *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT) { - n++; - } - pNext = (void *)((VkDebugUtilsMessengerCreateInfoEXT *)pNext)->pNext; - } - if (n == 0) { - return VK_SUCCESS; - } - - // 2nd, allocate memory for each VkDebugUtilsMessengerCreateInfoEXT: - VkDebugUtilsMessengerCreateInfoEXT *pInfos = *infos = - ((VkDebugUtilsMessengerCreateInfoEXT *)malloc(n * sizeof(VkDebugUtilsMessengerCreateInfoEXT))); - if (!pInfos) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - // 3rd, allocate memory for a unique handle for each messenger: - VkDebugUtilsMessengerEXT *pMessengers = *messengers = - ((VkDebugUtilsMessengerEXT *)malloc(n * sizeof(VkDebugUtilsMessengerEXT))); - if (!pMessengers) { - free(pInfos); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - // 4th, copy each VkDebugUtilsMessengerCreateInfoEXT for use by - // vkDestroyInstance, and assign a unique handle to each callback (just - // use the address of the copied VkDebugUtilsMessengerCreateInfoEXT): - pNext = pChain; - while (pNext) { - if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT) { - memcpy(pInfos, pNext, sizeof(VkDebugUtilsMessengerCreateInfoEXT)); - *pMessengers++ = (VkDebugUtilsMessengerEXT)pInfos++; - } - pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext; - } - - *num_messengers = n; - return VK_SUCCESS; -} - -// This utility frees the arrays allocated by layer_copy_tmp_debug_messengers() -static inline void layer_free_tmp_debug_messengers(VkDebugUtilsMessengerCreateInfoEXT *infos, - VkDebugUtilsMessengerEXT *messengers) { - free(infos); - free(messengers); -} - -// This utility enables all of the VkDebugUtilsMessengerCreateInfoEXT structs -// that were copied by layer_copy_tmp_debug_messengers() -static inline VkResult layer_enable_tmp_debug_messengers(debug_report_data *debug_data, uint32_t num_messengers, - VkDebugUtilsMessengerCreateInfoEXT *infos, - VkDebugUtilsMessengerEXT *messengers) { - VkResult rtn = VK_SUCCESS; - for (uint32_t i = 0; i < num_messengers; i++) { - rtn = layer_create_messenger_callback(debug_data, false, &infos[i], NULL, &messengers[i]); - if (rtn != VK_SUCCESS) { - for (uint32_t j = 0; j < i; j++) { - layer_destroy_messenger_callback(debug_data, messengers[j], NULL); - } - return rtn; - } - } - return rtn; -} - -// This utility disables all of the VkDebugUtilsMessengerCreateInfoEXT structs -// that were copied by layer_copy_tmp_debug_messengers() -static inline void layer_disable_tmp_debug_messengers(debug_report_data *debug_data, uint32_t num_messengers, - VkDebugUtilsMessengerEXT *messengers) { - for (uint32_t i = 0; i < num_messengers; i++) { - layer_destroy_messenger_callback(debug_data, messengers[i], NULL); - } -} - -// Checks if the message will get logged. -// Allows layer to defer collecting & formating data if the -// message will be discarded. -static inline bool will_log_msg(debug_report_data *debug_data, VkFlags msg_flags) { - VkFlags local_severity = 0; - VkFlags local_type = 0; - DebugReportFlagsToAnnotFlags(msg_flags, true, &local_severity, &local_type); - if (!debug_data || !(debug_data->active_severities & local_severity) || !(debug_data->active_types & local_type)) { - // Message is not wanted - return false; - } - - return true; -} -#ifndef WIN32 -static inline int string_sprintf(std::string *output, const char *fmt, ...) __attribute__((format(printf, 2, 3))); -#endif -static inline int string_sprintf(std::string *output, const char *fmt, ...) { - std::string &formatted = *output; - va_list argptr; - va_start(argptr, fmt); - int reserve = vsnprintf(nullptr, 0, fmt, argptr); - va_end(argptr); - formatted.reserve(reserve + 1); - va_start(argptr, fmt); - int result = vsnprintf((char *)formatted.data(), formatted.capacity(), fmt, argptr); - va_end(argptr); - assert(result == reserve); - return result; -} - -#ifdef WIN32 -static inline int vasprintf(char **strp, char const *fmt, va_list ap) { - *strp = nullptr; - int size = _vscprintf(fmt, ap); - if (size >= 0) { - *strp = (char *)malloc(size + 1); - if (!*strp) { - return -1; - } - _vsnprintf(*strp, size + 1, fmt, ap); - } - return size; -} -#endif - -// Output log message via DEBUG_REPORT. Takes format and variable arg list so that output string is only computed if a message -// needs to be logged -#ifndef WIN32 -static inline bool log_msg(const debug_report_data *debug_data, VkFlags msg_flags, VkDebugReportObjectTypeEXT object_type, - uint64_t src_object, int32_t msg_code, const char *format, ...) __attribute__((format(printf, 6, 7))); -static inline bool log_msg(const debug_report_data *debug_data, VkFlags msg_flags, VkDebugReportObjectTypeEXT object_type, - uint64_t src_object, std::string vuid_text, const char *format, ...) - __attribute__((format(printf, 6, 7))); -#endif -static inline bool log_msg(const debug_report_data *debug_data, VkFlags msg_flags, VkDebugReportObjectTypeEXT object_type, - uint64_t src_object, int32_t msg_code, const char *format, ...) { - VkFlags local_severity = 0; - VkFlags local_type = 0; - DebugReportFlagsToAnnotFlags(msg_flags, true, &local_severity, &local_type); - if (!debug_data || !(debug_data->active_severities & local_severity) || !(debug_data->active_types & local_type)) { - // Message is not wanted - return false; - } - - va_list argptr; - va_start(argptr, format); - char *str; - if (-1 == vasprintf(&str, format, argptr)) { - // On failure, glibc vasprintf leaves str undefined - str = nullptr; - } - va_end(argptr); - - std::string str_plus_spec_text(str); - - // If the msg_code is in the error map, tack on spec text to error message. - if (validation_error_map.find(msg_code) != validation_error_map.end()) { - str_plus_spec_text += " "; - str_plus_spec_text += validation_error_map[msg_code]; - } - - bool result = debug_log_msg(debug_data, msg_flags, object_type, src_object, 0, msg_code, "Validation", - str_plus_spec_text.c_str() ? str_plus_spec_text.c_str() : "Allocation failure"); - free(str); - return result; -} - -// Overload of log_msg that takes a VUID string in place of a numerical VUID abstraction -static inline bool log_msg(const debug_report_data *debug_data, VkFlags msg_flags, VkDebugReportObjectTypeEXT object_type, - uint64_t src_object, std::string vuid_text, const char *format, ...) { - VkFlags local_severity = 0; - VkFlags local_type = 0; - DebugReportFlagsToAnnotFlags(msg_flags, true, &local_severity, &local_type); - if (!debug_data || !(debug_data->active_severities & local_severity) || !(debug_data->active_types & local_type)) { - // Message is not wanted - return false; - } - - va_list argptr; - va_start(argptr, format); - char *str; - if (-1 == vasprintf(&str, format, argptr)) { - // On failure, glibc vasprintf leaves str undefined - str = nullptr; - } - va_end(argptr); - - std::string str_plus_spec_text(str); - - // If the msg_code is in the error map, get ID, look up spec text, and tack it onto error message. - if (validation_error_text_map.find(vuid_text.c_str()) != validation_error_text_map.end()) { - str_plus_spec_text += " "; - str_plus_spec_text += validation_error_map[validation_error_text_map[vuid_text.c_str()]]; - } - - // Append layer prefix with VUID string, pass in UNDEFINED for numerical VUID - static const int UNDEFINED_VUID = -1; - bool result = debug_log_msg(debug_data, msg_flags, object_type, src_object, 0, UNDEFINED_VUID, "Validation", - str_plus_spec_text.c_str() ? str_plus_spec_text.c_str() : "Allocation failure", vuid_text.c_str()); - - free(str); - return result; -} - -static inline VKAPI_ATTR VkBool32 VKAPI_CALL report_log_callback(VkFlags msg_flags, VkDebugReportObjectTypeEXT obj_type, - uint64_t src_object, size_t location, int32_t msg_code, - const char *layer_prefix, const char *message, void *user_data) { - char msg_flag_string[30]; - - PrintMessageFlags(msg_flags, msg_flag_string); - - fprintf((FILE *)user_data, "%s(%s): msg_code: %d: %s\n", layer_prefix, msg_flag_string, msg_code, message); - fflush((FILE *)user_data); - - return false; -} - -static inline VKAPI_ATTR VkBool32 VKAPI_CALL report_win32_debug_output_msg(VkFlags msg_flags, VkDebugReportObjectTypeEXT obj_type, - uint64_t src_object, size_t location, int32_t msg_code, - const char *layer_prefix, const char *message, - void *user_data) { -#ifdef WIN32 - char msg_flag_string[30]; - char buf[2048]; - - PrintMessageFlags(msg_flags, msg_flag_string); - _snprintf(buf, sizeof(buf) - 1, "%s (%s): msg_code: %d: %s\n", layer_prefix, msg_flag_string, msg_code, message); - - OutputDebugString(buf); -#endif - - return false; -} - -static inline VKAPI_ATTR VkBool32 VKAPI_CALL DebugBreakCallback(VkFlags msgFlags, VkDebugReportObjectTypeEXT obj_type, - uint64_t src_object, size_t location, int32_t msg_code, - const char *layer_prefix, const char *message, void *user_data) { -#ifdef WIN32 - DebugBreak(); -#else - raise(SIGTRAP); -#endif - - return false; -} - -static inline VKAPI_ATTR VkBool32 VKAPI_CALL messenger_log_callback(VkDebugUtilsMessageSeverityFlagBitsEXT message_severity, - VkDebugUtilsMessageTypeFlagsEXT message_type, - const VkDebugUtilsMessengerCallbackDataEXT *callback_data, - void *user_data) { - char msg_severity[30]; - char msg_type[30]; - - PrintMessageSeverity(message_severity, msg_severity); - PrintMessageType(message_type, msg_type); - - fprintf((FILE *)user_data, "%s(%s / %s): msgNum: %d - %s\n", callback_data->pMessageIdName, msg_severity, msg_type, - callback_data->messageIdNumber, callback_data->pMessage); - fprintf((FILE *)user_data, " Objects: %d\n", callback_data->objectCount); - for (uint32_t obj = 0; obj < callback_data->objectCount; ++obj) { - fprintf((FILE *)user_data, " [%d] 0x%" PRIx64 ", type: %d, name: %s\n", obj, - callback_data->pObjects[obj].objectHandle, callback_data->pObjects[obj].objectType, - callback_data->pObjects[obj].pObjectName); - } - fflush((FILE *)user_data); - - return false; -} - -static inline VKAPI_ATTR VkBool32 VKAPI_CALL messenger_win32_debug_output_msg( - VkDebugUtilsMessageSeverityFlagBitsEXT message_severity, VkDebugUtilsMessageTypeFlagsEXT message_type, - const VkDebugUtilsMessengerCallbackDataEXT *callback_data, void *user_data) { -#ifdef WIN32 - char buf[2048]; - char msg_severity[30]; - char msg_type[30]; - - PrintMessageSeverity(message_severity, msg_severity); - PrintMessageType(message_type, msg_type); - - size_t buffer_space = sizeof(buf) - 1; - size_t remaining_space = buffer_space; - _snprintf(buf, sizeof(buf) - 1, "%s(%s / %s): msgNum: %d - %s\n", callback_data->pMessageIdName, msg_severity, msg_type, - callback_data->messageIdNumber, callback_data->pMessage); - remaining_space = buffer_space - strlen(buf); - _snprintf(buf, remaining_space, " Objects: %d\n", callback_data->objectCount); - for (uint32_t obj = 0; obj < callback_data->objectCount; ++obj) { - remaining_space = buffer_space - strlen(buf); - if (remaining_space > 0) { - _snprintf(buf, remaining_space, " [%d] 0x%" PRIx64 ", type: %d, name: %s\n", obj, - callback_data->pObjects[obj].objectHandle, callback_data->pObjects[obj].objectType, - callback_data->pObjects[obj].pObjectName); - } - } - OutputDebugString(buf); -#endif - - return false; -} - -// This utility converts from the VkDebugUtilsLabelEXT structure into the logging version of the structure. -// In the logging version, we only record what we absolutely need to convey back to the callbacks. -static inline void InsertLabelIntoLog(const VkDebugUtilsLabelEXT *utils_label, std::vector &log_vector) { - LoggingLabelData log_label_data = {}; - log_label_data.name = utils_label->pLabelName; - log_label_data.color[0] = utils_label->color[0]; - log_label_data.color[1] = utils_label->color[1]; - log_label_data.color[2] = utils_label->color[2]; - log_label_data.color[3] = utils_label->color[3]; - log_vector.push_back(log_label_data); -} - -static inline void BeginQueueDebugUtilsLabel(debug_report_data *report_data, VkQueue queue, - const VkDebugUtilsLabelEXT *label_info) { - if (nullptr != label_info && nullptr != label_info->pLabelName) { - auto label_iter = report_data->debugUtilsQueueLabels->find(queue); - if (label_iter == report_data->debugUtilsQueueLabels->end()) { - std::vector new_queue_labels; - InsertLabelIntoLog(label_info, new_queue_labels); - report_data->debugUtilsQueueLabels->insert({queue, new_queue_labels}); - } else { - // If the last thing was a label insert, we need to pop it off of the label vector before any - // changes. This is because a label added with "vkQueueInsertDebugUtilsLabelEXT" is only a - // temporary location that exists until the next operation occurs. In this case, a new - // "vkQueueBeginDebugUtilsLabelEXT" has occurred erasing the previous inserted label. - if (report_data->queueLabelHasInsert) { - report_data->queueLabelHasInsert = false; - label_iter->second.pop_back(); - } - InsertLabelIntoLog(label_info, label_iter->second); - } - } -} - -static inline void EndQueueDebugUtilsLabel(debug_report_data *report_data, VkQueue queue) { - auto label_iter = report_data->debugUtilsQueueLabels->find(queue); - if (label_iter != report_data->debugUtilsQueueLabels->end()) { - // If the last thing was a label insert, we need to pop it off of the label vector before any - // changes. This is because a label added with "vkQueueInsertDebugUtilsLabelEXT" is only a - // temporary location that exists until the next operation occurs. In this case, a - // "vkQueueEndDebugUtilsLabelEXT" has occurred erasing the inserted label. - if (report_data->queueLabelHasInsert) { - report_data->queueLabelHasInsert = false; - label_iter->second.pop_back(); - } - // Now pop the normal item - label_iter->second.pop_back(); - } -} - -static inline void InsertQueueDebugUtilsLabel(debug_report_data *report_data, VkQueue queue, - const VkDebugUtilsLabelEXT *label_info) { - if (nullptr != label_info && nullptr != label_info->pLabelName) { - auto label_iter = report_data->debugUtilsQueueLabels->find(queue); - if (label_iter == report_data->debugUtilsQueueLabels->end()) { - std::vector new_queue_labels; - InsertLabelIntoLog(label_info, new_queue_labels); - report_data->debugUtilsQueueLabels->insert({queue, new_queue_labels}); - } else { - // If the last thing was a label insert, we need to pop it off of the label vector before any - // changes. This is because a label added with "vkQueueInsertDebugUtilsLabelEXT" is only a - // temporary location that exists until the next operation occurs. In this case, a new - // "vkQueueInsertDebugUtilsLabelEXT" has occurred erasing the previous inserted label. - if (report_data->queueLabelHasInsert) { - label_iter->second.pop_back(); - } - // Insert this new label and mark it as one that has been "inserted" so we can remove it on - // the next queue label operation. - InsertLabelIntoLog(label_info, label_iter->second); - report_data->queueLabelHasInsert = true; - } - } -} - -static inline void BeginCmdDebugUtilsLabel(debug_report_data *report_data, VkCommandBuffer command_buffer, - const VkDebugUtilsLabelEXT *label_info) { - if (nullptr != label_info && nullptr != label_info->pLabelName) { - auto label_iter = report_data->debugUtilsCmdBufLabels->find(command_buffer); - if (label_iter == report_data->debugUtilsCmdBufLabels->end()) { - std::vector new_cmdbuf_labels; - InsertLabelIntoLog(label_info, new_cmdbuf_labels); - report_data->debugUtilsCmdBufLabels->insert({command_buffer, new_cmdbuf_labels}); - } else { - // If the last thing was a label insert, we need to pop it off of the label vector before any - // changes. This is because a label added with "vkCmdInsertDebugUtilsLabelEXT" is only a - // temporary location that exists until the next operation occurs. In this case, a - // "vkCmdBeginDebugUtilsLabelEXT" has occurred erasing the inserted label. - if (report_data->cmdBufLabelHasInsert) { - report_data->cmdBufLabelHasInsert = false; - label_iter->second.pop_back(); - } - InsertLabelIntoLog(label_info, label_iter->second); - } - } -} - -static inline void EndCmdDebugUtilsLabel(debug_report_data *report_data, VkCommandBuffer command_buffer) { - auto label_iter = report_data->debugUtilsCmdBufLabels->find(command_buffer); - if (label_iter != report_data->debugUtilsCmdBufLabels->end()) { - // If the last thing was a label insert, we need to pop it off of the label vector before any - // changes. This is because a label added with "vkCmdInsertDebugUtilsLabelEXT" is only a - // temporary location that exists until the next operation occurs. In this case, a - // "vkCmdEndDebugUtilsLabelEXT" has occurred erasing the inserted label. - if (report_data->cmdBufLabelHasInsert) { - report_data->cmdBufLabelHasInsert = false; - label_iter->second.pop_back(); - } - // Now pop the normal item - label_iter->second.pop_back(); - } -} - -static inline void InsertCmdDebugUtilsLabel(debug_report_data *report_data, VkCommandBuffer command_buffer, - const VkDebugUtilsLabelEXT *label_info) { - if (nullptr != label_info && nullptr != label_info->pLabelName) { - auto label_iter = report_data->debugUtilsCmdBufLabels->find(command_buffer); - if (label_iter == report_data->debugUtilsCmdBufLabels->end()) { - std::vector new_cmdbuf_labels; - InsertLabelIntoLog(label_info, new_cmdbuf_labels); - report_data->debugUtilsCmdBufLabels->insert({command_buffer, new_cmdbuf_labels}); - } else { - // If the last thing was a label insert, we need to pop it off of the label vector before any - // changes. This is because a label added with "vkCmdInsertDebugUtilsLabelEXT" is only a - // temporary location that exists until the next operation occurs. In this case, a new - // "vkCmdInsertDebugUtilsLabelEXT" has occurred erasing the previous inserted label. - if (report_data->cmdBufLabelHasInsert) { - label_iter->second.pop_back(); - } - // Insert this new label and mark it as one that has been "inserted" so we can remove it on - // the next command buffer label operation. - InsertLabelIntoLog(label_info, label_iter->second); - report_data->cmdBufLabelHasInsert = true; - } - } -} - -#endif // LAYER_LOGGING_H diff --git a/layers/vk_layer_settings.txt b/layers/vk_layer_settings.txt deleted file mode 100644 index 4998d1c2..00000000 --- a/layers/vk_layer_settings.txt +++ /dev/null @@ -1,81 +0,0 @@ -################################################################################ -# -# This file contains per-layer settings that configure layer behavior at -# execution time. Comments in this file are denoted with the "#" char. -# Settings lines are of the form: -# ". = " -# -# is typically the official layer name, minus the VK_LAYER -# prefix and all lower-camel-case -- i.e., for VK_LAYER_LUNARG_core_validation, -# the layer identifier is 'lunarg_core_validation', and for -# VK_LAYER_GOOGLE_threading the layeridentifier is 'google_threading'. -# -################################################################################ -################################################################################ -# Validation Layer Common Settings: -# ================================= -# -# DEBUG_ACTION: -# ============= -# .debug_action : This is an enum value indicating what -# action is to be taken when a layer wants to report information. -# Possible settings values are defined in the vk_layer.h header file. -# These settings are: -# VK_DBG_LAYER_ACTION_IGNORE - Take no action. -# VK_DBG_LAYER_ACTION_LOG_MSG - Log a txt message to stdout or to a log filename -# specified via the .log_filename setting (see below). -# VK_DBG_LAYER_ACTION_CALLBACK - Call user defined callback function(s) that -# have been registered via the VK_EXT_debug_report extension. Since -# app must register callback, this is a NOOP for the settings file. -# VK_DBG_LAYER_ACTION_DEBUG_OUTPUT [Windows only] - Log a txt message using the -# Windows OutputDebugString function -- messages will show up in the -# Visual Studio output window, for instance. -# VK_DBG_LAYER_ACTION_BREAK - Trigger a breakpoint. -# -# REPORT_FLAGS: -# ============= -# .report_flags : This is a comma-delineated list of options -# telling the layer what types of messages it should report back. -# Options are: -# info - Report informational messages. -# warn - Report warnings from using the API in a manner which may lead to -# undefined behavior or to warn the user of common trouble spots. -# A warning does NOT necessarily signify illegal application behavior. -# perf - Report using the API in a way that may cause suboptimal performance. -# error - Report errors in API usage. -# debug - For layer development. Report messages for debugging layer -# behavior. -# -# LOG_FILENAME: -# ============= -# .log_filename : output filename. Can be relative to -# location of vk_layer_settings.txt file, or an absolute path. If no -# filename is specified or if filename has invalid path, then stdout -# is used by default. -# - -# VK_LAYER_LUNARG_core_validation Settings -lunarg_core_validation.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG -lunarg_core_validation.report_flags = error,warn,perf -lunarg_core_validation.log_filename = stdout - -# VK_LAYER_LUNARG_object_tracker Settings -lunarg_object_tracker.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG -lunarg_object_tracker.report_flags = error,warn,perf -lunarg_object_tracker.log_filename = stdout - -# VK_LAYER_LUNARG_parameter_validation Settings -lunarg_parameter_validation.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG -lunarg_parameter_validation.report_flags = error,warn,perf -lunarg_parameter_validation.log_filename = stdout - -# VK_LAYER_GOOGLE_threading Settings -google_threading.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG -google_threading.report_flags = error,warn,perf -google_threading.log_filename = stdout - -# VK_LAYER_GOOGLE_unique_objects Settings -google_unique_objects.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG -google_unique_objects.report_flags = error,warn,perf -google_unique_objects.log_filename = stdout -################################################################################ diff --git a/layers/vk_layer_table.cpp b/layers/vk_layer_table.cpp deleted file mode 100644 index 4a033b9a..00000000 --- a/layers/vk_layer_table.cpp +++ /dev/null @@ -1,146 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (c) 2015-2016 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 - */ -#include -#include -#include "vk_dispatch_table_helper.h" -#include "vulkan/vk_layer.h" -#include "vk_layer_table.h" -static device_table_map tableMap; -static instance_table_map tableInstanceMap; - -// Map lookup must be thread safe -VkLayerDispatchTable *device_dispatch_table(void *object) { - dispatch_key key = get_dispatch_key(object); - device_table_map::const_iterator it = tableMap.find((void *)key); - assert(it != tableMap.end() && "Not able to find device dispatch entry"); - return it->second; -} - -VkLayerInstanceDispatchTable *instance_dispatch_table(void *object) { - dispatch_key key = get_dispatch_key(object); - instance_table_map::const_iterator it = tableInstanceMap.find((void *)key); - assert(it != tableInstanceMap.end() && "Not able to find instance dispatch entry"); - return it->second; -} - -void destroy_dispatch_table(device_table_map &map, dispatch_key key) { - device_table_map::const_iterator it = map.find((void *)key); - if (it != map.end()) { - delete it->second; - map.erase(it); - } -} - -void destroy_dispatch_table(instance_table_map &map, dispatch_key key) { - instance_table_map::const_iterator it = map.find((void *)key); - if (it != map.end()) { - delete it->second; - map.erase(it); - } -} - -void destroy_device_dispatch_table(dispatch_key key) { destroy_dispatch_table(tableMap, key); } - -void destroy_instance_dispatch_table(dispatch_key key) { destroy_dispatch_table(tableInstanceMap, key); } - -VkLayerDispatchTable *get_dispatch_table(device_table_map &map, void *object) { - dispatch_key key = get_dispatch_key(object); - device_table_map::const_iterator it = map.find((void *)key); - assert(it != map.end() && "Not able to find device dispatch entry"); - return it->second; -} - -VkLayerInstanceDispatchTable *get_dispatch_table(instance_table_map &map, void *object) { - dispatch_key key = get_dispatch_key(object); - instance_table_map::const_iterator it = map.find((void *)key); - assert(it != map.end() && "Not able to find instance dispatch entry"); - return it->second; -} - -VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func) { - VkLayerInstanceCreateInfo *chain_info = (VkLayerInstanceCreateInfo *)pCreateInfo->pNext; - while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO && chain_info->function == func)) { - chain_info = (VkLayerInstanceCreateInfo *)chain_info->pNext; - } - assert(chain_info != NULL); - return chain_info; -} - -VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func) { - VkLayerDeviceCreateInfo *chain_info = (VkLayerDeviceCreateInfo *)pCreateInfo->pNext; - while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO && chain_info->function == func)) { - chain_info = (VkLayerDeviceCreateInfo *)chain_info->pNext; - } - assert(chain_info != NULL); - return chain_info; -} - -/* Various dispatchable objects will use the same underlying dispatch table if they - * are created from that "parent" object. Thus use pointer to dispatch table - * as the key to these table maps. - * Instance -> PhysicalDevice - * Device -> CommandBuffer or Queue - * If use the object themselves as key to map then implies Create entrypoints have to be intercepted - * and a new key inserted into map */ -VkLayerInstanceDispatchTable *initInstanceTable(VkInstance instance, const PFN_vkGetInstanceProcAddr gpa, instance_table_map &map) { - VkLayerInstanceDispatchTable *pTable; - dispatch_key key = get_dispatch_key(instance); - instance_table_map::const_iterator it = map.find((void *)key); - - if (it == map.end()) { - pTable = new VkLayerInstanceDispatchTable; - map[(void *)key] = pTable; - } else { - return it->second; - } - - layer_init_instance_dispatch_table(instance, pTable, gpa); - - // Setup func pointers that are required but not externally exposed. These won't be added to the instance dispatch table by - // default. - pTable->GetPhysicalDeviceProcAddr = (PFN_GetPhysicalDeviceProcAddr)gpa(instance, "vk_layerGetPhysicalDeviceProcAddr"); - - return pTable; -} - -VkLayerInstanceDispatchTable *initInstanceTable(VkInstance instance, const PFN_vkGetInstanceProcAddr gpa) { - return initInstanceTable(instance, gpa, tableInstanceMap); -} - -VkLayerDispatchTable *initDeviceTable(VkDevice device, const PFN_vkGetDeviceProcAddr gpa, device_table_map &map) { - VkLayerDispatchTable *pTable; - dispatch_key key = get_dispatch_key(device); - device_table_map::const_iterator it = map.find((void *)key); - - if (it == map.end()) { - pTable = new VkLayerDispatchTable; - map[(void *)key] = pTable; - } else { - return it->second; - } - - layer_init_device_dispatch_table(device, pTable, gpa); - - return pTable; -} - -VkLayerDispatchTable *initDeviceTable(VkDevice device, const PFN_vkGetDeviceProcAddr gpa) { - return initDeviceTable(device, gpa, tableMap); -} diff --git a/layers/vk_layer_table.h b/layers/vk_layer_table.h deleted file mode 100644 index 45b8f6e1..00000000 --- a/layers/vk_layer_table.h +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Tobin Ehlis - */ - -#pragma once - -#include "vulkan/vk_layer.h" -#include "vulkan/vulkan.h" -#include - -typedef std::unordered_map device_table_map; -typedef std::unordered_map instance_table_map; -VkLayerDispatchTable *initDeviceTable(VkDevice device, const PFN_vkGetDeviceProcAddr gpa, device_table_map &map); -VkLayerDispatchTable *initDeviceTable(VkDevice device, const PFN_vkGetDeviceProcAddr gpa); -VkLayerInstanceDispatchTable *initInstanceTable(VkInstance instance, const PFN_vkGetInstanceProcAddr gpa, instance_table_map &map); -VkLayerInstanceDispatchTable *initInstanceTable(VkInstance instance, const PFN_vkGetInstanceProcAddr gpa); - -typedef void *dispatch_key; - -static inline dispatch_key get_dispatch_key(const void *object) { return (dispatch_key) * (VkLayerDispatchTable **)object; } - -VkLayerDispatchTable *device_dispatch_table(void *object); - -VkLayerInstanceDispatchTable *instance_dispatch_table(void *object); - -VkLayerDispatchTable *get_dispatch_table(device_table_map &map, void *object); - -VkLayerInstanceDispatchTable *get_dispatch_table(instance_table_map &map, void *object); - -VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func); -VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func); - -void destroy_device_dispatch_table(dispatch_key key); -void destroy_instance_dispatch_table(dispatch_key key); -void destroy_dispatch_table(device_table_map &map, dispatch_key key); -void destroy_dispatch_table(instance_table_map &map, dispatch_key key); diff --git a/layers/vk_layer_utils.cpp b/layers/vk_layer_utils.cpp deleted file mode 100644 index 629b19f4..00000000 --- a/layers/vk_layer_utils.cpp +++ /dev/null @@ -1,207 +0,0 @@ -/* Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Mark Lobodzinski - * Author: Dave Houlton - * - */ - -#include -#include -#include -#include -#include "vulkan/vulkan.h" -#include "vk_layer_config.h" -#include "vk_layer_utils.h" - -static const uint8_t UTF8_ONE_BYTE_CODE = 0xC0; -static const uint8_t UTF8_ONE_BYTE_MASK = 0xE0; -static const uint8_t UTF8_TWO_BYTE_CODE = 0xE0; -static const uint8_t UTF8_TWO_BYTE_MASK = 0xF0; -static const uint8_t UTF8_THREE_BYTE_CODE = 0xF0; -static const uint8_t UTF8_THREE_BYTE_MASK = 0xF8; -static const uint8_t UTF8_DATA_BYTE_CODE = 0x80; -static const uint8_t UTF8_DATA_BYTE_MASK = 0xC0; - -VK_LAYER_EXPORT VkStringErrorFlags vk_string_validate(const int max_length, const char *utf8) { - VkStringErrorFlags result = VK_STRING_ERROR_NONE; - int num_char_bytes = 0; - int i, j; - - for (i = 0; i <= max_length; i++) { - if (utf8[i] == 0) { - break; - } else if (i == max_length) { - result = VK_STRING_ERROR_LENGTH; - break; - } else if ((utf8[i] >= 0xa) && (utf8[i] < 0x7f)) { - num_char_bytes = 0; - } else if ((utf8[i] & UTF8_ONE_BYTE_MASK) == UTF8_ONE_BYTE_CODE) { - num_char_bytes = 1; - } else if ((utf8[i] & UTF8_TWO_BYTE_MASK) == UTF8_TWO_BYTE_CODE) { - num_char_bytes = 2; - } else if ((utf8[i] & UTF8_THREE_BYTE_MASK) == UTF8_THREE_BYTE_CODE) { - num_char_bytes = 3; - } else { - result = VK_STRING_ERROR_BAD_DATA; - } - - // Validate the following num_char_bytes of data - for (j = 0; (j < num_char_bytes) && (i < max_length); j++) { - if (++i == max_length) { - result |= VK_STRING_ERROR_LENGTH; - break; - } - if ((utf8[i] & UTF8_DATA_BYTE_MASK) != UTF8_DATA_BYTE_CODE) { - result |= VK_STRING_ERROR_BAD_DATA; - } - } - } - return result; -} - -// Utility function for finding a text string in another string -VK_LAYER_EXPORT bool white_list(const char *item, const char *list) { - std::string candidate(item); - std::string white_list(list); - return (white_list.find(candidate) != std::string::npos); -} - -// Debug callbacks get created in three ways: -// o Application-defined debug callbacks -// o Through settings in a vk_layer_settings.txt file -// o By default, if neither an app-defined debug callback nor a vk_layer_settings.txt file is present -// -// At layer initialization time, default logging callbacks are created to output layer error messages. -// If a vk_layer_settings.txt file is present its settings will override any default settings. -// -// If a vk_layer_settings.txt file is present and an application defines a debug callback, both callbacks -// will be active. If no vk_layer_settings.txt file is present, creating an application-defined debug -// callback will cause the default callbacks to be unregisterd and removed. -VK_LAYER_EXPORT void layer_debug_report_actions(debug_report_data *report_data, - std::vector &logging_callback, - const VkAllocationCallbacks *pAllocator, const char *layer_identifier) { - VkDebugReportCallbackEXT callback = VK_NULL_HANDLE; - - std::string report_flags_key = layer_identifier; - std::string debug_action_key = layer_identifier; - std::string log_filename_key = layer_identifier; - report_flags_key.append(".report_flags"); - debug_action_key.append(".debug_action"); - log_filename_key.append(".log_filename"); - - // Initialize layer options - VkDebugReportFlagsEXT report_flags = GetLayerOptionFlags(report_flags_key, report_flags_option_definitions, 0); - VkLayerDbgActionFlags debug_action = GetLayerOptionFlags(debug_action_key, debug_actions_option_definitions, 0); - // Flag as default if these settings are not from a vk_layer_settings.txt file - bool default_layer_callback = (debug_action & VK_DBG_LAYER_ACTION_DEFAULT) ? true : false; - - if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) { - const char *log_filename = getLayerOption(log_filename_key.c_str()); - FILE *log_output = getLayerLogOutput(log_filename, layer_identifier); - VkDebugReportCallbackCreateInfoEXT dbgCreateInfo; - memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo)); - dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; - dbgCreateInfo.flags = report_flags; - dbgCreateInfo.pfnCallback = report_log_callback; - dbgCreateInfo.pUserData = (void *)log_output; - layer_create_report_callback(report_data, default_layer_callback, &dbgCreateInfo, pAllocator, &callback); - logging_callback.push_back(callback); - } - - callback = VK_NULL_HANDLE; - - if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) { - VkDebugReportCallbackCreateInfoEXT dbgCreateInfo; - memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo)); - dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; - dbgCreateInfo.flags = report_flags; - dbgCreateInfo.pfnCallback = report_win32_debug_output_msg; - dbgCreateInfo.pUserData = NULL; - layer_create_report_callback(report_data, default_layer_callback, &dbgCreateInfo, pAllocator, &callback); - logging_callback.push_back(callback); - } - - callback = VK_NULL_HANDLE; - - if (debug_action & VK_DBG_LAYER_ACTION_BREAK) { - VkDebugReportCallbackCreateInfoEXT dbgCreateInfo; - memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo)); - dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; - dbgCreateInfo.flags = report_flags; - dbgCreateInfo.pfnCallback = DebugBreakCallback; - dbgCreateInfo.pUserData = NULL; - layer_create_report_callback(report_data, default_layer_callback, &dbgCreateInfo, pAllocator, &callback); - logging_callback.push_back(callback); - } -} - -VK_LAYER_EXPORT void layer_debug_messenger_actions(debug_report_data *report_data, - std::vector &logging_messenger, - const VkAllocationCallbacks *pAllocator, const char *layer_identifier) { - VkDebugUtilsMessengerEXT messenger = VK_NULL_HANDLE; - - std::string report_flags_key = layer_identifier; - std::string debug_action_key = layer_identifier; - std::string log_filename_key = layer_identifier; - report_flags_key.append(".report_flags"); - debug_action_key.append(".debug_action"); - log_filename_key.append(".log_filename"); - - // Initialize layer options - VkDebugReportFlagsEXT report_flags = GetLayerOptionFlags(report_flags_key, report_flags_option_definitions, 0); - VkLayerDbgActionFlags debug_action = GetLayerOptionFlags(debug_action_key, debug_actions_option_definitions, 0); - // Flag as default if these settings are not from a vk_layer_settings.txt file - bool default_layer_callback = (debug_action & VK_DBG_LAYER_ACTION_DEFAULT) ? true : false; - VkDebugUtilsMessengerCreateInfoEXT dbgCreateInfo; - memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo)); - dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; - dbgCreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT; - if (report_flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) { - dbgCreateInfo.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; - } - if (report_flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) { - dbgCreateInfo.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - } - if (report_flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) { - dbgCreateInfo.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - dbgCreateInfo.messageType |= VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; - } - if (report_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) { - dbgCreateInfo.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; - } - if (report_flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) { - dbgCreateInfo.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; - } - - if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) { - const char *log_filename = getLayerOption(log_filename_key.c_str()); - FILE *log_output = getLayerLogOutput(log_filename, layer_identifier); - dbgCreateInfo.pfnUserCallback = messenger_log_callback; - dbgCreateInfo.pUserData = (void *)log_output; - layer_create_messenger_callback(report_data, default_layer_callback, &dbgCreateInfo, pAllocator, &messenger); - logging_messenger.push_back(messenger); - } - - messenger = VK_NULL_HANDLE; - - if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) { - dbgCreateInfo.pfnUserCallback = messenger_win32_debug_output_msg; - dbgCreateInfo.pUserData = NULL; - layer_create_messenger_callback(report_data, default_layer_callback, &dbgCreateInfo, pAllocator, &messenger); - logging_messenger.push_back(messenger); - } -} diff --git a/layers/vk_layer_utils.h b/layers/vk_layer_utils.h deleted file mode 100644 index cfad81ce..00000000 --- a/layers/vk_layer_utils.h +++ /dev/null @@ -1,125 +0,0 @@ -/* Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Mark Lobodzinski - * Author: Courtney Goeltzenleuchter - * Author: Dave Houlton - */ - -#pragma once -#include -#include -#include -#include "vk_format_utils.h" -#include "vk_layer_logging.h" - -#ifndef WIN32 -#include // For ffs() -#else -#include // For __lzcnt() -#endif - -#ifdef __cplusplus -// Traits objects to allow string_join to operate on collections of const char * -template -struct StringJoinSizeTrait { - static size_t size(const String &str) { return str.size(); } -}; - -template <> -struct StringJoinSizeTrait { - static size_t size(const char *str) { - if (!str) return 0; - return strlen(str); - } -}; -// Similar to perl/python join -// * String must support size, reserve, append, and be default constructable -// * StringCollection must support size, const forward iteration, and store -// strings compatible with String::append -// * Accessor trait can be set if default accessors (compatible with string -// and const char *) don't support size(StringCollection::value_type &) -// -// Return type based on sep type -template , - typename Accessor = StringJoinSizeTrait> -static inline String string_join(const String &sep, const StringCollection &strings) { - String joined; - const size_t count = strings.size(); - if (!count) return joined; - - // Prereserved storage, s.t. we will execute in linear time (avoids reallocation copies) - size_t reserve = (count - 1) * sep.size(); - for (const auto &str : strings) { - reserve += Accessor::size(str); // abstracted to allow const char * type in StringCollection - } - joined.reserve(reserve + 1); - - // Seps only occur *between* strings entries, so first is special - auto current = strings.cbegin(); - joined.append(*current); - ++current; - for (; current != strings.cend(); ++current) { - joined.append(sep); - joined.append(*current); - } - return joined; -} - -// Requires StringCollection::value_type has a const char * constructor and is compatible the string_join::String above -template , typename SepString = std::string> -static inline SepString string_join(const char *sep, const StringCollection &strings) { - return string_join(SepString(sep), strings); -} - -extern "C" { -#endif - -#define VK_LAYER_API_VERSION VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION) - -typedef enum VkStringErrorFlagBits { - VK_STRING_ERROR_NONE = 0x00000000, - VK_STRING_ERROR_LENGTH = 0x00000001, - VK_STRING_ERROR_BAD_DATA = 0x00000002, -} VkStringErrorFlagBits; -typedef VkFlags VkStringErrorFlags; - -VK_LAYER_EXPORT void layer_debug_report_actions(debug_report_data *report_data, - std::vector &logging_callback, - const VkAllocationCallbacks *pAllocator, const char *layer_identifier); - -VK_LAYER_EXPORT void layer_debug_messenger_actions(debug_report_data *report_data, - std::vector &logging_messenger, - const VkAllocationCallbacks *pAllocator, const char *layer_identifier); - -VK_LAYER_EXPORT VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array); -VK_LAYER_EXPORT bool white_list(const char *item, const char *whitelist); - -static inline int u_ffs(int val) { -#ifdef WIN32 - unsigned long bit_pos = 0; - if (_BitScanForward(&bit_pos, val) != 0) { - bit_pos += 1; - } - return bit_pos; -#else - return ffs(val); -#endif -} - -#ifdef __cplusplus -} -#endif diff --git a/layers/vk_validation_error_database.txt b/layers/vk_validation_error_database.txt deleted file mode 100644 index 1fb924cd..00000000 --- a/layers/vk_validation_error_database.txt +++ /dev/null @@ -1,3939 +0,0 @@ -# This is a database file with validation error check information -# Comments are denoted with '#' char -# The format of the lines is: -# ~^~~^~~^~~^~~^~~^~~^~ -# error_enum: Unique error enum for this check of format VALIDATION_ERROR_ -# check_implemented: 'Y' if check has been implemented in layers, or 'N' for not implemented -# testname: Name of validation test for this check, 'Unknown' for unknown, 'None' if not implemented, or 'NotTestable' if cannot be implemented -# api: Vulkan API function that this check is related to -# vuid_string: Unique string to identify this check -# core|ext: Either 'core' for core spec or some extension string that indicates the extension required for this VU to be relevant -# errormsg: The unique error message for this check that includes spec language and link -# note: Free txt field with any custom notes related to the check in question -VALIDATION_ERROR_00000009~^~Y~^~None~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'Each of fence, semaphore, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-commonparent)~^~implicit -VALIDATION_ERROR_00000a10~^~N~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-semaphore-01288~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01288)~^~ -VALIDATION_ERROR_00000a12~^~N~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-fence-01289~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-fence-01289)~^~ -VALIDATION_ERROR_00000a14~^~N~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-deviceMask-01290~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must be a valid device mask' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-deviceMask-01290)~^~ -VALIDATION_ERROR_00000a16~^~N~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-deviceMask-01291~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-deviceMask-01291)~^~ -VALIDATION_ERROR_00000d16~^~N~^~None~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-swapchain-01675~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'swapchain must not be in the retired state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-swapchain-01675)~^~ -VALIDATION_ERROR_00000dea~^~N~^~None~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-semaphore-01781~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01781)~^~ -VALIDATION_ERROR_00000dec~^~N~^~None~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-semaphore-01782~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'semaphore and fence must not both be equal to VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01782)~^~ -VALIDATION_ERROR_00000e18~^~N~^~None~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-semaphore-01804~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'semaphore and fence must not both be equal to VK_NULL_HANDLE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01804)~^~ -VALIDATION_ERROR_00008801~^~Y~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-fence-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-fence-parameter)~^~implicit -VALIDATION_ERROR_0001c40d~^~Y~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_0002b00b~^~Y~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0002b801~^~Y~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-semaphore-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-parameter)~^~implicit -VALIDATION_ERROR_0002f001~^~Y~^~Unknown~^~VkAcquireNextImageInfoKHR~^~VUID-VkAcquireNextImageInfoKHR-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-swapchain-parameter)~^~implicit -VALIDATION_ERROR_002004f0~^~Y~^~Unknown~^~VkAllocationCallbacks~^~VUID-VkAllocationCallbacks-pfnAllocation-00632~^~core~^~The spec valid usage text states 'pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnAllocation-00632)~^~ -VALIDATION_ERROR_002004f2~^~Y~^~Unknown~^~VkAllocationCallbacks~^~VUID-VkAllocationCallbacks-pfnReallocation-00633~^~core~^~The spec valid usage text states 'pfnReallocation must be a valid pointer to a valid user-defined PFN_vkReallocationFunction' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnReallocation-00633)~^~ -VALIDATION_ERROR_002004f4~^~Y~^~Unknown~^~VkAllocationCallbacks~^~VUID-VkAllocationCallbacks-pfnFree-00634~^~core~^~The spec valid usage text states 'pfnFree must be a valid pointer to a valid user-defined PFN_vkFreeFunction' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnFree-00634)~^~ -VALIDATION_ERROR_002004f6~^~N~^~Unknown~^~VkAllocationCallbacks~^~VUID-VkAllocationCallbacks-pfnInternalAllocation-00635~^~core~^~The spec valid usage text states 'If either of pfnInternalAllocation or pfnInternalFree is not NULL, both must be valid callbacks' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnInternalAllocation-00635)~^~ -VALIDATION_ERROR_004009c0~^~N~^~Unknown~^~VkAndroidSurfaceCreateInfoKHR~^~VUID-VkAndroidSurfaceCreateInfoKHR-window-01248~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'window must point to a valid Android ANativeWindow.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-window-01248)~^~TBD in parameter validation layer. -VALIDATION_ERROR_00409005~^~Y~^~Unknown~^~VkAndroidSurfaceCreateInfoKHR~^~VUID-VkAndroidSurfaceCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_0041c40d~^~Y~^~Unknown~^~VkAndroidSurfaceCreateInfoKHR~^~VUID-VkAndroidSurfaceCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0042b00b~^~Y~^~Unknown~^~VkAndroidSurfaceCreateInfoKHR~^~VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0060f001~^~N~^~Unknown~^~VkApplicationInfo~^~VUID-VkApplicationInfo-pApplicationName-parameter~^~core~^~The spec valid usage text states 'If pApplicationName is not NULL, pApplicationName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-pApplicationName-parameter)~^~implicit -VALIDATION_ERROR_00615c01~^~N~^~Unknown~^~VkApplicationInfo~^~VUID-VkApplicationInfo-pEngineName-parameter~^~core~^~The spec valid usage text states 'If pEngineName is not NULL, pEngineName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-pEngineName-parameter)~^~implicit -VALIDATION_ERROR_0061c40d~^~Y~^~Unknown~^~VkApplicationInfo~^~VUID-VkApplicationInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0062b00b~^~Y~^~Unknown~^~VkApplicationInfo~^~VUID-VkApplicationInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_00800696~^~Y~^~AttachmentDescriptionInvalidFinalLayout~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-finalLayout-00843~^~core~^~The spec valid usage text states 'finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-finalLayout-00843)~^~ -VALIDATION_ERROR_00808e01~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-finalLayout-parameter~^~core~^~The spec valid usage text states 'finalLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-finalLayout-parameter)~^~implicit -VALIDATION_ERROR_00809001~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkAttachmentDescriptionFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_00809201~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-format-parameter)~^~implicit -VALIDATION_ERROR_0080b801~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-initialLayout-parameter~^~core~^~The spec valid usage text states 'initialLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-initialLayout-parameter)~^~implicit -VALIDATION_ERROR_0080c201~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-loadOp-parameter~^~core~^~The spec valid usage text states 'loadOp must be a valid VkAttachmentLoadOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-loadOp-parameter)~^~implicit -VALIDATION_ERROR_0082b401~^~Y~^~CreateRenderPassAttachments~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-samples-parameter~^~core~^~The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-samples-parameter)~^~implicit -VALIDATION_ERROR_0082e001~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-stencilLoadOp-parameter~^~core~^~The spec valid usage text states 'stencilLoadOp must be a valid VkAttachmentLoadOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-stencilLoadOp-parameter)~^~implicit -VALIDATION_ERROR_0082e201~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-stencilStoreOp-parameter~^~core~^~The spec valid usage text states 'stencilStoreOp must be a valid VkAttachmentStoreOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-stencilStoreOp-parameter)~^~implicit -VALIDATION_ERROR_0082e401~^~Y~^~Unknown~^~VkAttachmentDescription~^~VUID-VkAttachmentDescription-storeOp-parameter~^~core~^~The spec valid usage text states 'storeOp must be a valid VkAttachmentStoreOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-storeOp-parameter)~^~implicit -VALIDATION_ERROR_00a006b2~^~N~^~Unknown~^~VkAttachmentReference~^~VUID-VkAttachmentReference-layout-00857~^~core~^~The spec valid usage text states 'layout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentReference-layout-00857)~^~ -VALIDATION_ERROR_00a0be01~^~Y~^~Unknown~^~VkAttachmentReference~^~VUID-VkAttachmentReference-layout-parameter~^~core~^~The spec valid usage text states 'layout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentReference-layout-parameter)~^~implicit -VALIDATION_ERROR_00c00009~^~Y~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-commonparent~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-commonparent)~^~implicit -VALIDATION_ERROR_00c00c72~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01593~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'buffer must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01593)~^~ -VALIDATION_ERROR_00c00c74~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01594~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'buffer must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01594)~^~ -VALIDATION_ERROR_00c00c76~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-memoryOffset-01595~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memoryOffset-01595)~^~ -VALIDATION_ERROR_00c00c78~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01596~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01596)~^~ -VALIDATION_ERROR_00c00c7a~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01597~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01597)~^~ -VALIDATION_ERROR_00c00c7c~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01598~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01598)~^~ -VALIDATION_ERROR_00c00c7e~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-memory-01599~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-01599)~^~ -VALIDATION_ERROR_00c00c80~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-memoryOffset-01600~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memoryOffset-01600)~^~ -VALIDATION_ERROR_00c00c82~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-size-01601~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-size-01601)~^~ -VALIDATION_ERROR_00c00c84~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01602~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01602)~^~ -VALIDATION_ERROR_00c00c86~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01603~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01603)~^~ -VALIDATION_ERROR_00c00c88~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-01604~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01604)~^~ -VALIDATION_ERROR_00c00c8a~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-pNext-01605~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the pNext chain includes VkBindBufferMemoryDeviceGroupInfo, all instances of memory specified by VkBindBufferMemoryDeviceGroupInfo::pDeviceIndices must have been allocated' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-pNext-01605)~^~ -VALIDATION_ERROR_00c00ed8~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-memory-01900~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-01900)~^~ -VALIDATION_ERROR_00c01a01~^~Y~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-buffer-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-parameter)~^~implicit -VALIDATION_ERROR_00c0c601~^~Y~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-memory-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-parameter)~^~implicit -VALIDATION_ERROR_00c1c40d~^~Y~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_00c2b00b~^~N~^~None~^~VkBindBufferMemoryInfo~^~VUID-VkBindBufferMemoryInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-sType-sType)~^~implicit -VALIDATION_ERROR_00e00009~^~Y~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-commonparent~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'Both of image, and memory that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-commonparent)~^~implicit -VALIDATION_ERROR_00e00c92~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-image-01609~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'image must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01609)~^~ -VALIDATION_ERROR_00e00c94~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-image-01610~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'image must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01610)~^~ -VALIDATION_ERROR_00e00c96~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-memoryOffset-01611~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memoryOffset-01611)~^~ -VALIDATION_ERROR_00e00c98~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-memory-01612~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01612)~^~ -VALIDATION_ERROR_00e00c9a~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-memoryOffset-01613~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memoryOffset-01613)~^~ -VALIDATION_ERROR_00e00c9c~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-memory-01614~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01614)~^~ -VALIDATION_ERROR_00e00c9e~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01615~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01615)~^~ -VALIDATION_ERROR_00e00ca0~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01616~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01616)~^~ -VALIDATION_ERROR_00e00ca2~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01617~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01617)~^~ -VALIDATION_ERROR_00e00ca4~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01618~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, image must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01618)~^~ -VALIDATION_ERROR_00e00ca6~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01619~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2's pNext chain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01619)~^~ -VALIDATION_ERROR_00e00ca8~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01620~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2's pNext chain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01620)~^~ -VALIDATION_ERROR_00e00caa~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01621~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2's pNext chain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01621)~^~ -VALIDATION_ERROR_00e00cac~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-image-01622~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01622)~^~ -VALIDATION_ERROR_00e00cae~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-image-01623~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01623)~^~ -VALIDATION_ERROR_00e00cb0~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-image-01624~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01624)~^~ -VALIDATION_ERROR_00e00cb2~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-memory-01625~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01625)~^~ -VALIDATION_ERROR_00e00cb4~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01626~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all instances of memory specified by VkBindImageMemoryDeviceGroupInfo::pDeviceIndices must have been allocated' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01626)~^~ -VALIDATION_ERROR_00e00cb6~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01627~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, and VkBindImageMemoryDeviceGroupInfo::splitInstanceBindRegionCount is not zero, then image must have been created with the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01627)~^~ -VALIDATION_ERROR_00e00cb8~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01628~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions must be valid rectangles contained within the dimensions of image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01628)~^~ -VALIDATION_ERROR_00e00cba~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01629~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, the union of the areas of all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions that correspond to the same instance of image must cover the entire image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01629)~^~ -VALIDATION_ERROR_00e00cbc~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-image-01630~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01630)~^~ -VALIDATION_ERROR_00e00cbe~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01631~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If the pNext chain includes an instance of VkBindImageMemorySwapchainInfoKHR, memory must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01631)~^~ -VALIDATION_ERROR_00e00cc0~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-01632~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If the pNext chain does not include an instance of VkBindImageMemorySwapchainInfoKHR, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01632)~^~ -VALIDATION_ERROR_00e00ede~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-memory-01903~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01903)~^~ -VALIDATION_ERROR_00e0a001~^~Y~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-image-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-parameter)~^~implicit -VALIDATION_ERROR_00e1c40d~^~Y~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, or VkBindImagePlaneMemoryInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_00e2b00b~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-sType-sType)~^~implicit -VALIDATION_ERROR_00e2b00f~^~N~^~None~^~VkBindImageMemoryInfo~^~VUID-VkBindImageMemoryInfo-sType-unique~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-sType-unique)~^~implicit -VALIDATION_ERROR_01000cd8~^~N~^~None~^~VkBindImageMemorySwapchainInfoKHR~^~VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageIndex must be less than the number of images in swapchain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644)~^~ -VALIDATION_ERROR_0102b00b~^~N~^~Unknown~^~VkBindImageMemorySwapchainInfoKHR~^~VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0102f001~^~N~^~Unknown~^~VkBindImageMemorySwapchainInfoKHR~^~VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter)~^~implicit -VALIDATION_ERROR_01200009~^~Y~^~Unknown~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-commonparent~^~core~^~The spec valid usage text states 'Both of the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-commonparent)~^~implicit -VALIDATION_ERROR_01210201~^~Y~^~None~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-pBufferBinds-parameter~^~core~^~The spec valid usage text states 'If bufferBindCount is not 0, pBufferBinds must be a valid pointer to an array of bufferBindCount valid VkSparseBufferMemoryBindInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pBufferBinds-parameter)~^~implicit -VALIDATION_ERROR_01218001~^~Y~^~None~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-pImageBinds-parameter~^~core~^~The spec valid usage text states 'If imageBindCount is not 0, pImageBinds must be a valid pointer to an array of imageBindCount valid VkSparseImageMemoryBindInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pImageBinds-parameter)~^~implicit -VALIDATION_ERROR_01218c01~^~Y~^~None~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-pImageOpaqueBinds-parameter~^~core~^~The spec valid usage text states 'If imageOpaqueBindCount is not 0, pImageOpaqueBinds must be a valid pointer to an array of imageOpaqueBindCount valid VkSparseImageOpaqueMemoryBindInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pImageOpaqueBinds-parameter)~^~implicit -VALIDATION_ERROR_0121c40d~^~Y~^~Unknown~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDeviceGroupBindSparseInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_01223401~^~Y~^~Unknown~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-pSignalSemaphores-parameter~^~core~^~The spec valid usage text states 'If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pSignalSemaphores-parameter)~^~implicit -VALIDATION_ERROR_01227601~^~Y~^~Unknown~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-pWaitSemaphores-parameter~^~core~^~The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pWaitSemaphores-parameter)~^~implicit -VALIDATION_ERROR_0122b00b~^~N~^~Unknown~^~VkBindSparseInfo~^~VUID-VkBindSparseInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_01400720~^~Y~^~InvalidCreateBufferSize~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-size-00912~^~core~^~The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-size-00912)~^~ -VALIDATION_ERROR_01400722~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sharingMode-00913~^~core~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-00913)~^~ -VALIDATION_ERROR_01400724~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sharingMode-00914~^~core~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-00914)~^~ -VALIDATION_ERROR_01400726~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-flags-00915~^~core~^~The spec valid usage text states 'If the sparse bindings feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00915)~^~ -VALIDATION_ERROR_01400728~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-flags-00916~^~core~^~The spec valid usage text states 'If the sparse buffer residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00916)~^~ -VALIDATION_ERROR_0140072a~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-flags-00917~^~core~^~The spec valid usage text states 'If the sparse aliased residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00917)~^~ -VALIDATION_ERROR_0140072c~^~Y~^~SparseBindingImageBufferCreate~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-flags-00918~^~core~^~The spec valid usage text states 'If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00918)~^~ -VALIDATION_ERROR_01400730~^~N~^~Unknown~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-pNext-00920~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryBufferCreateInfo, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.pname:compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo-&gt;handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-00920)~^~ -VALIDATION_ERROR_01400ade~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sharingMode-01391~^~!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01391)~^~ -VALIDATION_ERROR_01400b16~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sharingMode-01419~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01419)~^~ -VALIDATION_ERROR_01400c46~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-pNext-01571~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkDedicatedAllocationBufferCreateInfoNV, and the dedicatedAllocation member of the chained structure is VK_TRUE, then flags must not include VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-01571)~^~ -VALIDATION_ERROR_01400ebe~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-flags-01887~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If the protected memory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-flags-01887)~^~ -VALIDATION_ERROR_01400ec0~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-None-01888~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If any of the bits VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT are set, VK_BUFFER_CREATE_PROTECTED_BIT must not also be set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-None-01888)~^~ -VALIDATION_ERROR_01409001~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0141c40d~^~Y~^~Unknown~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV or VkExternalMemoryBufferCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_0142b00b~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0142b00f~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_0142c001~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sharingMode-parameter~^~core~^~The spec valid usage text states 'sharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-parameter)~^~implicit -VALIDATION_ERROR_01430601~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-usage-parameter~^~core~^~The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-parameter)~^~implicit -VALIDATION_ERROR_01430603~^~Y~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-usage-requiredbitmask~^~core~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_01600182~^~Y~^~MiscImageLayerTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferOffset-00193~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter's format is not a depth/stencil format, then bufferOffset must be a multiple of the format's element size' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-00193)~^~ -VALIDATION_ERROR_01600184~^~Y~^~MiscImageLayerTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferOffset-00194~^~core~^~The spec valid usage text states 'bufferOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-00194)~^~ -VALIDATION_ERROR_01600186~^~Y~^~MiscImageLayerTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferRowLength-00195~^~core~^~The spec valid usage text states 'bufferRowLength must be 0, or greater than or equal to the width member of imageExtent' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferRowLength-00195)~^~ -VALIDATION_ERROR_01600188~^~Y~^~MiscImageLayerTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferImageHeight-00196~^~core~^~The spec valid usage text states 'bufferImageHeight must be 0, or greater than or equal to the height member of imageExtent' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferImageHeight-00196)~^~ -VALIDATION_ERROR_0160018a~^~N~^~Unknown~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageOffset-00197~^~core~^~The spec valid usage text states 'imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00197)~^~ -VALIDATION_ERROR_0160018c~^~N~^~Unknown~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageOffset-00198~^~core~^~The spec valid usage text states 'imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00198)~^~ -VALIDATION_ERROR_0160018e~^~Y~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-srcImage-00199~^~core~^~The spec valid usage text states 'If the calling command's srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D, then imageOffset.y must be 0 and imageExtent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-srcImage-00199)~^~ -VALIDATION_ERROR_01600190~^~N~^~Unknown~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageOffset-00200~^~core~^~The spec valid usage text states 'imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00200)~^~This VU has two distinct conditions and the implemented check looks at both, but there are two distinct test cases for this enum -VALIDATION_ERROR_01600192~^~Y~^~MiscImageLayerTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-srcImage-00201~^~core~^~The spec valid usage text states 'If the calling command's srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then imageOffset.z must be 0 and imageExtent.depth must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-srcImage-00201)~^~ -VALIDATION_ERROR_01600196~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferRowLength-00203~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, bufferRowLength must be a multiple of the compressed texel block width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferRowLength-00203)~^~ -VALIDATION_ERROR_01600198~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferImageHeight-00204~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, bufferImageHeight must be a multiple of the compressed texel block height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferImageHeight-00204)~^~ -VALIDATION_ERROR_0160019a~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageOffset-00205~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00205)~^~ -VALIDATION_ERROR_0160019c~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferOffset-00206~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, bufferOffset must be a multiple of the compressed texel block size in bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-00206)~^~ -VALIDATION_ERROR_0160019e~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageExtent-00207~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageExtent-00207)~^~ -VALIDATION_ERROR_016001a0~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageExtent-00208~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageExtent-00208)~^~ -VALIDATION_ERROR_016001a2~^~Y~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageExtent-00209~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageExtent-00209)~^~ -VALIDATION_ERROR_016001a6~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-aspectMask-00211~^~core~^~The spec valid usage text states 'The aspectMask member of imageSubresource must specify aspects present in the calling command's VkImage parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-aspectMask-00211)~^~ -VALIDATION_ERROR_016001a8~^~Y~^~ImageBufferCopyTests~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-aspectMask-00212~^~core~^~The spec valid usage text states 'The aspectMask member of imageSubresource must only have a single bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-aspectMask-00212)~^~ -VALIDATION_ERROR_016001aa~^~Y~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-baseArrayLayer-00213~^~core~^~The spec valid usage text states 'If the calling command's VkImage parameter is of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of imageSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-baseArrayLayer-00213)~^~ -VALIDATION_ERROR_016001ac~^~N~^~Unknown~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-00214~^~core~^~The spec valid usage text states 'When copying to the depth aspect of an image subresource, the data in the source buffer must be in the range [0,1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-None-00214)~^~ -VALIDATION_ERROR_01600c2c~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferOffset-01558~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter's format is not a depth/stencil format or a multi-planar format, then bufferOffset must be a multiple of the format's element size' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-01558)~^~ -VALIDATION_ERROR_01600c2e~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-bufferOffset-01559~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter's format is a multi-planar format, then bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in features-formats-compatible-planes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-01559)~^~ -VALIDATION_ERROR_01600c30~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-aspectMask-01560~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter's format is a multi-planar format, then the aspectMask member of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-aspectMask-01560)~^~ -VALIDATION_ERROR_01600d8e~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-01735~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, "_422" image format, bufferRowLength must be a multiple of the compressed texel block width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01735)~^~ -VALIDATION_ERROR_01600d90~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-01736~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, "_422" image format, bufferImageHeight must be a multiple of the compressed texel block height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01736)~^~ -VALIDATION_ERROR_01600d92~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-01737~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, "_422" image format, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01737)~^~ -VALIDATION_ERROR_01600d94~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-01738~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, "_422" image format, bufferOffset must be a multiple of the compressed texel block size in bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01738)~^~ -VALIDATION_ERROR_01600d96~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-01739~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, "_422" image format, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01739)~^~ -VALIDATION_ERROR_01600d98~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-01740~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, "_422" image format, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01740)~^~ -VALIDATION_ERROR_01600d9a~^~N~^~None~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-None-01741~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, "_422" image format, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01741)~^~ -VALIDATION_ERROR_0160aa01~^~N~^~Unknown~^~VkBufferImageCopy~^~VUID-VkBufferImageCopy-imageSubresource-parameter~^~core~^~The spec valid usage text states 'imageSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageSubresource-parameter)~^~implicit -VALIDATION_ERROR_01800946~^~Y~^~InvalidBarriers~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-offset-01187~^~core~^~The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-offset-01187)~^~ -VALIDATION_ERROR_01800948~^~N~^~Unknown~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-size-01188~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-size-01188)~^~ -VALIDATION_ERROR_0180094a~^~Y~^~InvalidBarriers~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-size-01189~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-size-01189)~^~ -VALIDATION_ERROR_0180094c~^~Y~^~InvalidBarrierQueueFamily~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01190~^~!(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01190)~^~ -VALIDATION_ERROR_0180094e~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01191~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01191)~^~ -VALIDATION_ERROR_01800950~^~Y~^~InvalidBarrierQueueFamily~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01192~^~!(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see devsandqueues-queueprops)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01192)~^~ -VALIDATION_ERROR_01800952~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01193~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01193)~^~ -VALIDATION_ERROR_01800958~^~Y~^~InvalidBarrierQueueFamily~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01196~^~core~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01196)~^~ -VALIDATION_ERROR_01800dc6~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01763~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory ownership transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01763)~^~ -VALIDATION_ERROR_01800dc8~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01764~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01764)~^~ -VALIDATION_ERROR_01800dca~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01765~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01765)~^~ -VALIDATION_ERROR_01800f16~^~N~^~None~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01931~^~core~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01931)~^~ -VALIDATION_ERROR_01801a01~^~Y~^~Unknown~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-parameter)~^~implicit -VALIDATION_ERROR_01806801~^~Y~^~Unknown~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-dstAccessMask-parameter~^~core~^~The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-dstAccessMask-parameter)~^~implicit -VALIDATION_ERROR_0181c40d~^~Y~^~Unknown~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0182b00b~^~N~^~Unknown~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0182c401~^~Y~^~Unknown~^~VkBufferMemoryBarrier~^~VUID-VkBufferMemoryBarrier-srcAccessMask-parameter~^~core~^~The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-srcAccessMask-parameter)~^~implicit -VALIDATION_ERROR_01a0073a~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-offset-00925~^~core~^~The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-offset-00925)~^~ -VALIDATION_ERROR_01a0073c~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-offset-00926~^~core~^~The spec valid usage text states 'offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-offset-00926)~^~ -VALIDATION_ERROR_01a00740~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-range-00928~^~core~^~The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-range-00928)~^~ -VALIDATION_ERROR_01a00742~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-range-00929~^~core~^~The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be a multiple of the element size of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-range-00929)~^~ -VALIDATION_ERROR_01a00744~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-range-00930~^~core~^~The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-range-00930)~^~ -VALIDATION_ERROR_01a00746~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-offset-00931~^~core~^~The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-offset-00931)~^~ -VALIDATION_ERROR_01a00748~^~Y~^~None~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-buffer-00932~^~core~^~The spec valid usage text states 'buffer must have been created with a usage value containing at least one of VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00932)~^~ -VALIDATION_ERROR_01a0074a~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-buffer-00933~^~core~^~The spec valid usage text states 'If buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format must be supported for uniform texel buffers, as specified by the VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00933)~^~ -VALIDATION_ERROR_01a0074c~^~N~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-buffer-00934~^~core~^~The spec valid usage text states 'If buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format must be supported for storage texel buffers, as specified by the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00934)~^~ -VALIDATION_ERROR_01a0074e~^~Y~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-buffer-00935~^~core~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00935)~^~ -VALIDATION_ERROR_01a01a01~^~Y~^~None~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-parameter)~^~implicit -VALIDATION_ERROR_01a09005~^~Y~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_01a09201~^~Y~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-format-parameter)~^~implicit -VALIDATION_ERROR_01a1c40d~^~Y~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_01a2b00b~^~Y~^~Unknown~^~VkBufferViewCreateInfo~^~VUID-VkBufferViewCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_01c00026~^~Y~^~None~^~VkClearAttachment~^~VUID-VkClearAttachment-aspectMask-00019~^~core~^~The spec valid usage text states 'If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, it must not include VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-00019)~^~ -VALIDATION_ERROR_01c00028~^~Y~^~Unknown~^~VkClearAttachment~^~VUID-VkClearAttachment-aspectMask-00020~^~core~^~The spec valid usage text states 'aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-00020)~^~ -VALIDATION_ERROR_01c0002a~^~N~^~Unknown~^~VkClearAttachment~^~VUID-VkClearAttachment-clearValue-00021~^~core~^~The spec valid usage text states 'clearValue must be a valid VkClearValue union' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-clearValue-00021)~^~ -VALIDATION_ERROR_01c00c01~^~Y~^~Unknown~^~VkClearAttachment~^~VUID-VkClearAttachment-aspectMask-parameter~^~core~^~The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-parameter)~^~implicit -VALIDATION_ERROR_01c00c03~^~Y~^~Unknown~^~VkClearAttachment~^~VUID-VkClearAttachment-aspectMask-requiredbitmask~^~core~^~The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_01c00e22~^~N~^~None~^~VkClearAttachment~^~VUID-VkClearAttachment-commandBuffer-01809~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then the attachment to be cleared must not be a protected image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkClearAttachment-commandBuffer-01809)~^~ -VALIDATION_ERROR_01c00e24~^~N~^~None~^~VkClearAttachment~^~VUID-VkClearAttachment-commandBuffer-01810~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then the attachment to be cleared must not be an unprotected image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkClearAttachment-commandBuffer-01810)~^~ -VALIDATION_ERROR_01e0002c~^~N~^~Unknown~^~VkClearDepthStencilValue~^~VUID-VkClearDepthStencilValue-depth-00022~^~(VK_EXT_depth_range_unrestricted)~^~The spec valid usage text states 'Unless the VK_EXT_depth_range_unrestricted extension is enabled depth must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkClearDepthStencilValue-depth-00022)~^~ -VALIDATION_ERROR_0200002e~^~N~^~Unknown~^~VkClearValue~^~VUID-VkClearValue-depthStencil-00023~^~core~^~The spec valid usage text states 'depthStencil must be a valid VkClearDepthStencilValue structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearValue-depthStencil-00023)~^~ -VALIDATION_ERROR_02200009~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-commonparent~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'Each of indirectCommandsLayout, objectTable, sequencesCountBuffer, sequencesIndexBuffer, and targetCommandBuffer that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-commonparent)~^~implicit -VALIDATION_ERROR_02200a66~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-objectTable-01331~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The provided objectTable must include all objects referenced by the generation process.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-objectTable-01331)~^~ -VALIDATION_ERROR_02200a68~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-01332~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'indirectCommandsTokenCount must match the indirectCommandsLayout's tokenCount.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-01332)~^~ -VALIDATION_ERROR_02200a6a~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-tokenType-01333~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The tokenType member of each entry in the pIndirectCommandsTokens array must match the values used at creation time of indirectCommandsLayout' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-tokenType-01333)~^~ -VALIDATION_ERROR_02200a6c~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01334~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If targetCommandBuffer is provided, it must have reserved command space.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01334)~^~ -VALIDATION_ERROR_02200a6e~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01335~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If targetCommandBuffer is provided, the objectTable must match the reservation's objectTable and must have had all referenced objects registered at reservation time.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01335)~^~ -VALIDATION_ERROR_02200a70~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01336~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If targetCommandBuffer is provided, the indirectCommandsLayout must match the reservation's indirectCommandsLayout.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01336)~^~ -VALIDATION_ERROR_02200a72~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01337~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If targetCommandBuffer is provided, the maxSequencesCount must not exceed the reservation's maxSequencesCount.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01337)~^~ -VALIDATION_ERROR_02200a74~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01338~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If sequencesCountBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01338)~^~ -VALIDATION_ERROR_02200a76~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01339~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If sequencesCountBuffer is used, sequencesCountOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceCountBufferOffsetAlignment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01339)~^~ -VALIDATION_ERROR_02200a78~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01340~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If sequencesIndexBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01340)~^~ -VALIDATION_ERROR_02200a7a~^~N~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01341~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If sequencesIndexBuffer is used, sequencesIndexOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceIndexBufferOffsetAlignment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01341)~^~ -VALIDATION_ERROR_0220b401~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter)~^~implicit -VALIDATION_ERROR_0220b61b~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-arraylength~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'indirectCommandsTokenCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-arraylength)~^~implicit -VALIDATION_ERROR_0220d801~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter)~^~implicit -VALIDATION_ERROR_02219401~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-pIndirectCommandsTokens-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pIndirectCommandsTokens must be a valid pointer to an array of indirectCommandsTokenCount valid VkIndirectCommandsTokenNVX structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-pIndirectCommandsTokens-parameter)~^~implicit -VALIDATION_ERROR_0221c40d~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-pNext-pNext~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0222b00b~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-sType-sType~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sType-sType)~^~implicit -VALIDATION_ERROR_0222ba01~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If sequencesCountBuffer is not VK_NULL_HANDLE, sequencesCountBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter)~^~implicit -VALIDATION_ERROR_0222bc01~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If sequencesIndexBuffer is not VK_NULL_HANDLE, sequencesIndexBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter)~^~implicit -VALIDATION_ERROR_0222f601~^~Y~^~Unknown~^~VkCmdProcessCommandsInfoNVX~^~VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If targetCommandBuffer is not NULL, targetCommandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter)~^~implicit -VALIDATION_ERROR_02400009~^~Y~^~Unknown~^~VkCmdReserveSpaceForCommandsInfoNVX~^~VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'Both of indirectCommandsLayout, and objectTable must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent)~^~implicit -VALIDATION_ERROR_0240b401~^~Y~^~Unknown~^~VkCmdReserveSpaceForCommandsInfoNVX~^~VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter)~^~implicit -VALIDATION_ERROR_0240d801~^~Y~^~Unknown~^~VkCmdReserveSpaceForCommandsInfoNVX~^~VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter)~^~implicit -VALIDATION_ERROR_0241c40d~^~Y~^~Unknown~^~VkCmdReserveSpaceForCommandsInfoNVX~^~VUID-VkCmdReserveSpaceForCommandsInfoNVX-pNext-pNext~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0242b00b~^~Y~^~Unknown~^~VkCmdReserveSpaceForCommandsInfoNVX~^~VUID-VkCmdReserveSpaceForCommandsInfoNVX-sType-sType~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-sType-sType)~^~implicit -VALIDATION_ERROR_02600058~^~N~^~Unknown~^~VkCommandBufferAllocateInfo~^~VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044~^~core~^~The spec valid usage text states 'commandBufferCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044)~^~ -VALIDATION_ERROR_02602801~^~Y~^~None~^~VkCommandBufferAllocateInfo~^~VUID-VkCommandBufferAllocateInfo-commandPool-parameter~^~core~^~The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-commandPool-parameter)~^~implicit -VALIDATION_ERROR_0260c001~^~Y~^~Unknown~^~VkCommandBufferAllocateInfo~^~VUID-VkCommandBufferAllocateInfo-level-parameter~^~core~^~The spec valid usage text states 'level must be a valid VkCommandBufferLevel value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-level-parameter)~^~implicit -VALIDATION_ERROR_0261c40d~^~Y~^~Unknown~^~VkCommandBufferAllocateInfo~^~VUID-VkCommandBufferAllocateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0262b00b~^~Y~^~Unknown~^~VkCommandBufferAllocateInfo~^~VUID-VkCommandBufferAllocateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0280006a~^~Y~^~SecondaryCommandBufferNullRenderpass~^~VkCommandBufferBeginInfo~^~VUID-VkCommandBufferBeginInfo-flags-00053~^~core~^~The spec valid usage text states 'If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo must be a valid VkRenderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-00053)~^~ -VALIDATION_ERROR_0280006c~^~Y~^~Unknown~^~VkCommandBufferBeginInfo~^~VUID-VkCommandBufferBeginInfo-flags-00054~^~core~^~The spec valid usage text states 'If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-00054)~^~ -VALIDATION_ERROR_0280006e~^~Y~^~None~^~VkCommandBufferBeginInfo~^~VUID-VkCommandBufferBeginInfo-flags-00055~^~core~^~The spec valid usage text states 'If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-00055)~^~ -VALIDATION_ERROR_02809001~^~Y~^~Unknown~^~VkCommandBufferBeginInfo~^~VUID-VkCommandBufferBeginInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkCommandBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0281c40d~^~Y~^~Unknown~^~VkCommandBufferBeginInfo~^~VUID-VkCommandBufferBeginInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0282b00b~^~Y~^~Unknown~^~VkCommandBufferBeginInfo~^~VUID-VkCommandBufferBeginInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_02a00009~^~Y~^~Unknown~^~VkCommandBufferInheritanceInfo~^~VUID-VkCommandBufferInheritanceInfo-commonparent~^~core~^~The spec valid usage text states 'Both of framebuffer, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-commonparent)~^~implicit -VALIDATION_ERROR_02a00070~^~Y~^~Unknown~^~VkCommandBufferInheritanceInfo~^~VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056~^~core~^~The spec valid usage text states 'If the inherited queries feature is not enabled, occlusionQueryEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056)~^~ -VALIDATION_ERROR_02a00072~^~Y~^~Unknown~^~VkCommandBufferInheritanceInfo~^~VUID-VkCommandBufferInheritanceInfo-queryFlags-00057~^~core~^~The spec valid usage text states 'If the inherited queries feature is enabled, queryFlags must be a valid combination of VkQueryControlFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-queryFlags-00057)~^~ -VALIDATION_ERROR_02a00074~^~N~^~Unknown~^~VkCommandBufferInheritanceInfo~^~VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058~^~core~^~The spec valid usage text states 'If the pipeline statistics queries feature is not enabled, pipelineStatistics must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058)~^~ -VALIDATION_ERROR_02a1c40d~^~N~^~Unknown~^~VkCommandBufferInheritanceInfo~^~VUID-VkCommandBufferInheritanceInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_02a2b00b~^~N~^~Unknown~^~VkCommandBufferInheritanceInfo~^~VUID-VkCommandBufferInheritanceInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_02c0004e~^~Y~^~Unknown~^~VkCommandPoolCreateInfo~^~VUID-VkCommandPoolCreateInfo-queueFamilyIndex-00039~^~core~^~The spec valid usage text states 'queueFamilyIndex must be the index of a queue family available in the calling command's device parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-queueFamilyIndex-00039)~^~ -VALIDATION_ERROR_02c09001~^~Y~^~Unknown~^~VkCommandPoolCreateInfo~^~VUID-VkCommandPoolCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkCommandPoolCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_02c1c40d~^~Y~^~Unknown~^~VkCommandPoolCreateInfo~^~VUID-VkCommandPoolCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_02c2b00b~^~Y~^~Unknown~^~VkCommandPoolCreateInfo~^~VUID-VkCommandPoolCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_02e00001~^~Y~^~Unknown~^~VkComponentMapping~^~VUID-VkComponentMapping-a-parameter~^~core~^~The spec valid usage text states 'a must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-a-parameter)~^~implicit -VALIDATION_ERROR_02e01001~^~Y~^~Unknown~^~VkComponentMapping~^~VUID-VkComponentMapping-b-parameter~^~core~^~The spec valid usage text states 'b must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-b-parameter)~^~implicit -VALIDATION_ERROR_02e09a01~^~Y~^~Unknown~^~VkComponentMapping~^~VUID-VkComponentMapping-g-parameter~^~core~^~The spec valid usage text states 'g must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-g-parameter)~^~implicit -VALIDATION_ERROR_02e2a201~^~Y~^~Unknown~^~VkComponentMapping~^~VUID-VkComponentMapping-r-parameter~^~core~^~The spec valid usage text states 'r must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-r-parameter)~^~implicit -VALIDATION_ERROR_03000009~^~Y~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-commonparent~^~core~^~The spec valid usage text states 'Both of basePipelineHandle, and layout that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-commonparent)~^~implicit -VALIDATION_ERROR_03000572~^~Y~^~None~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-flags-00697~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00697)~^~ -VALIDATION_ERROR_03000574~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-flags-00698~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command's pCreateInfos parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00698)~^~ -VALIDATION_ERROR_03000576~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-flags-00699~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00699)~^~ -VALIDATION_ERROR_03000578~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-flags-00700~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00700)~^~ -VALIDATION_ERROR_0300057a~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-stage-00701~^~core~^~The spec valid usage text states 'The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-00701)~^~ -VALIDATION_ERROR_0300057c~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-stage-00702~^~core~^~The spec valid usage text states 'The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-00702)~^~ -VALIDATION_ERROR_0300057e~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-layout-00703~^~core~^~The spec valid usage text states 'layout must be consistent with the layout of the compute shader specified in stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-00703)~^~ -VALIDATION_ERROR_03000d2e~^~N~^~None~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-layout-01687~^~core~^~The spec valid usage text states 'The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-01687)~^~ -VALIDATION_ERROR_03009001~^~Y~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkPipelineCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0300be01~^~Y~^~None~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-layout-parameter~^~core~^~The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0301c40d~^~Y~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-pNext-pNext)~^~implicit, TBD parameter validation layer. -VALIDATION_ERROR_0302b00b~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0302d801~^~N~^~Unknown~^~VkComputePipelineCreateInfo~^~VUID-VkComputePipelineCreateInfo-stage-parameter~^~core~^~The spec valid usage text states 'stage must be a valid VkPipelineShaderStageCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-parameter)~^~implicit -VALIDATION_ERROR_03200009~^~Y~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-commonparent~^~core~^~The spec valid usage text states 'Both of dstSet, and srcSet must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-commonparent)~^~implicit -VALIDATION_ERROR_032002b2~^~Y~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcBinding-00345~^~core~^~The spec valid usage text states 'srcBinding must be a valid binding within srcSet' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcBinding-00345)~^~ -VALIDATION_ERROR_032002b4~^~Y~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcArrayElement-00346~^~core~^~The spec valid usage text states 'The sum of srcArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by srcBinding, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcArrayElement-00346)~^~ -VALIDATION_ERROR_032002b6~^~Y~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-dstBinding-00347~^~core~^~The spec valid usage text states 'dstBinding must be a valid binding within dstSet' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-dstBinding-00347)~^~ -VALIDATION_ERROR_032002b8~^~Y~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-dstArrayElement-00348~^~core~^~The spec valid usage text states 'The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-dstArrayElement-00348)~^~ -VALIDATION_ERROR_032002ba~^~Y~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcSet-00349~^~core~^~The spec valid usage text states 'If srcSet is equal to dstSet, then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-00349)~^~ -VALIDATION_ERROR_03200efc~^~Y~^~None~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcSet-01918~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If srcSet's layout was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet's layout must also have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01918)~^~ -VALIDATION_ERROR_03200efe~^~Y~^~None~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcSet-01919~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If srcSet's layout was created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet's layout must also have been created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01919)~^~ -VALIDATION_ERROR_03200f00~^~Y~^~None~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcSet-01920~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If the descriptor pool from which srcSet was allocated was created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01920)~^~ -VALIDATION_ERROR_03200f02~^~Y~^~None~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcSet-01921~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01921)~^~ -VALIDATION_ERROR_03207601~^~Y~^~UpdateDestroyDescriptorSetLayout~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-dstSet-parameter~^~core~^~The spec valid usage text states 'dstSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-dstSet-parameter)~^~implicit -VALIDATION_ERROR_0321c40d~^~Y~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0322b00b~^~N~^~Unknown~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0322d201~^~Y~^~UpdateDestroyDescriptorSetLayout~^~VkCopyDescriptorSet~^~VUID-VkCopyDescriptorSet-srcSet-parameter~^~core~^~The spec valid usage text states 'srcSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-parameter)~^~implicit -VALIDATION_ERROR_0340009e~^~N~^~Unknown~^~VkD3D12FenceSubmitInfoKHR~^~VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079)~^~ -VALIDATION_ERROR_034000a0~^~N~^~Unknown~^~VkD3D12FenceSubmitInfoKHR~^~VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080)~^~ -VALIDATION_ERROR_03423201~^~N~^~Unknown~^~VkD3D12FenceSubmitInfoKHR~^~VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a valid pointer to an array of signalSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter)~^~implicit -VALIDATION_ERROR_03427401~^~N~^~Unknown~^~VkD3D12FenceSubmitInfoKHR~^~VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a valid pointer to an array of waitSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter)~^~implicit -VALIDATION_ERROR_0342b00b~^~N~^~Unknown~^~VkD3D12FenceSubmitInfoKHR~^~VUID-VkD3D12FenceSubmitInfoKHR-sType-sType~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0361a801~^~Y~^~Unknown~^~VkDebugMarkerMarkerInfoEXT~^~VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pMarkerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter)~^~implicit -VALIDATION_ERROR_0361c40d~^~Y~^~Unknown~^~VkDebugMarkerMarkerInfoEXT~^~VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0362b00b~^~Y~^~Unknown~^~VkDebugMarkerMarkerInfoEXT~^~VUID-VkDebugMarkerMarkerInfoEXT-sType-sType~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_03800ba4~^~N~^~None~^~VkDebugMarkerObjectNameInfoEXT~^~VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490)~^~ -VALIDATION_ERROR_03800ba6~^~N~^~None~^~VkDebugMarkerObjectNameInfoEXT~^~VUID-VkDebugMarkerObjectNameInfoEXT-object-01491~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'object must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-object-01491)~^~ -VALIDATION_ERROR_03800ba8~^~N~^~None~^~VkDebugMarkerObjectNameInfoEXT~^~VUID-VkDebugMarkerObjectNameInfoEXT-object-01492~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'object must be a Vulkan object of the type associated with objectType as defined in debug-report-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-object-01492)~^~ -VALIDATION_ERROR_0380da01~^~Y~^~Unknown~^~VkDebugMarkerObjectNameInfoEXT~^~VUID-VkDebugMarkerObjectNameInfoEXT-objectType-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'objectType must be a valid VkDebugReportObjectTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-objectType-parameter)~^~implicit -VALIDATION_ERROR_0381c40d~^~Y~^~Unknown~^~VkDebugMarkerObjectNameInfoEXT~^~VUID-VkDebugMarkerObjectNameInfoEXT-pNext-pNext~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0381ce01~^~Y~^~Unknown~^~VkDebugMarkerObjectNameInfoEXT~^~VUID-VkDebugMarkerObjectNameInfoEXT-pObjectName-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pObjectName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-pObjectName-parameter)~^~implicit -VALIDATION_ERROR_0382b00b~^~Y~^~Unknown~^~VkDebugMarkerObjectNameInfoEXT~^~VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_03a00baa~^~N~^~None~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493)~^~ -VALIDATION_ERROR_03a00bac~^~N~^~None~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-object-01494~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'object must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-object-01494)~^~ -VALIDATION_ERROR_03a00bae~^~N~^~None~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-object-01495~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'object must be a Vulkan object of the type associated with objectType as defined in debug-report-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-object-01495)~^~ -VALIDATION_ERROR_03a0da01~^~Y~^~Unknown~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-objectType-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'objectType must be a valid VkDebugReportObjectTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-objectType-parameter)~^~implicit -VALIDATION_ERROR_03a1c40d~^~Y~^~Unknown~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-pNext-pNext~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_03a25a01~^~Y~^~Unknown~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-pTag-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pTag must be a valid pointer to an array of tagSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-pTag-parameter)~^~implicit -VALIDATION_ERROR_03a2b00b~^~Y~^~Unknown~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_03a2f41b~^~Y~^~Unknown~^~VkDebugMarkerObjectTagInfoEXT~^~VUID-VkDebugMarkerObjectTagInfoEXT-tagSize-arraylength~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'tagSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-tagSize-arraylength)~^~implicit -VALIDATION_ERROR_03c00ad2~^~N~^~Unknown~^~VkDebugReportCallbackCreateInfoEXT~^~VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-01385~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'pfnCallback must be a valid PFN_vkDebugReportCallbackEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-01385)~^~ -VALIDATION_ERROR_03c09001~^~Y~^~Unknown~^~VkDebugReportCallbackCreateInfoEXT~^~VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'flags must be a valid combination of VkDebugReportFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_03c2b00b~^~Y~^~Unknown~^~VkDebugReportCallbackCreateInfoEXT~^~VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_03e2b00b~^~N~^~Unknown~^~VkDedicatedAllocationBufferCreateInfoNV~^~VUID-VkDedicatedAllocationBufferCreateInfoNV-sType-sType~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationBufferCreateInfoNV-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_040007c4~^~N~^~Unknown~^~VkDedicatedAllocationImageCreateInfoNV~^~VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If dedicatedAllocation is VK_TRUE, VkImageCreateInfo::flags must not include VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994)~^~ -VALIDATION_ERROR_0402b00b~^~N~^~Unknown~^~VkDedicatedAllocationImageCreateInfoNV~^~VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_04200009~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-commonparent~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-commonparent)~^~implicit -VALIDATION_ERROR_04200512~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'At least one of image and buffer must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649)~^~ -VALIDATION_ERROR_04200514~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, the image must have been created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650)~^~ -VALIDATION_ERROR_04200516~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, the buffer must have been created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651)~^~ -VALIDATION_ERROR_04200518~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652)~^~ -VALIDATION_ERROR_0420051a~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653)~^~ -VALIDATION_ERROR_0420051c~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654~^~(VK_NV_dedicated_allocation)+(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654)~^~ -VALIDATION_ERROR_0420051e~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655~^~(VK_NV_dedicated_allocation)+(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655)~^~ -VALIDATION_ERROR_04201a01~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter)~^~implicit -VALIDATION_ERROR_0420a001~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter)~^~implicit -VALIDATION_ERROR_0422b00b~^~N~^~Unknown~^~VkDedicatedAllocationMemoryAllocateInfoNV~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_044002a8~^~Y~^~DSBufferInfoErrors~^~VkDescriptorBufferInfo~^~VUID-VkDescriptorBufferInfo-offset-00340~^~core~^~The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-offset-00340)~^~ -VALIDATION_ERROR_044002aa~^~Y~^~DSBufferInfoErrors~^~VkDescriptorBufferInfo~^~VUID-VkDescriptorBufferInfo-range-00341~^~core~^~The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00341)~^~ -VALIDATION_ERROR_044002ac~^~Y~^~DSBufferInfoErrors~^~VkDescriptorBufferInfo~^~VUID-VkDescriptorBufferInfo-range-00342~^~core~^~The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be less than or equal to the size of buffer minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00342)~^~ -VALIDATION_ERROR_04401a01~^~Y~^~Unknown~^~VkDescriptorBufferInfo~^~VUID-VkDescriptorBufferInfo-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-buffer-parameter)~^~implicit -VALIDATION_ERROR_04600009~^~Y~^~Unknown~^~VkDescriptorImageInfo~^~VUID-VkDescriptorImageInfo-commonparent~^~core~^~The spec valid usage text states 'Both of imageView, and sampler that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorImageInfo-commonparent)~^~implicit -VALIDATION_ERROR_046002ae~^~Y~^~Maint1BindingSliceOf3DImage~^~VkDescriptorImageInfo~^~VUID-VkDescriptorImageInfo-imageView-00343~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'imageView must not be 2D or 2D array image view created from a 3D image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorImageInfo-imageView-00343)~^~ -VALIDATION_ERROR_046002b0~^~Y~^~Unknown~^~VkDescriptorImageInfo~^~VUID-VkDescriptorImageInfo-imageLayout-00344~^~core~^~The spec valid usage text states 'imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time this descriptor is accessed' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorImageInfo-imageLayout-00344)~^~ -VALIDATION_ERROR_04600c36~^~N~^~None~^~VkDescriptorImageInfo~^~VUID-VkDescriptorImageInfo-sampler-01563~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If sampler is used and enables sampler Y'CBCR conversion:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorImageInfo-sampler-01563)~^~ -VALIDATION_ERROR_04600c38~^~N~^~None~^~VkDescriptorImageInfo~^~VUID-VkDescriptorImageInfo-sampler-01564~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If sampler is used and does not enable sampler Y'CBCR conversion and the VkFormat of the image is a multi-planar format, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorImageInfo-sampler-01564)~^~ -VALIDATION_ERROR_0480025a~^~Y~^~InvalidCreateDescriptorPool~^~VkDescriptorPoolCreateInfo~^~VUID-VkDescriptorPoolCreateInfo-maxSets-00301~^~core~^~The spec valid usage text states 'maxSets must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-maxSets-00301)~^~ -VALIDATION_ERROR_04809001~^~Y~^~Unknown~^~VkDescriptorPoolCreateInfo~^~VUID-VkDescriptorPoolCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkDescriptorPoolCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0481c40d~^~Y~^~Unknown~^~VkDescriptorPoolCreateInfo~^~VUID-VkDescriptorPoolCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0481e401~^~Y~^~Unknown~^~VkDescriptorPoolCreateInfo~^~VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter~^~core~^~The spec valid usage text states 'pPoolSizes must be a valid pointer to an array of poolSizeCount valid VkDescriptorPoolSize structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter)~^~implicit -VALIDATION_ERROR_0482881b~^~Y~^~Unknown~^~VkDescriptorPoolCreateInfo~^~VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength~^~core~^~The spec valid usage text states 'poolSizeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength)~^~implicit -VALIDATION_ERROR_0482b00b~^~Y~^~Unknown~^~VkDescriptorPoolCreateInfo~^~VUID-VkDescriptorPoolCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_04a0025c~^~Y~^~InvalidCreateDescriptorPool~^~VkDescriptorPoolSize~^~VUID-VkDescriptorPoolSize-descriptorCount-00302~^~core~^~The spec valid usage text states 'descriptorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolSize-descriptorCount-00302)~^~ -VALIDATION_ERROR_04a30401~^~Y~^~Unknown~^~VkDescriptorPoolSize~^~VUID-VkDescriptorPoolSize-type-parameter~^~core~^~The spec valid usage text states 'type must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolSize-type-parameter)~^~implicit -VALIDATION_ERROR_04c00009~^~Y~^~Unknown~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-commonparent~^~core~^~The spec valid usage text states 'Both of descriptorPool, and the elements of pSetLayouts must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-commonparent)~^~implicit -VALIDATION_ERROR_04c00264~^~Y~^~AllocDescriptorFromEmptyPool~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-00306~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'descriptorSetCount must not be greater than the number of sets that are currently available for allocation in descriptorPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-00306)~^~ -VALIDATION_ERROR_04c00266~^~Y~^~AllocDescriptorFromEmptyPool~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-descriptorPool-00307~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'descriptorPool must have enough free descriptor capacity remaining to allocate the descriptor sets of the specified layouts' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorPool-00307)~^~ -VALIDATION_ERROR_04c00268~^~Y~^~AllocatePushDescriptorSet~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'Each element of pSetLayouts must not have been created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308)~^~ -VALIDATION_ERROR_04c017c8~^~Y~^~DescriptorIndexingSetLayout~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044)~^~ -VALIDATION_ERROR_04c04601~^~Y~^~None~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter~^~core~^~The spec valid usage text states 'descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter)~^~implicit -VALIDATION_ERROR_04c04a1b~^~N~^~Unknown~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength~^~core~^~The spec valid usage text states 'descriptorSetCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength)~^~implicit -VALIDATION_ERROR_04c1c40d~^~Y~^~Unknown~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountAllocateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_04c22c01~^~Y~^~None~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter~^~core~^~The spec valid usage text states 'pSetLayouts must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSetLayout handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter)~^~implicit -VALIDATION_ERROR_04c2b00b~^~Y~^~Unknown~^~VkDescriptorSetAllocateInfo~^~VUID-VkDescriptorSetAllocateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_04e00234~^~Y~^~None~^~VkDescriptorSetLayoutBinding~^~VUID-VkDescriptorSetLayoutBinding-descriptorType-00282~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorType-00282)~^~ -VALIDATION_ERROR_04e00236~^~Y~^~Unknown~^~VkDescriptorSetLayoutBinding~^~VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283~^~core~^~The spec valid usage text states 'If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283)~^~ -VALIDATION_ERROR_04e00bcc~^~N~^~None~^~VkDescriptorSetLayoutBinding~^~VUID-VkDescriptorSetLayoutBinding-descriptorType-01510~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorType-01510)~^~ -VALIDATION_ERROR_04e04e01~^~Y~^~Unknown~^~VkDescriptorSetLayoutBinding~^~VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter~^~core~^~The spec valid usage text states 'descriptorType must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter)~^~implicit -VALIDATION_ERROR_0500022e~^~Y~^~DuplicateDescriptorBinding~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-binding-00279~^~core~^~The spec valid usage text states 'The VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-binding-00279)~^~ -VALIDATION_ERROR_05000230~^~Y~^~InvalidPushDescriptorSetLayout~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-flags-00280~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-00280)~^~ -VALIDATION_ERROR_05000232~^~Y~^~InvalidPushDescriptorSetLayout~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-flags-00281~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then the total number of elements of all bindings must be less than or equal to VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-00281)~^~ -VALIDATION_ERROR_05001770~^~Y~^~DescriptorIndexingSetLayout~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-flags-03000~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, flags must include VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-03000)~^~ -VALIDATION_ERROR_05001772~^~N~^~None~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001)~^~ -VALIDATION_ERROR_05009001~^~Y~^~Unknown~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkDescriptorSetLayoutCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter)~^~implicit -VALIDATION_ERROR_0500fc01~^~Y~^~Unknown~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter~^~core~^~The spec valid usage text states 'If bindingCount is not 0, pBindings must be a valid pointer to an array of bindingCount valid VkDescriptorSetLayoutBinding structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter)~^~implicit -VALIDATION_ERROR_0501c40d~^~Y~^~Unknown~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDescriptorSetLayoutBindingFlagsCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0502b00b~^~Y~^~Unknown~^~VkDescriptorSetLayoutCreateInfo~^~VUID-VkDescriptorSetLayoutCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_05200009~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'Both of descriptorSetLayout, and pipelineLayout that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent)~^~implicit -VALIDATION_ERROR_052002bc~^~Y~^~CreateDescriptorUpdateTemplate~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must be a valid VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350)~^~ -VALIDATION_ERROR_052002be~^~Y~^~CreateDescriptorUpdateTemplate~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)~^~The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351)~^~ -VALIDATION_ERROR_052002c0~^~Y~^~CreateDescriptorUpdateTemplate~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)~^~The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352)~^~ -VALIDATION_ERROR_052002c2~^~Y~^~CreateDescriptorUpdateTemplate~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)~^~The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353)~^~ -VALIDATION_ERROR_05204c01~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter)~^~implicit -VALIDATION_ERROR_0520501b~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorUpdateEntryCount-arraylength~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'descriptorUpdateEntryCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorUpdateEntryCount-arraylength)~^~implicit -VALIDATION_ERROR_05209005~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-flags-zerobitmask~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_05213201~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-pDescriptorUpdateEntries-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'pDescriptorUpdateEntries must be a valid pointer to an array of descriptorUpdateEntryCount valid VkDescriptorUpdateTemplateEntry structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-pDescriptorUpdateEntries-parameter)~^~implicit -VALIDATION_ERROR_0521c40d~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_0522b00b~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_0522f801~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateCreateInfo~^~VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'templateType must be a valid VkDescriptorUpdateTemplateType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-parameter)~^~implicit -VALIDATION_ERROR_054002c4~^~N~^~Unknown~^~VkDescriptorUpdateTemplateEntry~^~VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'dstBinding must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354)~^~ -VALIDATION_ERROR_054002c6~^~N~^~Unknown~^~VkDescriptorUpdateTemplateEntry~^~VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding implicitly specified when using a descriptor update template to update descriptors, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355)~^~ -VALIDATION_ERROR_05404e01~^~Y~^~Unknown~^~VkDescriptorUpdateTemplateEntry~^~VUID-VkDescriptorUpdateTemplateEntry-descriptorType-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'descriptorType must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateEntry-descriptorType-parameter)~^~implicit -VALIDATION_ERROR_056002e8~^~Y~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-queueFamilyIndex-00372~^~core~^~The spec valid usage text states '' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-queueFamilyIndex-00372)~^~ -VALIDATION_ERROR_056002ea~^~N~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-pNext-00373~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If the pNext chain includes a VkPhysicalDeviceFeatures2 structure, then pEnabledFeatures must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-00373)~^~ -VALIDATION_ERROR_056002ec~^~Y~^~Maintenance1AndNegativeViewport~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374~^~(VK_AMD_negative_viewport_height)+!(VK_VERSION_1_1)+(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374)~^~ -VALIDATION_ERROR_05600e60~^~N~^~None~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840~^~(VK_AMD_negative_viewport_height)+(VK_VERSION_1_1)~^~The spec valid usage text states 'ppEnabledExtensionNames must not contain VK_AMD_negative_viewport_height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840)~^~ -VALIDATION_ERROR_05609005~^~Y~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_05615a01~^~N~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter~^~core~^~The spec valid usage text states 'If pEnabledFeatures is not NULL, pEnabledFeatures must be a valid pointer to a valid VkPhysicalDeviceFeatures structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter)~^~implicit -VALIDATION_ERROR_0561c40d~^~N~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceSamplerYcbcrConversionFeatures, or VkPhysicalDeviceVariablePointerFeatures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_0561fe01~^~Y~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter~^~core~^~The spec valid usage text states 'pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter)~^~implicit -VALIDATION_ERROR_05628e01~^~Y~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter~^~core~^~The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter)~^~implicit -VALIDATION_ERROR_05629001~^~Y~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter~^~core~^~The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter)~^~implicit -VALIDATION_ERROR_0562a01b~^~N~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength~^~core~^~The spec valid usage text states 'queueCreateInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength)~^~implicit -VALIDATION_ERROR_0562b00b~^~Y~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0562b00f~^~N~^~Unknown~^~VkDeviceCreateInfo~^~VUID-VkDeviceCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_05805801~^~Y~^~Unknown~^~VkDeviceEventInfoEXT~^~VUID-VkDeviceEventInfoEXT-deviceEvent-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'deviceEvent must be a valid VkDeviceEventTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceEventInfoEXT-deviceEvent-parameter)~^~implicit -VALIDATION_ERROR_0581c40d~^~Y~^~Unknown~^~VkDeviceEventInfoEXT~^~VUID-VkDeviceEventInfoEXT-pNext-pNext~^~(VK_EXT_display_control)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceEventInfoEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_0582b00b~^~Y~^~Unknown~^~VkDeviceEventInfoEXT~^~VUID-VkDeviceEventInfoEXT-sType-sType~^~(VK_EXT_display_control)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceEventInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_05a1c40d~^~N~^~Unknown~^~VkDeviceGeneratedCommandsFeaturesNVX~^~VUID-VkDeviceGeneratedCommandsFeaturesNVX-pNext-pNext~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsFeaturesNVX-pNext-pNext)~^~implicit -VALIDATION_ERROR_05a2b00b~^~Y~^~Unknown~^~VkDeviceGeneratedCommandsFeaturesNVX~^~VUID-VkDeviceGeneratedCommandsFeaturesNVX-sType-sType~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsFeaturesNVX-sType-sType)~^~implicit -VALIDATION_ERROR_05c1c40d~^~N~^~Unknown~^~VkDeviceGeneratedCommandsLimitsNVX~^~VUID-VkDeviceGeneratedCommandsLimitsNVX-pNext-pNext~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsLimitsNVX-pNext-pNext)~^~implicit -VALIDATION_ERROR_05c2b00b~^~Y~^~Unknown~^~VkDeviceGeneratedCommandsLimitsNVX~^~VUID-VkDeviceGeneratedCommandsLimitsNVX-sType-sType~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsLimitsNVX-sType-sType)~^~implicit -VALIDATION_ERROR_05e008bc~^~N~^~Unknown~^~VkDeviceGroupBindSparseInfo~^~VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'resourceDeviceIndex and memoryDeviceIndex must both be valid device indices.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118)~^~ -VALIDATION_ERROR_05e008be~^~N~^~Unknown~^~VkDeviceGroupBindSparseInfo~^~VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'Each memory allocation bound in this batch must have allocated an instance for memoryDeviceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119)~^~ -VALIDATION_ERROR_05e2b00b~^~N~^~Unknown~^~VkDeviceGroupBindSparseInfo~^~VUID-VkDeviceGroupBindSparseInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupBindSparseInfo-sType-sType)~^~implicit -VALIDATION_ERROR_060000d4~^~N~^~Unknown~^~VkDeviceGroupCommandBufferBeginInfo~^~VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must be a valid device mask value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106)~^~ -VALIDATION_ERROR_060000d6~^~N~^~Unknown~^~VkDeviceGroupCommandBufferBeginInfo~^~VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107)~^~ -VALIDATION_ERROR_0602b00b~^~N~^~Unknown~^~VkDeviceGroupCommandBufferBeginInfo~^~VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType)~^~implicit -VALIDATION_ERROR_062002ee~^~N~^~Unknown~^~VkDeviceGroupDeviceCreateInfo~^~VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'Each element of pPhysicalDevices must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375)~^~ -VALIDATION_ERROR_062002f0~^~N~^~Unknown~^~VkDeviceGroupDeviceCreateInfo~^~VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'All elements of pPhysicalDevices must be in the same device group as enumerated by vkEnumeratePhysicalDeviceGroups' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376)~^~ -VALIDATION_ERROR_062002f2~^~N~^~Unknown~^~VkDeviceGroupDeviceCreateInfo~^~VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'If physicalDeviceCount is not 0, the physicalDevice parameter of vkCreateDevice must be an element of pPhysicalDevices.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377)~^~ -VALIDATION_ERROR_0621dc01~^~N~^~Unknown~^~VkDeviceGroupDeviceCreateInfo~^~VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'If physicalDeviceCount is not 0, pPhysicalDevices must be a valid pointer to an array of physicalDeviceCount valid VkPhysicalDevice handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter)~^~implicit -VALIDATION_ERROR_0622b00b~^~N~^~Unknown~^~VkDeviceGroupDeviceCreateInfo~^~VUID-VkDeviceGroupDeviceCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_06400a22~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'swapchainCount must equal 0 or VkPresentInfoKHR::swapchainCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297)~^~ -VALIDATION_ERROR_06400a24~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-mode-01298~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01298)~^~ -VALIDATION_ERROR_06400a26~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-mode-01299~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and some physical device in the logical device must include that bit in its VkDeviceGroupPresentCapabilitiesKHR::presentMask.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01299)~^~ -VALIDATION_ERROR_06400a28~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-mode-01300~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, then each element of pDeviceMasks must have a value for which all set bits are set in one of the elements of VkDeviceGroupPresentCapabilitiesKHR::presentMask' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01300)~^~ -VALIDATION_ERROR_06400a2a~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-mode-01301~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, then for each bit set in each element of pDeviceMasks, the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01301)~^~ -VALIDATION_ERROR_06400a2c~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'The value of each element of pDeviceMasks must be equal to the device mask passed in VkAcquireNextImageInfoKHR::deviceMask when the image index was last acquired' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302)~^~ -VALIDATION_ERROR_06400a2e~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-mode-01303~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'mode must have exactly one bit set, and that bit must have been included in VkDeviceGroupSwapchainCreateInfoKHR::modes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01303)~^~ -VALIDATION_ERROR_0640ce01~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-mode-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'mode must be a valid VkDeviceGroupPresentModeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-parameter)~^~implicit -VALIDATION_ERROR_06414001~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If swapchainCount is not 0, pDeviceMasks must be a valid pointer to an array of swapchainCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter)~^~implicit -VALIDATION_ERROR_0642b00b~^~N~^~Unknown~^~VkDeviceGroupPresentInfoKHR~^~VUID-VkDeviceGroupPresentInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_06600712~^~N~^~Unknown~^~VkDeviceGroupRenderPassBeginInfo~^~VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must be a valid device mask value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905)~^~ -VALIDATION_ERROR_06600714~^~N~^~Unknown~^~VkDeviceGroupRenderPassBeginInfo~^~VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906)~^~ -VALIDATION_ERROR_06600716~^~N~^~Unknown~^~VkDeviceGroupRenderPassBeginInfo~^~VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must be a subset of the command buffer's initial device mask' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907)~^~ -VALIDATION_ERROR_06600718~^~N~^~Unknown~^~VkDeviceGroupRenderPassBeginInfo~^~VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceRenderAreaCount must either be zero or equal to the number of physical devices in the logical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908)~^~ -VALIDATION_ERROR_06614201~^~N~^~Unknown~^~VkDeviceGroupRenderPassBeginInfo~^~VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If deviceRenderAreaCount is not 0, pDeviceRenderAreas must be a valid pointer to an array of deviceRenderAreaCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter)~^~implicit -VALIDATION_ERROR_0662b00b~^~N~^~Unknown~^~VkDeviceGroupRenderPassBeginInfo~^~VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType)~^~implicit -VALIDATION_ERROR_068000a4~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'waitSemaphoreCount must equal VkSubmitInfo::waitSemaphoreCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082)~^~ -VALIDATION_ERROR_068000a6~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBufferCount must equal VkSubmitInfo::commandBufferCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083)~^~ -VALIDATION_ERROR_068000a8~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'signalSemaphoreCount must equal VkSubmitInfo::signalSemaphoreCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084)~^~ -VALIDATION_ERROR_068000aa~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'All elements of pWaitSemaphoreDeviceIndices and pSignalSemaphoreDeviceIndices must be valid device indices' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085)~^~ -VALIDATION_ERROR_068000ac~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'All elements of pCommandBufferDeviceMasks must be valid device masks' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086)~^~ -VALIDATION_ERROR_06811201~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If commandBufferCount is not 0, pCommandBufferDeviceMasks must be a valid pointer to an array of commandBufferCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter)~^~implicit -VALIDATION_ERROR_06823001~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If signalSemaphoreCount is not 0, pSignalSemaphoreDeviceIndices must be a valid pointer to an array of signalSemaphoreCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter)~^~implicit -VALIDATION_ERROR_06827201~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphoreDeviceIndices must be a valid pointer to an array of waitSemaphoreCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter)~^~implicit -VALIDATION_ERROR_0682b00b~^~N~^~Unknown~^~VkDeviceGroupSubmitInfo~^~VUID-VkDeviceGroupSubmitInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-sType-sType)~^~implicit -VALIDATION_ERROR_06a0d001~^~N~^~Unknown~^~VkDeviceGroupSwapchainCreateInfoKHR~^~VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'modes must be a valid combination of VkDeviceGroupPresentModeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter)~^~implicit -VALIDATION_ERROR_06a0d003~^~N~^~Unknown~^~VkDeviceGroupSwapchainCreateInfoKHR~^~VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'modes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask)~^~implicit -VALIDATION_ERROR_06a2b00b~^~N~^~Unknown~^~VkDeviceGroupSwapchainCreateInfoKHR~^~VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_06c002fa~^~Y~^~Unknown~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381~^~core~^~The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381)~^~ -VALIDATION_ERROR_06c002fc~^~Y~^~Unknown~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-queueCount-00382~^~core~^~The spec valid usage text states 'queueCount must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-queueCount-00382)~^~ -VALIDATION_ERROR_06c002fe~^~Y~^~Unknown~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383~^~core~^~The spec valid usage text states 'Each element of pQueuePriorities must be between 0.0 and 1.0 inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383)~^~ -VALIDATION_ERROR_06c09001~^~Y~^~None~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkDeviceQueueCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-flags-parameter)~^~implicit -VALIDATION_ERROR_06c1c40d~^~Y~^~Unknown~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDeviceQueueGlobalPriorityCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_06c20401~^~Y~^~Unknown~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter~^~core~^~The spec valid usage text states 'pQueuePriorities must be a valid pointer to an array of queueCount float values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter)~^~implicit -VALIDATION_ERROR_06c29e1b~^~Y~^~Unknown~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-queueCount-arraylength~^~core~^~The spec valid usage text states 'queueCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-queueCount-arraylength)~^~implicit -VALIDATION_ERROR_06c2b00b~^~N~^~Unknown~^~VkDeviceQueueCreateInfo~^~VUID-VkDeviceQueueCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_06e00342~^~N~^~Unknown~^~VkDispatchIndirectCommand~^~VUID-VkDispatchIndirectCommand-x-00417~^~core~^~The spec valid usage text states 'x must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDispatchIndirectCommand-x-00417)~^~ -VALIDATION_ERROR_06e00344~^~N~^~Unknown~^~VkDispatchIndirectCommand~^~VUID-VkDispatchIndirectCommand-y-00418~^~core~^~The spec valid usage text states 'y must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDispatchIndirectCommand-y-00418)~^~ -VALIDATION_ERROR_06e00346~^~N~^~Unknown~^~VkDispatchIndirectCommand~^~VUID-VkDispatchIndirectCommand-z-00419~^~core~^~The spec valid usage text states 'z must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDispatchIndirectCommand-z-00419)~^~ -VALIDATION_ERROR_07006201~^~Y~^~Unknown~^~VkDisplayEventInfoEXT~^~VUID-VkDisplayEventInfoEXT-displayEvent-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'displayEvent must be a valid VkDisplayEventTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayEventInfoEXT-displayEvent-parameter)~^~implicit -VALIDATION_ERROR_0701c40d~^~Y~^~Unknown~^~VkDisplayEventInfoEXT~^~VUID-VkDisplayEventInfoEXT-pNext-pNext~^~(VK_EXT_display_control)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayEventInfoEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_0702b00b~^~Y~^~Unknown~^~VkDisplayEventInfoEXT~^~VUID-VkDisplayEventInfoEXT-sType-sType~^~(VK_EXT_display_control)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayEventInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_072009c4~^~N~^~Unknown~^~VkDisplayModeCreateInfoKHR~^~VUID-VkDisplayModeCreateInfoKHR-width-01250~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'The width and height members of the visibleRegion member of parameters must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-width-01250)~^~ -VALIDATION_ERROR_072009c6~^~N~^~Unknown~^~VkDisplayModeCreateInfoKHR~^~VUID-VkDisplayModeCreateInfoKHR-refreshRate-01251~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'The refreshRate member of parameters must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-refreshRate-01251)~^~ -VALIDATION_ERROR_07209005~^~Y~^~Unknown~^~VkDisplayModeCreateInfoKHR~^~VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0721c40d~^~Y~^~Unknown~^~VkDisplayModeCreateInfoKHR~^~VUID-VkDisplayModeCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0722b00b~^~Y~^~Unknown~^~VkDisplayModeCreateInfoKHR~^~VUID-VkDisplayModeCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0741c40d~^~Y~^~Unknown~^~VkDisplayPowerInfoEXT~^~VUID-VkDisplayPowerInfoEXT-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPowerInfoEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_07428a01~^~Y~^~Unknown~^~VkDisplayPowerInfoEXT~^~VUID-VkDisplayPowerInfoEXT-powerState-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)~^~The spec valid usage text states 'powerState must be a valid VkDisplayPowerStateEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPowerInfoEXT-powerState-parameter)~^~implicit -VALIDATION_ERROR_0742b00b~^~Y~^~Unknown~^~VkDisplayPowerInfoEXT~^~VUID-VkDisplayPowerInfoEXT-sType-sType~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPowerInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_076009d2~^~N~^~Unknown~^~VkDisplayPresentInfoKHR~^~VUID-VkDisplayPresentInfoKHR-srcRect-01257~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'srcRect must specify a rectangular region that is a subset of the image being presented' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-srcRect-01257)~^~ -VALIDATION_ERROR_076009d4~^~N~^~Unknown~^~VkDisplayPresentInfoKHR~^~VUID-VkDisplayPresentInfoKHR-dstRect-01258~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'dstRect must specify a rectangular region that is a subset of the visibleRegion parameter of the display mode the swapchain being presented uses' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-dstRect-01258)~^~ -VALIDATION_ERROR_076009d6~^~N~^~Unknown~^~VkDisplayPresentInfoKHR~^~VUID-VkDisplayPresentInfoKHR-persistentContent-01259~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'If the persistentContent member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display the present operation targets then persistent must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-persistentContent-01259)~^~ -VALIDATION_ERROR_0762b00b~^~N~^~Unknown~^~VkDisplayPresentInfoKHR~^~VUID-VkDisplayPresentInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_078009c8~^~N~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252)~^~ -VALIDATION_ERROR_078009ca~^~N~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If the planeReorderPossible member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display corresponding to displayMode is VK_TRUE then planeStackIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR; otherwise planeStackIndex must equal the currentStackIndex member of VkDisplayPlanePropertiesKHR returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR for the display plane corresponding to displayMode' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253)~^~ -VALIDATION_ERROR_078009cc~^~N~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If alphaMode is VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR then globalAlpha must be between 0 and 1, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254)~^~ -VALIDATION_ERROR_078009ce~^~N~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'alphaMode must be 0 or one of the bits present in the supportedAlpha member of VkDisplayPlaneCapabilitiesKHR returned by vkGetDisplayPlaneCapabilitiesKHR for the display plane corresponding to displayMode' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255)~^~ -VALIDATION_ERROR_078009d0~^~N~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-width-01256~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'The width and height members of imageExtent must be less than the maxImageDimensions2D member of VkPhysicalDeviceLimits' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-width-01256)~^~ -VALIDATION_ERROR_07800a01~^~Y~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'alphaMode must be a valid VkDisplayPlaneAlphaFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter)~^~implicit -VALIDATION_ERROR_07806401~^~Y~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'displayMode must be a valid VkDisplayModeKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter)~^~implicit -VALIDATION_ERROR_07809005~^~Y~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0781c40d~^~Y~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0782b00b~^~Y~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_07830201~^~Y~^~Unknown~^~VkDisplaySurfaceCreateInfoKHR~^~VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'transform must be a valid VkSurfaceTransformFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter)~^~implicit -VALIDATION_ERROR_07a00450~^~N~^~Unknown~^~VkDrawIndexedIndirectCommand~^~VUID-VkDrawIndexedIndirectCommand-None-00552~^~core~^~The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndexedIndirectCommand-None-00552)~^~ -VALIDATION_ERROR_07a00452~^~N~^~Unknown~^~VkDrawIndexedIndirectCommand~^~VUID-VkDrawIndexedIndirectCommand-indexSize-00553~^~core~^~The spec valid usage text states '(indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndexedIndirectCommand-indexSize-00553)~^~ -VALIDATION_ERROR_07a00454~^~N~^~Unknown~^~VkDrawIndexedIndirectCommand~^~VUID-VkDrawIndexedIndirectCommand-firstInstance-00554~^~core~^~The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndexedIndirectCommand-firstInstance-00554)~^~ -VALIDATION_ERROR_07c003e8~^~N~^~Unknown~^~VkDrawIndirectCommand~^~VUID-VkDrawIndirectCommand-None-00500~^~core~^~The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndirectCommand-None-00500)~^~ -VALIDATION_ERROR_07c003ea~^~N~^~Unknown~^~VkDrawIndirectCommand~^~VUID-VkDrawIndirectCommand-firstInstance-00501~^~core~^~The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndirectCommand-firstInstance-00501)~^~ -VALIDATION_ERROR_07e09005~^~Y~^~Unknown~^~VkEventCreateInfo~^~VUID-VkEventCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_07e1c40d~^~Y~^~Unknown~^~VkEventCreateInfo~^~VUID-VkEventCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_07e2b00b~^~Y~^~Unknown~^~VkEventCreateInfo~^~VUID-VkEventCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_08000520~^~N~^~Unknown~^~VkExportMemoryAllocateInfo~^~VUID-VkExportMemoryAllocateInfo-handleTypes-00656~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfo-handleTypes-00656)~^~ -VALIDATION_ERROR_08009e01~^~N~^~Unknown~^~VkExportMemoryAllocateInfo~^~VUID-VkExportMemoryAllocateInfo-handleTypes-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfo-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_0802b00b~^~N~^~Unknown~^~VkExportMemoryAllocateInfo~^~VUID-VkExportMemoryAllocateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_08209e01~^~N~^~Unknown~^~VkExportMemoryAllocateInfoNV~^~VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter~^~(VK_NV_external_memory)~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_0822b00b~^~N~^~Unknown~^~VkExportMemoryAllocateInfoNV~^~VUID-VkExportMemoryAllocateInfoNV-sType-sType~^~(VK_NV_external_memory)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_08400522~^~N~^~Unknown~^~VkExportMemoryWin32HandleInfoKHR~^~VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If VkExportMemoryAllocateInfo::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, VkExportMemoryWin32HandleInfoKHR must not be in the pNext chain of VkMemoryAllocateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657)~^~ -VALIDATION_ERROR_0840f401~^~N~^~Unknown~^~VkExportMemoryWin32HandleInfoKHR~^~VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter)~^~implicit -VALIDATION_ERROR_0842b00b~^~N~^~Unknown~^~VkExportMemoryWin32HandleInfoKHR~^~VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0860f401~^~N~^~Unknown~^~VkExportMemoryWin32HandleInfoNV~^~VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter)~^~implicit -VALIDATION_ERROR_0862b00b~^~N~^~Unknown~^~VkExportMemoryWin32HandleInfoNV~^~VUID-VkExportMemoryWin32HandleInfoNV-sType-sType~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_088008c8~^~N~^~Unknown~^~VkExportSemaphoreCreateInfo~^~VUID-VkExportSemaphoreCreateInfo-handleTypes-01124~^~(VK_VERSION_1_1,VK_KHR_external_semaphore)~^~The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphoreProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreCreateInfo-handleTypes-01124)~^~ -VALIDATION_ERROR_08809e01~^~N~^~Unknown~^~VkExportSemaphoreCreateInfo~^~VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter~^~(VK_VERSION_1_1,VK_KHR_external_semaphore)~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_0882b00b~^~N~^~Unknown~^~VkExportSemaphoreCreateInfo~^~VUID-VkExportSemaphoreCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_semaphore)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_08a008ca~^~N~^~Unknown~^~VkExportSemaphoreWin32HandleInfoKHR~^~VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If VkExportSemaphoreCreateInfo::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, VkExportSemaphoreWin32HandleInfoKHR must not be in the pNext chain of VkSemaphoreCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125)~^~ -VALIDATION_ERROR_08a0f401~^~N~^~Unknown~^~VkExportSemaphoreWin32HandleInfoKHR~^~VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter)~^~implicit -VALIDATION_ERROR_08a2b00b~^~N~^~Unknown~^~VkExportSemaphoreWin32HandleInfoKHR~^~VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_08c09e01~^~N~^~Unknown~^~VkExternalMemoryBufferCreateInfo~^~VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_08c2b00b~^~N~^~Unknown~^~VkExternalMemoryBufferCreateInfo~^~VUID-VkExternalMemoryBufferCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_08e09e01~^~N~^~Unknown~^~VkExternalMemoryImageCreateInfo~^~VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_08e09e03~^~N~^~Unknown~^~VkExternalMemoryImageCreateInfo~^~VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'handleTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask)~^~implicit -VALIDATION_ERROR_08e2b00b~^~N~^~Unknown~^~VkExternalMemoryImageCreateInfo~^~VUID-VkExternalMemoryImageCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_09009e01~^~N~^~Unknown~^~VkExternalMemoryImageCreateInfoNV~^~VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter~^~(VK_NV_external_memory)~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_0902b00b~^~N~^~Unknown~^~VkExternalMemoryImageCreateInfoNV~^~VUID-VkExternalMemoryImageCreateInfoNV-sType-sType~^~(VK_NV_external_memory)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_09209001~^~Y~^~Unknown~^~VkFenceCreateInfo~^~VUID-VkFenceCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkFenceCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0921c40d~^~Y~^~Unknown~^~VkFenceCreateInfo~^~VUID-VkFenceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportFenceCreateInfo or VkExportFenceWin32HandleInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0922b00b~^~Y~^~Unknown~^~VkFenceCreateInfo~^~VUID-VkFenceCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0922b00f~^~N~^~None~^~VkFenceCreateInfo~^~VUID-VkFenceCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_09400009~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-commonparent~^~core~^~The spec valid usage text states 'Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-commonparent)~^~implicit -VALIDATION_ERROR_094006d8~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-attachmentCount-00876~^~core~^~The spec valid usage text states 'attachmentCount must be equal to the attachment count specified in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-attachmentCount-00876)~^~ -VALIDATION_ERROR_094006da~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00877~^~core~^~The spec valid usage text states 'Each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00877)~^~ -VALIDATION_ERROR_094006dc~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00878~^~core~^~The spec valid usage text states 'Each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00878)~^~ -VALIDATION_ERROR_094006de~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00879~^~core~^~The spec valid usage text states 'Each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00879)~^~ -VALIDATION_ERROR_094006e0~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00880~^~core~^~The spec valid usage text states 'Each element of pAttachments must have been created with an VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00880)~^~ -VALIDATION_ERROR_094006e2~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00881~^~core~^~The spec valid usage text states 'Each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00881)~^~ -VALIDATION_ERROR_094006e4~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00882~^~core~^~The spec valid usage text states 'Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00882)~^~ -VALIDATION_ERROR_094006e6~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00883~^~core~^~The spec valid usage text states 'Each element of pAttachments must only specify a single mip level' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00883)~^~ -VALIDATION_ERROR_094006e8~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00884~^~core~^~The spec valid usage text states 'Each element of pAttachments must have been created with the identity swizzle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00884)~^~ -VALIDATION_ERROR_094006ea~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-width-00885~^~core~^~The spec valid usage text states 'width must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-width-00885)~^~ -VALIDATION_ERROR_094006ec~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-width-00886~^~core~^~The spec valid usage text states 'width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-width-00886)~^~ -VALIDATION_ERROR_094006ee~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-height-00887~^~core~^~The spec valid usage text states 'height must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-height-00887)~^~ -VALIDATION_ERROR_094006f0~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-height-00888~^~core~^~The spec valid usage text states 'height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-height-00888)~^~ -VALIDATION_ERROR_094006f2~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-layers-00889~^~core~^~The spec valid usage text states 'layers must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-layers-00889)~^~ -VALIDATION_ERROR_094006f4~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-layers-00890~^~core~^~The spec valid usage text states 'layers must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-layers-00890)~^~ -VALIDATION_ERROR_094006f6~^~N~^~Unknown~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-00891~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'Each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00891)~^~ -VALIDATION_ERROR_09409005~^~Y~^~Unknown~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0940f201~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pAttachments-parameter~^~core~^~The spec valid usage text states 'If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-parameter)~^~implicit -VALIDATION_ERROR_0941c40d~^~Y~^~Unknown~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0942ae01~^~Y~^~FramebufferCreateErrors~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-renderPass-parameter~^~core~^~The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-renderPass-parameter)~^~implicit -VALIDATION_ERROR_0942b00b~^~Y~^~Unknown~^~VkFramebufferCreateInfo~^~VUID-VkFramebufferCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_09600009~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-commonparent~^~core~^~The spec valid usage text states 'Each of basePipelineHandle, layout, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-commonparent)~^~implicit -VALIDATION_ERROR_096005a4~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-flags-00722~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00722)~^~ -VALIDATION_ERROR_096005a6~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-flags-00723~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command's pCreateInfos parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00723)~^~ -VALIDATION_ERROR_096005a8~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-flags-00724~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00724)~^~ -VALIDATION_ERROR_096005aa~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-flags-00725~^~core~^~The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00725)~^~ -VALIDATION_ERROR_096005ac~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-stage-00726~^~core~^~The spec valid usage text states 'The stage member of each element of pStages must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-00726)~^~ -VALIDATION_ERROR_096005ae~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-stage-00727~^~core~^~The spec valid usage text states 'The stage member of one element of pStages must be VK_SHADER_STAGE_VERTEX_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-00727)~^~ -VALIDATION_ERROR_096005b0~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-stage-00728~^~core~^~The spec valid usage text states 'The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-00728)~^~ -VALIDATION_ERROR_096005b2~^~Y~^~CreatePipelineTessErrors~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00729~^~core~^~The spec valid usage text states 'If pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00729)~^~ -VALIDATION_ERROR_096005b4~^~Y~^~CreatePipelineTessErrors~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00730~^~core~^~The spec valid usage text states 'If pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00730)~^~ -VALIDATION_ERROR_096005b6~^~Y~^~CreatePipelineTessErrors~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00731~^~core~^~The spec valid usage text states 'If pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pTessellationState must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00731)~^~ -VALIDATION_ERROR_096005b8~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00732~^~core~^~The spec valid usage text states 'If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00732)~^~ -VALIDATION_ERROR_096005ba~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00733~^~core~^~The spec valid usage text states 'If pStages includes tessellation shader stages, and the shader code of both stages contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline, they must both specify the same subdivision mode' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00733)~^~ -VALIDATION_ERROR_096005bc~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00734~^~core~^~The spec valid usage text states 'If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the output patch size in the pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00734)~^~ -VALIDATION_ERROR_096005be~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00735~^~core~^~The spec valid usage text states 'If pStages includes tessellation shader stages, and the shader code of both contain an OpExecutionMode instruction that specifies the out patch size in the pipeline, they must both specify the same patch size' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00735)~^~ -VALIDATION_ERROR_096005c0~^~Y~^~CreatePipelineTessErrors~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00736~^~core~^~The spec valid usage text states 'If pStages includes tessellation shader stages, the topology member of pInputAssembly must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00736)~^~ -VALIDATION_ERROR_096005c2~^~Y~^~CreatePipelineTessErrors~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-topology-00737~^~core~^~The spec valid usage text states 'If the topology member of pInputAssembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, pStages must include tessellation shader stages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-topology-00737)~^~ -VALIDATION_ERROR_096005c4~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00738~^~core~^~The spec valid usage text states 'If pStages includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology specified in pInputAssembly' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00738)~^~ -VALIDATION_ERROR_096005c6~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00739~^~core~^~The spec valid usage text states 'If pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology that is output by the tessellation stages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00739)~^~ -VALIDATION_ERROR_096005c8~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00740~^~core~^~The spec valid usage text states 'If pStages includes a fragment shader stage and a geometry shader stage, and the fragment shader code reads from an input variable that is decorated with PrimitiveID, then the geometry shader code must write to a matching output variable, decorated with PrimitiveID, in all execution paths' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00740)~^~ -VALIDATION_ERROR_096005ca~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00741~^~core~^~The spec valid usage text states 'If pStages includes a fragment shader stage, its shader code must not read from any input attachment that is defined as VK_ATTACHMENT_UNUSED in subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00741)~^~ -VALIDATION_ERROR_096005cc~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-00742~^~core~^~The spec valid usage text states 'The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00742)~^~ -VALIDATION_ERROR_096005ce~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-00743~^~!(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00743)~^~ -VALIDATION_ERROR_096005d0~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-00744~^~!(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00744)~^~ -VALIDATION_ERROR_096005d2~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-00745~^~core~^~The spec valid usage text states 'If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the blendEnable member of the corresponding element of the pAttachment member of pColorBlendState must be VK_FALSE if the format of the attachment does not support color blend operations, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00745)~^~ -VALIDATION_ERROR_096005d4~^~Y~^~NumBlendAttachMismatch~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746~^~core~^~The spec valid usage text states 'If rasterization is not disabled and the subpass uses color attachments, the attachmentCount member of pColorBlendState must be equal to the colorAttachmentCount used to create subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746)~^~ -VALIDATION_ERROR_096005d6~^~Y~^~PSOViewportStateTests,PSOViewportStateMultiViewportTests~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747~^~core~^~The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState::viewportCount VkViewport structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747)~^~ -VALIDATION_ERROR_096005d8~^~Y~^~PSOViewportStateTests,PSOViewportStateMultiViewportTests~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748~^~core~^~The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState::scissorCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748)~^~ -VALIDATION_ERROR_096005da~^~Y~^~PSOLineWidthInvalid~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749~^~core~^~The spec valid usage text states 'If the wide lines feature is not enabled, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_WIDTH, the lineWidth member of pRasterizationState must be 1.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749)~^~ -VALIDATION_ERROR_096005dc~^~Y~^~PSOViewportStateTests~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750~^~core~^~The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750)~^~ -VALIDATION_ERROR_096005de~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751~^~core~^~The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751)~^~ -VALIDATION_ERROR_096005e0~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752~^~core~^~The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses a depth/stencil attachment, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752)~^~ -VALIDATION_ERROR_096005e2~^~Y~^~PipelineRenderpassCompatibility~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753~^~core~^~The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753)~^~ -VALIDATION_ERROR_096005e4~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754~^~core~^~The spec valid usage text states 'If the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754)~^~ -VALIDATION_ERROR_096005e6~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755~^~(VK_EXT_depth_range_unrestricted)~^~The spec valid usage text states 'If the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755)~^~ -VALIDATION_ERROR_096005e8~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-layout-00756~^~core~^~The spec valid usage text states 'layout must be consistent with all shaders specified in pStages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-00756)~^~ -VALIDATION_ERROR_096005ea~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-00757~^~!(VK_AMD_mixed_attachment_samples)+!(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must be the same as the sample count for those subpass attachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00757)~^~ -VALIDATION_ERROR_096005ec~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-00758~^~core~^~The spec valid usage text states 'If subpass does not use any color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must follow the rules for a zero-attachment subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00758)~^~ -VALIDATION_ERROR_096005ee~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-00759~^~core~^~The spec valid usage text states 'subpass must be a valid subpass within renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00759)~^~ -VALIDATION_ERROR_096005f0~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-renderPass-00760~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewTessellationShader is not enabled, then pStages must not include tessellation shaders.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00760)~^~ -VALIDATION_ERROR_096005f2~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-renderPass-00761~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewGeometryShader is not enabled, then pStages must not include a geometry shader.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00761)~^~ -VALIDATION_ERROR_096005f4~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-renderPass-00762~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the renderPass has multiview enabled and subpass has more than one bit set in the view mask, shaders in the pipeline must not write to the Layer built-in output' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00762)~^~ -VALIDATION_ERROR_096005f6~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-renderPass-00763~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the renderPass has multiview enabled, then all shaders must not include variables decorated with the Layer built-in decoration in their interfaces.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00763)~^~ -VALIDATION_ERROR_096005f8~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-flags-00764~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00764)~^~ -VALIDATION_ERROR_09600b06~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-01411~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'If subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the rasterizationSamples member of pMultisampleState must be the same as the sample count of the depth/stencil attachment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01411)~^~ -VALIDATION_ERROR_09600b08~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-01412~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'If subpass has any color attachments, then the rasterizationSamples member of pMultisampleState must be greater than or equal to the sample count for those subpass attachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01412)~^~ -VALIDATION_ERROR_09600bc2~^~Y~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-01505~^~(VK_AMD_mixed_attachment_samples)~^~The spec valid usage text states 'If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must equal the maximum of the sample counts of those subpass attachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01505)~^~ -VALIDATION_ERROR_09600be2~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.width must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.width as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521)~^~ -VALIDATION_ERROR_09600be4~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.height must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.height as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522)~^~ -VALIDATION_ERROR_09600be6~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523)~^~ -VALIDATION_ERROR_09600be8~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524)~^~ -VALIDATION_ERROR_09600c3a~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-01565~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If pStages includes a fragment shader stage and an input attachment was referenced by the VkRenderPassInputAttachmentAspectCreateInfo at renderPass create time, its shader code must not read from any aspect that was not specified in the aspectMask of the corresponding VkInputAttachmentAspectReference structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-01565)~^~ -VALIDATION_ERROR_09600d30~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-layout-01688~^~core~^~The spec valid usage text states 'The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-01688)~^~ -VALIDATION_ERROR_09600d66~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, chained to the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715)~^~ -VALIDATION_ERROR_09600db8~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-01756~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01756)~^~ -VALIDATION_ERROR_09600dba~^~N~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-subpass-01757~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01757)~^~ -VALIDATION_ERROR_09609001~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkPipelineCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0960be01~^~Y~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-layout-parameter~^~core~^~The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-parameter)~^~implicit -VALIDATION_ERROR_09615601~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter~^~core~^~The spec valid usage text states 'If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter)~^~implicit -VALIDATION_ERROR_09619801~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter~^~core~^~The spec valid usage text states 'pInputAssemblyState must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter)~^~implicit -VALIDATION_ERROR_0961c40d~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_09620801~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter~^~core~^~The spec valid usage text states 'pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter)~^~implicit -VALIDATION_ERROR_09623e01~^~Y~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pStages-parameter~^~core~^~The spec valid usage text states 'pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-parameter)~^~implicit -VALIDATION_ERROR_09626801~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter~^~core~^~The spec valid usage text states 'pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter)~^~implicit -VALIDATION_ERROR_0962ae01~^~Y~^~None~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter~^~core~^~The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter)~^~implicit -VALIDATION_ERROR_0962b00b~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0962da1b~^~N~^~Unknown~^~VkGraphicsPipelineCreateInfo~^~VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength~^~core~^~The spec valid usage text states 'stageCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength)~^~implicit -VALIDATION_ERROR_09800a48~^~N~^~Unknown~^~VkIOSSurfaceCreateInfoMVK~^~VUID-VkIOSSurfaceCreateInfoMVK-pView-01316~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'pView must be a valid UIView and must be backed by a CALayer instance of type CAMetalLayer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-pView-01316)~^~ -VALIDATION_ERROR_09809005~^~Y~^~Unknown~^~VkIOSSurfaceCreateInfoMVK~^~VUID-VkIOSSurfaceCreateInfoMVK-flags-zerobitmask~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_0981c40d~^~Y~^~Unknown~^~VkIOSSurfaceCreateInfoMVK~^~VUID-VkIOSSurfaceCreateInfoMVK-pNext-pNext~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-pNext-pNext)~^~implicit -VALIDATION_ERROR_0982b00b~^~Y~^~Unknown~^~VkIOSSurfaceCreateInfoMVK~^~VUID-VkIOSSurfaceCreateInfoMVK-sType-sType~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-sType-sType)~^~implicit -VALIDATION_ERROR_09a001dc~^~Y~^~Unknown~^~VkImageBlit~^~VUID-VkImageBlit-aspectMask-00238~^~core~^~The spec valid usage text states 'The aspectMask member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-aspectMask-00238)~^~ -VALIDATION_ERROR_09a001de~^~Y~^~Unknown~^~VkImageBlit~^~VUID-VkImageBlit-layerCount-00239~^~core~^~The spec valid usage text states 'The layerCount member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-layerCount-00239)~^~ -VALIDATION_ERROR_09a001e0~^~Y~^~MiscBlitImageTests~^~VkImageBlit~^~VUID-VkImageBlit-srcImage-00240~^~core~^~The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcImage-00240)~^~ -VALIDATION_ERROR_09a001e2~^~Y~^~MiscBlitImageTests~^~VkImageBlit~^~VUID-VkImageBlit-aspectMask-00241~^~core~^~The spec valid usage text states 'The aspectMask member of srcSubresource must specify aspects present in the calling command's srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-aspectMask-00241)~^~ -VALIDATION_ERROR_09a001e4~^~Y~^~MiscBlitImageTests~^~VkImageBlit~^~VUID-VkImageBlit-aspectMask-00242~^~core~^~The spec valid usage text states 'The aspectMask member of dstSubresource must specify aspects present in the calling command's dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-aspectMask-00242)~^~ -VALIDATION_ERROR_09a001e6~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-srcOffset-00243~^~core~^~The spec valid usage text states 'srcOffset[0].x and srcOffset[1].x must both be greater than or equal to 0 and less than or equal to the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcOffset-00243)~^~ -VALIDATION_ERROR_09a001e8~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-srcOffset-00244~^~core~^~The spec valid usage text states 'srcOffset[0].y and srcOffset[1].y must both be greater than or equal to 0 and less than or equal to the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcOffset-00244)~^~ -VALIDATION_ERROR_09a001ea~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-srcImage-00245~^~core~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset[0].y must be 0 and srcOffset[1].y must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcImage-00245)~^~ -VALIDATION_ERROR_09a001ec~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-srcOffset-00246~^~core~^~The spec valid usage text states 'srcOffset[0].z and srcOffset[1].z must both be greater than or equal to 0 and less than or equal to the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcOffset-00246)~^~ -VALIDATION_ERROR_09a001ee~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-srcImage-00247~^~core~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset[0].z must be 0 and srcOffset[1].z must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcImage-00247)~^~ -VALIDATION_ERROR_09a001f0~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-dstOffset-00248~^~core~^~The spec valid usage text states 'dstOffset[0].x and dstOffset[1].x must both be greater than or equal to 0 and less than or equal to the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstOffset-00248)~^~ -VALIDATION_ERROR_09a001f2~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-dstOffset-00249~^~core~^~The spec valid usage text states 'dstOffset[0].y and dstOffset[1].y must both be greater than or equal to 0 and less than or equal to the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstOffset-00249)~^~ -VALIDATION_ERROR_09a001f4~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-dstImage-00250~^~core~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset[0].y must be 0 and dstOffset[1].y must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstImage-00250)~^~ -VALIDATION_ERROR_09a001f6~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-dstOffset-00251~^~core~^~The spec valid usage text states 'dstOffset[0].z and dstOffset[1].z must both be greater than or equal to 0 and less than or equal to the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstOffset-00251)~^~ -VALIDATION_ERROR_09a001f8~^~Y~^~BlitImageOffsets~^~VkImageBlit~^~VUID-VkImageBlit-dstImage-00252~^~core~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset[0].z must be 0 and dstOffset[1].z must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstImage-00252)~^~ -VALIDATION_ERROR_09a07a01~^~N~^~Unknown~^~VkImageBlit~^~VUID-VkImageBlit-dstSubresource-parameter~^~core~^~The spec valid usage text states 'dstSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstSubresource-parameter)~^~implicit -VALIDATION_ERROR_09a2d601~^~N~^~Unknown~^~VkImageBlit~^~VUID-VkImageBlit-srcSubresource-parameter~^~core~^~The spec valid usage text states 'srcSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcSubresource-parameter)~^~implicit -VALIDATION_ERROR_09c00112~^~Y~^~CopyImageAspectMismatch~^~VkImageCopy~^~VUID-VkImageCopy-aspectMask-00137~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'The aspectMask member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-aspectMask-00137)~^~ -VALIDATION_ERROR_09c00114~^~N~^~None~^~VkImageCopy~^~VUID-VkImageCopy-layerCount-00138~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'The layerCount member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-layerCount-00138)~^~ -VALIDATION_ERROR_09c00116~^~N~^~None~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-00139~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-00139)~^~ -VALIDATION_ERROR_09c00118~^~Y~^~CopyImageLayerCountMismatch~^~VkImageCopy~^~VUID-VkImageCopy-extent-00140~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'The number of slices of the extent (for 3D) or layers of the srcSubresource (for non-3D) must match the number of slices of the extent (for 3D) or layers of the dstSubresource (for non-3D)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-extent-00140)~^~ -VALIDATION_ERROR_09c0011a~^~Y~^~CopyImageTypeExtentMismatch~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-00141~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of the corresponding subresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-00141)~^~ -VALIDATION_ERROR_09c0011c~^~Y~^~CopyImageAspectMismatch~^~VkImageCopy~^~VUID-VkImageCopy-aspectMask-00142~^~core~^~The spec valid usage text states 'The aspectMask member of srcSubresource must specify aspects present in the calling command's srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-aspectMask-00142)~^~ -VALIDATION_ERROR_09c0011e~^~Y~^~CopyImageAspectMismatch~^~VkImageCopy~^~VUID-VkImageCopy-aspectMask-00143~^~core~^~The spec valid usage text states 'The aspectMask member of dstSubresource must specify aspects present in the calling command's dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-aspectMask-00143)~^~ -VALIDATION_ERROR_09c00120~^~Y~^~CopyImageSrcSizeExceeded~^~VkImageCopy~^~VUID-VkImageCopy-srcOffset-00144~^~core~^~The spec valid usage text states 'srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00144)~^~ -VALIDATION_ERROR_09c00122~^~Y~^~CopyImageSrcSizeExceeded~^~VkImageCopy~^~VUID-VkImageCopy-srcOffset-00145~^~core~^~The spec valid usage text states 'srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00145)~^~ -VALIDATION_ERROR_09c00124~^~Y~^~CopyImageTypeExtentMismatch~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-00146~^~core~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-00146)~^~ -VALIDATION_ERROR_09c00126~^~Y~^~CopyImageSrcSizeExceeded~^~VkImageCopy~^~VUID-VkImageCopy-srcOffset-00147~^~core~^~The spec valid usage text states 'srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00147)~^~ -VALIDATION_ERROR_09c0012c~^~Y~^~CopyImageDstSizeExceeded~^~VkImageCopy~^~VUID-VkImageCopy-dstOffset-00150~^~core~^~The spec valid usage text states 'dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00150)~^~ -VALIDATION_ERROR_09c0012e~^~Y~^~CopyImageDstSizeExceeded~^~VkImageCopy~^~VUID-VkImageCopy-dstOffset-00151~^~core~^~The spec valid usage text states 'dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00151)~^~ -VALIDATION_ERROR_09c00130~^~Y~^~CopyImageTypeExtentMismatch~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-00152~^~core~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstImage-00152)~^~ -VALIDATION_ERROR_09c00132~^~Y~^~CopyImageDstSizeExceeded~^~VkImageCopy~^~VUID-VkImageCopy-dstOffset-00153~^~core~^~The spec valid usage text states 'dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00153)~^~ -VALIDATION_ERROR_09c0013a~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-srcOffset-00157~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00157)~^~ -VALIDATION_ERROR_09c0013c~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-extent-00158~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00158)~^~ -VALIDATION_ERROR_09c0013e~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-extent-00159~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00159)~^~ -VALIDATION_ERROR_09c00140~^~Y~^~NotTestable~^~VkImageCopy~^~VUID-VkImageCopy-extent-00160~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00160)~^~ -VALIDATION_ERROR_09c00144~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-dstOffset-00162~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00162)~^~ -VALIDATION_ERROR_09c00146~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-extent-00163~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00163)~^~ -VALIDATION_ERROR_09c00148~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-extent-00164~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00164)~^~ -VALIDATION_ERROR_09c0014a~^~Y~^~NotTestable~^~VkImageCopy~^~VUID-VkImageCopy-extent-00165~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00165)~^~ -VALIDATION_ERROR_09c00c1e~^~Y~^~CopyImageAspectMismatch~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01551~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If neither the calling command's srcImage nor the calling command's dstImage has a multi-planar image format then the aspectMask member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01551)~^~ -VALIDATION_ERROR_09c00c20~^~Y~^~CopyImageMultiplaneAspectBits~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01552~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage has a VkFormat with two planes then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01552)~^~ -VALIDATION_ERROR_09c00c22~^~Y~^~CopyImageMultiplaneAspectBits~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01553~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage has a VkFormat with three planes then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01553)~^~ -VALIDATION_ERROR_09c00c24~^~Y~^~CopyImageMultiplaneAspectBits~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01554~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage has a VkFormat with two planes then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01554)~^~ -VALIDATION_ERROR_09c00c26~^~Y~^~CopyImageMultiplaneAspectBits~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01555~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage has a VkFormat with three planes then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01555)~^~ -VALIDATION_ERROR_09c00c28~^~Y~^~CopyImageMultiplaneAspectBits~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01556~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage has a multi-planar image format and the dstImage does not have a multi-planar image format, the dstSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01556)~^~ -VALIDATION_ERROR_09c00c2a~^~Y~^~CopyImageMultiplaneAspectBits~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01557~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage has a multi-planar image format and the srcImage does not have a multi-planar image format, the srcSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01557)~^~ -VALIDATION_ERROR_09c00d7e~^~Y~^~CopyImageSinglePlane422Alignment,CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01727~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, "_422" image format, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01727)~^~ -VALIDATION_ERROR_09c00d80~^~Y~^~CopyImageSinglePlane422Alignment,CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01728~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, "_422" image format, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01728)~^~ -VALIDATION_ERROR_09c00d82~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01729~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, "_422" image format, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01729)~^~ -VALIDATION_ERROR_09c00d84~^~Y~^~NotTestable~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01730~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, "_422" image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01730)~^~ -VALIDATION_ERROR_09c00d86~^~Y~^~CopyImageSinglePlane422Alignment,CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01731~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, "_422" image format, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01731)~^~ -VALIDATION_ERROR_09c00d88~^~Y~^~CopyImageSinglePlane422Alignment,CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01732~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, "_422" image format, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01732)~^~ -VALIDATION_ERROR_09c00d8a~^~Y~^~CopyImageCompressedBlockAlignment~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01733~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, "_422" image format, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01733)~^~ -VALIDATION_ERROR_09c00d8c~^~Y~^~NotTestable~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01734~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, "_422" image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01734)~^~ -VALIDATION_ERROR_09c00df2~^~Y~^~CopyImageTypeExtentMismatch~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01785~^~core~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-01785)~^~ -VALIDATION_ERROR_09c00df4~^~Y~^~CopyImageTypeExtentMismatch~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01786~^~core~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstImage-01786)~^~ -VALIDATION_ERROR_09c00df6~^~Y~^~CopyImageTypeExtentMismatch~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01787~^~core~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_2D, then srcOffset.z must be 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-01787)~^~ -VALIDATION_ERROR_09c00df8~^~Y~^~CopyImageTypeExtentMismatch~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01788~^~core~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_2D, then dstOffset.z must be 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstImage-01788)~^~ -VALIDATION_ERROR_09c00dfa~^~N~^~None~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01789~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If the calling command's srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-01789)~^~ -VALIDATION_ERROR_09c00dfc~^~N~^~None~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01790~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If both srcImage and dstImage are of type VK_IMAGE_TYPE_2D then then extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01790)~^~ -VALIDATION_ERROR_09c00dfe~^~N~^~None~^~VkImageCopy~^~VUID-VkImageCopy-srcImage-01791~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_2D, and the dstImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of srcSubresource.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01791)~^~ -VALIDATION_ERROR_09c00e00~^~N~^~None~^~VkImageCopy~^~VUID-VkImageCopy-dstImage-01792~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_2D, and the srcImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of dstSubresource.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01792)~^~ -VALIDATION_ERROR_09c07a01~^~N~^~Unknown~^~VkImageCopy~^~VUID-VkImageCopy-dstSubresource-parameter~^~core~^~The spec valid usage text states 'dstSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstSubresource-parameter)~^~implicit -VALIDATION_ERROR_09c2d601~^~N~^~Unknown~^~VkImageCopy~^~VUID-VkImageCopy-srcSubresource-parameter~^~core~^~The spec valid usage text states 'srcSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcSubresource-parameter)~^~implicit -VALIDATION_ERROR_09e00758~^~Y~^~CreateImageFormatSupportErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-format-00940~^~!(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'The combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-00940)~^~ -VALIDATION_ERROR_09e0075a~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sharingMode-00941~^~core~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-00941)~^~ -VALIDATION_ERROR_09e0075c~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sharingMode-00942~^~core~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-00942)~^~ -VALIDATION_ERROR_09e0075e~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-format-00943~^~core~^~The spec valid usage text states 'format must not be VK_FORMAT_UNDEFINED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-00943)~^~ -VALIDATION_ERROR_09e00760~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-extent-00944~^~core~^~The spec valid usage text states 'extent::width must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00944)~^~ -VALIDATION_ERROR_09e00762~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-extent-00945~^~core~^~The spec valid usage text states 'extent::height must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00945)~^~ -VALIDATION_ERROR_09e00764~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-extent-00946~^~core~^~The spec valid usage text states 'extent::depth must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00946)~^~ -VALIDATION_ERROR_09e00766~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-mipLevels-00947~^~core~^~The spec valid usage text states 'mipLevels must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-mipLevels-00947)~^~ -VALIDATION_ERROR_09e00768~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-arrayLayers-00948~^~core~^~The spec valid usage text states 'arrayLayers must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-arrayLayers-00948)~^~ -VALIDATION_ERROR_09e0076a~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-00949~^~core~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_2D' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00949)~^~ -VALIDATION_ERROR_09e0076c~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-00950~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_3D' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00950)~^~ -VALIDATION_ERROR_09e0076e~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00951~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_1D, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension1D, or VkImageFormatProperties::maxExtent.width (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00951)~^~ -VALIDATION_ERROR_09e00770~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00952~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D and flags does not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension2D, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00952)~^~ -VALIDATION_ERROR_09e00772~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00953~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimensionCube, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00953)~^~ -VALIDATION_ERROR_09e00774~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00954~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be equal and arrayLayers must be greater than or equal to 6' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00954)~^~ -VALIDATION_ERROR_09e00776~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00955~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_3D, extent.width, extent.height and extent.depth must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension3D, or VkImageFormatProperties::maxExtent.width/height/depth (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00955)~^~ -VALIDATION_ERROR_09e00778~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00956~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00956)~^~ -VALIDATION_ERROR_09e0077a~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00957~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D, extent.depth must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00957)~^~ -VALIDATION_ERROR_09e0077c~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-mipLevels-00958~^~core~^~The spec valid usage text states 'mipLevels must be less than or equal to {lfloor}log2(max(extent.width, extent.height, extent.depth)){rfloor} + 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-mipLevels-00958)~^~ -VALIDATION_ERROR_09e0077e~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-extent-00959~^~core~^~The spec valid usage text states 'mipLevels must be less than or equal to VkImageFormatProperties::maxMipLevels (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00959)~^~ -VALIDATION_ERROR_09e00780~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-arrayLayers-00960~^~core~^~The spec valid usage text states 'arrayLayers must be less than or equal to VkImageFormatProperties::maxArrayLayers (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-arrayLayers-00960)~^~ -VALIDATION_ERROR_09e00782~^~Y~^~CreateImageMinLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00961~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_3D, arrayLayers must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00961)~^~ -VALIDATION_ERROR_09e00784~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-samples-00962~^~core~^~The spec valid usage text states 'If samples is not VK_SAMPLE_COUNT_1_BIT, imageType must be VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, tiling must be VK_IMAGE_TILING_OPTIMAL, and mipLevels must be equal to 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-00962)~^~ -VALIDATION_ERROR_09e00786~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-usage-00963~^~core~^~The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, then bits other than VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT must not be set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00963)~^~ -VALIDATION_ERROR_09e00788~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-usage-00964~^~core~^~The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00964)~^~ -VALIDATION_ERROR_09e0078a~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-usage-00965~^~core~^~The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00965)~^~ -VALIDATION_ERROR_09e0078c~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-usage-00966~^~core~^~The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, usage must also contain at least one of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00966)~^~ -VALIDATION_ERROR_09e0078e~^~Y~^~CreateImageMaxLimitsViolation~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-samples-00967~^~core~^~The spec valid usage text states 'samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-00967)~^~ -VALIDATION_ERROR_09e00790~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-usage-00968~^~core~^~The spec valid usage text states 'If the multisampled storage images feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00968)~^~ -VALIDATION_ERROR_09e00792~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-00969~^~core~^~The spec valid usage text states 'If the sparse bindings feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00969)~^~ -VALIDATION_ERROR_09e00794~^~Y~^~SparseResidencyImageCreateUnsupportedTypes~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00970~^~core~^~The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00970)~^~ -VALIDATION_ERROR_09e00796~^~Y~^~SparseResidencyImageCreateUnsupportedTypes~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00971~^~core~^~The spec valid usage text states 'If the sparse residency for 2D images feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00971)~^~ -VALIDATION_ERROR_09e00798~^~Y~^~SparseResidencyImageCreateUnsupportedTypes~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00972~^~core~^~The spec valid usage text states 'If the sparse residency for 3D images feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00972)~^~ -VALIDATION_ERROR_09e0079a~^~Y~^~SparseResidencyImageCreateUnsupportedSamples~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00973~^~core~^~The spec valid usage text states 'If the sparse residency for images with 2 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00973)~^~ -VALIDATION_ERROR_09e0079c~^~Y~^~SparseResidencyImageCreateUnsupportedSamples~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00974~^~core~^~The spec valid usage text states 'If the sparse residency for images with 4 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00974)~^~ -VALIDATION_ERROR_09e0079e~^~Y~^~SparseResidencyImageCreateUnsupportedSamples~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00975~^~core~^~The spec valid usage text states 'If the sparse residency for images with 8 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00975)~^~ -VALIDATION_ERROR_09e007a0~^~Y~^~SparseResidencyImageCreateUnsupportedSamples~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-00976~^~core~^~The spec valid usage text states 'If the sparse residency for images with 16 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00976)~^~ -VALIDATION_ERROR_09e007b6~^~Y~^~SparseBindingImageBufferCreate~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-00987~^~core~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00987)~^~ -VALIDATION_ERROR_09e007b8~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-00988~^~(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_NV_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00988)~^~ -VALIDATION_ERROR_09e007bc~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-00990~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfo, its handleTypes member must only contain bits that are also in VkExternalImageFormatProperties::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2 with format, imageType, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfo in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfo::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00990)~^~ -VALIDATION_ERROR_09e007be~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-00991~^~(VK_NV_external_memory+VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, imageType, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00991)~^~ -VALIDATION_ERROR_09e007c0~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-00992~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00992)~^~ -VALIDATION_ERROR_09e007c2~^~Y~^~CreateImageMiscErrors~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-initialLayout-00993~^~core~^~The spec valid usage text states 'initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-00993)~^~ -VALIDATION_ERROR_09e00ae0~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sharingMode-01392~^~!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01392)~^~ -VALIDATION_ERROR_09e00b18~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sharingMode-01420~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01420)~^~ -VALIDATION_ERROR_09e00b1a~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-physicalDeviceCount-01421~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-physicalDeviceCount-01421)~^~ -VALIDATION_ERROR_09e00b46~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-01443~^~(VK_VERSION_1_1,VK_KHR_external_memory,VK_NV_external_memory)~^~The spec valid usage text states 'If the pNext chain includes a ifdef::VK_VERSION_1_1,VK_KHR_external_memory[VkExternalMemoryImageCreateInfo]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01443)~^~ -VALIDATION_ERROR_09e00bfa~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-01533~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT format must be a depth or depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01533)~^~ -VALIDATION_ERROR_09e00c48~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-01572~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then format must be a block-compressed image format, an ETC compressed image format, or an ASTC compressed image format.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01572)~^~ -VALIDATION_ERROR_09e00c4a~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-01573~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01573)~^~ -VALIDATION_ERROR_09e00c4c~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-format-01574~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the image format is one of those listed in features-formats-requiring-sampler-ycbcr-conversion:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-format-01574)~^~ -VALIDATION_ERROR_09e00c4e~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-tiling-01575~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If tiling is VK_IMAGE_TILING_OPTIMAL, format is a multi-planar format, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-tiling-01575)~^~ -VALIDATION_ERROR_09e00c50~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-tiling-01576~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If tiling is VK_IMAGE_TILING_LINEAR, format is a multi-planar format, and VkFormatProperties::linearTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-tiling-01576)~^~ -VALIDATION_ERROR_09e00c52~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-format-01577~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If format is not a multi-planar format, and flags does not include VK_IMAGE_CREATE_ALIAS_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-format-01577)~^~ -VALIDATION_ERROR_09e00ec2~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-01889~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the pNext chain doesn't contain an instance of VkExternalFormatANDROID, or if format is not VK_FORMAT_UNDEFINED, the combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01889)~^~ -VALIDATION_ERROR_09e00ec4~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-01890~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If the protected memory feature is not enabled, flags must not contain VK_IMAGE_CREATE_PROTECTED_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01890)~^~ -VALIDATION_ERROR_09e00ec6~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-None-01891~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_CREATE_PROTECTED_BIT must not also be set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-None-01891)~^~ -VALIDATION_ERROR_09e00ec8~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-01892~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01892)~^~ -VALIDATION_ERROR_09e00eca~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-01893~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01893)~^~ -VALIDATION_ERROR_09e00f08~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-01924~^~core~^~The spec valid usage text states 'If the sparse aliased residency feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-01924)~^~ -VALIDATION_ERROR_09e00f0a~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-None-01925~^~core~^~The spec valid usage text states 'If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-None-01925)~^~ -VALIDATION_ERROR_09e09001~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_09e09201~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-parameter)~^~implicit -VALIDATION_ERROR_09e0ac01~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-imageType-parameter~^~core~^~The spec valid usage text states 'imageType must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-parameter)~^~implicit -VALIDATION_ERROR_09e0b801~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-initialLayout-parameter~^~core~^~The spec valid usage text states 'initialLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-parameter)~^~implicit -VALIDATION_ERROR_09e1c40d~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageFormatListCreateInfoKHR, or VkImageSwapchainCreateInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_09e2b00b~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_09e2b00f~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_09e2b401~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-samples-parameter~^~core~^~The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-parameter)~^~implicit -VALIDATION_ERROR_09e2c001~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sharingMode-parameter~^~core~^~The spec valid usage text states 'sharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-parameter)~^~implicit -VALIDATION_ERROR_09e2fa01~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-tiling-parameter~^~core~^~The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-tiling-parameter)~^~implicit -VALIDATION_ERROR_09e30601~^~N~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-usage-parameter~^~core~^~The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-parameter)~^~implicit -VALIDATION_ERROR_09e30603~^~Y~^~Unknown~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-usage-requiredbitmask~^~core~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_0a00095a~^~Y~^~InvalidImageLayout~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01197~^~core~^~The spec valid usage text states 'oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01197)~^~ -VALIDATION_ERROR_0a00095c~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-newLayout-01198~^~core~^~The spec valid usage text states 'newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-newLayout-01198)~^~ -VALIDATION_ERROR_0a00095e~^~Y~^~InvalidBarrierQueueFamily~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01199~^~!(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01199)~^~ -VALIDATION_ERROR_0a000960~^~Y~^~InvalidBarrierQueueFamily~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01200~^~!(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see devsandqueues-queueprops).' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01200)~^~ -VALIDATION_ERROR_0a000962~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01201~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01201)~^~ -VALIDATION_ERROR_0a00096a~^~Y~^~InvalidBarrierQueueFamily~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01205~^~core~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01205)~^~ -VALIDATION_ERROR_0a00096e~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01207~^~core~^~The spec valid usage text states 'If image has a depth/stencil format with both depth and stencil components, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01207)~^~ -VALIDATION_ERROR_0a000970~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01208~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01208)~^~ -VALIDATION_ERROR_0a000972~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01209~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01209)~^~ -VALIDATION_ERROR_0a000974~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01210~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01210)~^~ -VALIDATION_ERROR_0a000976~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01211~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01211)~^~ -VALIDATION_ERROR_0a000978~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01212~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01212)~^~ -VALIDATION_ERROR_0a00097a~^~Y~^~InvalidBarriers~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01213~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01213)~^~ -VALIDATION_ERROR_0a000aca~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01381~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01381)~^~ -VALIDATION_ERROR_0a000b9c~^~Y~^~ImageBarrierWithBadRange~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-subresourceRange-01486~^~core~^~The spec valid usage text states 'subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01486)~^~ -VALIDATION_ERROR_0a000ba0~^~Y~^~ImageBarrierWithBadRange~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-subresourceRange-01488~^~core~^~The spec valid usage text states 'subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01488)~^~ -VALIDATION_ERROR_0a000cf4~^~N~^~None~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01658~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01658)~^~ -VALIDATION_ERROR_0a000cf6~^~N~^~None~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01659~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01659)~^~ -VALIDATION_ERROR_0a000d0e~^~N~^~None~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01671~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image has a single-plane color format or is not disjoint, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01671)~^~ -VALIDATION_ERROR_0a000d10~^~N~^~None~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01672~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01672)~^~ -VALIDATION_ERROR_0a000d12~^~N~^~None~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01673~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01673)~^~ -VALIDATION_ERROR_0a000d78~^~Y~^~ImageBarrierWithBadRange~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-subresourceRange-01724~^~core~^~The spec valid usage text states 'If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01724)~^~ -VALIDATION_ERROR_0a000d7a~^~Y~^~ImageBarrierWithBadRange~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-subresourceRange-01725~^~core~^~The spec valid usage text states 'If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01725)~^~ -VALIDATION_ERROR_0a000dcc~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01766~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01766)~^~ -VALIDATION_ERROR_0a000dce~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01767~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01767)~^~ -VALIDATION_ERROR_0a000dd0~^~Y~^~InvalidBarrierQueueFamilyWithMemExt~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01768~^~(VK_VERSION_1_1,VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01768)~^~ -VALIDATION_ERROR_0a000f18~^~N~^~None~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-01932~^~core~^~The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01932)~^~ -VALIDATION_ERROR_0a006801~^~Y~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-dstAccessMask-parameter~^~core~^~The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-dstAccessMask-parameter)~^~implicit -VALIDATION_ERROR_0a00a001~^~Y~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-parameter)~^~implicit -VALIDATION_ERROR_0a00d401~^~Y~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-newLayout-parameter~^~core~^~The spec valid usage text states 'newLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-newLayout-parameter)~^~implicit -VALIDATION_ERROR_0a00dc01~^~Y~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-parameter~^~core~^~The spec valid usage text states 'oldLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-parameter)~^~implicit -VALIDATION_ERROR_0a01c40d~^~Y~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0a02b00b~^~N~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0a02c401~^~Y~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-srcAccessMask-parameter~^~core~^~The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-srcAccessMask-parameter)~^~implicit -VALIDATION_ERROR_0a02ea01~^~N~^~Unknown~^~VkImageMemoryBarrier~^~VUID-VkImageMemoryBarrier-subresourceRange-parameter~^~core~^~The spec valid usage text states 'subresourceRange must be a valid VkImageSubresourceRange structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-parameter)~^~implicit -VALIDATION_ERROR_0a200214~^~Y~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-aspectMask-00266~^~core~^~The spec valid usage text states 'The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-aspectMask-00266)~^~ -VALIDATION_ERROR_0a200216~^~Y~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-layerCount-00267~^~core~^~The spec valid usage text states 'The layerCount member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-layerCount-00267)~^~ -VALIDATION_ERROR_0a200218~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-srcImage-00268~^~core~^~The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcImage-00268)~^~ -VALIDATION_ERROR_0a20021a~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-srcOffset-00269~^~core~^~The spec valid usage text states 'srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcOffset-00269)~^~ -VALIDATION_ERROR_0a20021c~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-srcOffset-00270~^~core~^~The spec valid usage text states 'srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcOffset-00270)~^~ -VALIDATION_ERROR_0a20021e~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-srcImage-00271~^~core~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcImage-00271)~^~ -VALIDATION_ERROR_0a200220~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-srcOffset-00272~^~core~^~The spec valid usage text states 'srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcOffset-00272)~^~ -VALIDATION_ERROR_0a200222~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-srcImage-00273~^~core~^~The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcImage-00273)~^~ -VALIDATION_ERROR_0a200224~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-dstOffset-00274~^~core~^~The spec valid usage text states 'dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstOffset-00274)~^~ -VALIDATION_ERROR_0a200226~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-dstOffset-00275~^~core~^~The spec valid usage text states 'dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstOffset-00275)~^~ -VALIDATION_ERROR_0a200228~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-dstImage-00276~^~core~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstImage-00276)~^~ -VALIDATION_ERROR_0a20022a~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-dstOffset-00277~^~core~^~The spec valid usage text states 'dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstOffset-00277)~^~ -VALIDATION_ERROR_0a20022c~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-dstImage-00278~^~core~^~The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstImage-00278)~^~ -VALIDATION_ERROR_0a207a01~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-dstSubresource-parameter~^~core~^~The spec valid usage text states 'dstSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstSubresource-parameter)~^~implicit -VALIDATION_ERROR_0a22d601~^~N~^~Unknown~^~VkImageResolve~^~VUID-VkImageResolve-srcSubresource-parameter~^~core~^~The spec valid usage text states 'srcSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcSubresource-parameter)~^~implicit -VALIDATION_ERROR_0a400c01~^~Y~^~InvalidImageViewAspect~^~VkImageSubresource~^~VUID-VkImageSubresource-aspectMask-parameter~^~core~^~The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresource-aspectMask-parameter)~^~implicit, Multi-purposing this enum for various invalid aspect usage. There is some "must" language in spec at VkImageAspectFlagBits definition that we need specific enums for. Also need more tests for these cases. -VALIDATION_ERROR_0a400c03~^~Y~^~Unknown~^~VkImageSubresource~^~VUID-VkImageSubresource-aspectMask-requiredbitmask~^~core~^~The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresource-aspectMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_0a60014e~^~Y~^~CopyImageAspectMismatch~^~VkImageSubresourceLayers~^~VUID-VkImageSubresourceLayers-aspectMask-00167~^~core~^~The spec valid usage text states 'If aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-00167)~^~ -VALIDATION_ERROR_0a600150~^~Y~^~CopyImageAspectMismatch~^~VkImageSubresourceLayers~^~VUID-VkImageSubresourceLayers-aspectMask-00168~^~core~^~The spec valid usage text states 'aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-00168)~^~ -VALIDATION_ERROR_0a600c01~^~Y~^~Unknown~^~VkImageSubresourceLayers~^~VUID-VkImageSubresourceLayers-aspectMask-parameter~^~core~^~The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-parameter)~^~implicit -VALIDATION_ERROR_0a600c03~^~Y~^~Unknown~^~VkImageSubresourceLayers~^~VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask~^~core~^~The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_0a600d48~^~N~^~None~^~VkImageSubresourceLayers~^~VUID-VkImageSubresourceLayers-layerCount-01700~^~core~^~The spec valid usage text states 'layerCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-layerCount-01700)~^~ -VALIDATION_ERROR_0a800c01~^~N~^~Unknown~^~VkImageSubresourceRange~^~VUID-VkImageSubresourceRange-aspectMask-parameter~^~core~^~The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-aspectMask-parameter)~^~implicit -VALIDATION_ERROR_0a800c03~^~Y~^~Unknown~^~VkImageSubresourceRange~^~VUID-VkImageSubresourceRange-aspectMask-requiredbitmask~^~core~^~The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-aspectMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_0a800d0c~^~N~^~None~^~VkImageSubresourceRange~^~VUID-VkImageSubresourceRange-aspectMask-01670~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, then it must not include any of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSubresourceRange-aspectMask-01670)~^~ -VALIDATION_ERROR_0a800d70~^~N~^~None~^~VkImageSubresourceRange~^~VUID-VkImageSubresourceRange-levelCount-01720~^~core~^~The spec valid usage text states 'If levelCount is not VK_REMAINING_MIP_LEVELS, it must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-levelCount-01720)~^~ -VALIDATION_ERROR_0a800d72~^~N~^~None~^~VkImageSubresourceRange~^~VUID-VkImageSubresourceRange-layerCount-01721~^~core~^~The spec valid usage text states 'If layerCount is not VK_REMAINING_ARRAY_LAYERS, it must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-layerCount-01721)~^~ -VALIDATION_ERROR_0aa007c6~^~N~^~Unknown~^~VkImageSwapchainCreateInfoKHR~^~VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995~^~(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If swapchain is not VK_NULL_HANDLE, the fields of VkImageCreateInfo must match the implied image creation parameters of the swapchain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995)~^~ -VALIDATION_ERROR_0aa2b00b~^~N~^~Unknown~^~VkImageSwapchainCreateInfoKHR~^~VUID-VkImageSwapchainCreateInfoKHR-sType-sType~^~(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSwapchainCreateInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0aa2f001~^~N~^~Unknown~^~VkImageSwapchainCreateInfoKHR~^~VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter)~^~implicit -VALIDATION_ERROR_0ac007d6~^~Y~^~CreateImageViewBreaksParameterCompatibilityRequirements~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01003~^~core~^~The spec valid usage text states 'If image was not created with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then viewType must not be VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01003)~^~ -VALIDATION_ERROR_0ac007d8~^~N~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-viewType-01004~^~core~^~The spec valid usage text states 'If the image cubemap arrays feature is not enabled, viewType must not be VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-viewType-01004)~^~ -VALIDATION_ERROR_0ac007da~^~Y~^~CreateImageViewBreaksParameterCompatibilityRequirements~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01005~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01005)~^~ -VALIDATION_ERROR_0ac007dc~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01006~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01006)~^~ -VALIDATION_ERROR_0ac007de~^~N~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01007~^~core~^~The spec valid usage text states 'image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01007)~^~ -VALIDATION_ERROR_0ac007e0~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01008~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01008)~^~ -VALIDATION_ERROR_0ac007e2~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01009~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01009)~^~ -VALIDATION_ERROR_0ac007e4~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01010~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01010)~^~ -VALIDATION_ERROR_0ac007e6~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01011~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01011)~^~ -VALIDATION_ERROR_0ac007e8~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01012~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01012)~^~ -VALIDATION_ERROR_0ac007ea~^~Y~^~CreateImageViewFormatFeatureMismatch~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01013~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01013)~^~ -VALIDATION_ERROR_0ac007ec~^~Y~^~CreateImageViewFormatFeatureMismatch~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01014~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01014)~^~ -VALIDATION_ERROR_0ac007ee~^~Y~^~CreateImageViewFormatFeatureMismatch~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01015~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01015)~^~ -VALIDATION_ERROR_0ac007f0~^~Y~^~CreateImageViewFormatFeatureMismatch~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01016~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01016)~^~ -VALIDATION_ERROR_0ac007f4~^~Y~^~CreateImageViewDifferentClass~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01018~^~core~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01018)~^~Multi-purposing this for some format compatibility checks, need unique enums. -VALIDATION_ERROR_0ac007f6~^~Y~^~CreateImageViewNoMutableFormatBit~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01019~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be identical to the format used to create image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01019)~^~ -VALIDATION_ERROR_0ac007f8~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01020~^~core~^~The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01020)~^~ -VALIDATION_ERROR_0ac007fa~^~Y~^~CreateImageViewBreaksParameterCompatibilityRequirements~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subResourceRange-01021~^~core~^~The spec valid usage text states 'subresourceRange and viewType must be compatible with the image, as described in the compatibility table' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subResourceRange-01021)~^~ -VALIDATION_ERROR_0ac00b8c~^~Y~^~CreateImageViewInvalidSubresourceRange~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subresourceRange-01478~^~core~^~The spec valid usage text states 'subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01478)~^~ -VALIDATION_ERROR_0ac00b90~^~Y~^~CreateImageViewInvalidSubresourceRange~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subresourceRange-01480~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01480)~^~ -VALIDATION_ERROR_0ac00b94~^~Y~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01482~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01482)~^~ -VALIDATION_ERROR_0ac00b96~^~Y~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subresourceRange-01483~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01483)~^~ -VALIDATION_ERROR_0ac00b98~^~Y~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01484~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the extent.depth specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01484)~^~ -VALIDATION_ERROR_0ac00b9a~^~Y~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subresourceRange-01485~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the extent.depth specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01485)~^~ -VALIDATION_ERROR_0ac00c5e~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01583~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with, or must be an uncompressed format that is size-compatible with, the format used to create image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01583)~^~ -VALIDATION_ERROR_0ac00c60~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01584~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, the levelCount and layerCount members of subresourceRange must both be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01584)~^~ -VALIDATION_ERROR_0ac00c62~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-pNext-01585~^~(VK_KHR_image_format_list)~^~The spec valid usage text states 'If a VkImageFormatListCreateInfoKHR structure was included in the pNext chain of the VkImageCreateInfo struct used when creating image and the viewFormatCount field of VkImageFormatListCreateInfoKHR is not zero then format must be one of the formats in VkImageFormatListCreateInfoKHR::pViewFormats.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-pNext-01585)~^~ -VALIDATION_ERROR_0ac00c64~^~Y~^~MultiplaneIncompatibleViewFormat~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01586~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a multi-planar format, and if subresourceRange.aspectMask is one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in features-formats-compatible-planes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01586)~^~ -VALIDATION_ERROR_0ac00d6c~^~Y~^~CreateImageViewInvalidSubresourceRange~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subresourceRange-01718~^~core~^~The spec valid usage text states 'If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01718)~^~ -VALIDATION_ERROR_0ac00d6e~^~Y~^~CreateImageViewInvalidSubresourceRange~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subresourceRange-01719~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01719)~^~ -VALIDATION_ERROR_0ac00dbe~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01759~^~(VK_VERSION_1_1,VK_KHR_maintenance2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01759)~^~ -VALIDATION_ERROR_0ac00dc0~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01760~^~!(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01760)~^~ -VALIDATION_ERROR_0ac00dc2~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01761~^~(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01761)~^~ -VALIDATION_ERROR_0ac00dc4~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01762~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag,' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01762)~^~ -VALIDATION_ERROR_0ac00ed0~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-01896~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If image has an external format:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01896)~^~ -VALIDATION_ERROR_0ac02c01~^~N~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-components-parameter~^~core~^~The spec valid usage text states 'components must be a valid VkComponentMapping structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-components-parameter)~^~implicit -VALIDATION_ERROR_0ac09005~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0ac09201~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-format-parameter)~^~implicit -VALIDATION_ERROR_0ac0a001~^~Y~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-parameter)~^~implicit -VALIDATION_ERROR_0ac1c40d~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageViewUsageCreateInfo or VkSamplerYcbcrConversionInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0ac2b00b~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0ac2b00f~^~N~^~None~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_0ac2ea01~^~N~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-subresourceRange-parameter~^~core~^~The spec valid usage text states 'subresourceRange must be a valid VkImageSubresourceRange structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-parameter)~^~implicit -VALIDATION_ERROR_0ac30801~^~Y~^~Unknown~^~VkImageViewCreateInfo~^~VUID-VkImageViewCreateInfo-viewType-parameter~^~core~^~The spec valid usage text states 'viewType must be a valid VkImageViewType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-viewType-parameter)~^~implicit -VALIDATION_ERROR_0ae00536~^~N~^~Unknown~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-00667~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00667)~^~ -VALIDATION_ERROR_0ae00538~^~N~^~Unknown~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-fd-00668~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'The memory from which fd was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-00668)~^~ -VALIDATION_ERROR_0ae0053a~^~N~^~Unknown~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-00669~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If handleType is not 0, it must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00669)~^~ -VALIDATION_ERROR_0ae0053c~^~N~^~Unknown~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-00670~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If handleType is not 0, fd must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00670)~^~ -VALIDATION_ERROR_0ae00be0~^~N~^~None~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-fd-01520~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'fd must obey any requirements listed for handleType in external memory handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-01520)~^~ -VALIDATION_ERROR_0ae00da4~^~N~^~None~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-fd-01746~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in external-memory-handle-types-compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-01746)~^~ -VALIDATION_ERROR_0ae09c01~^~N~^~Unknown~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_0ae2b00b~^~N~^~Unknown~^~VkImportMemoryFdInfoKHR~^~VUID-VkImportMemoryFdInfoKHR-sType-sType~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0b000524~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658)~^~ -VALIDATION_ERROR_0b000526~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659)~^~ -VALIDATION_ERROR_0b000528~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handleType is not 0, it must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660)~^~ -VALIDATION_ERROR_0b00052a~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661)~^~ -VALIDATION_ERROR_0b000b3e~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439)~^~ -VALIDATION_ERROR_0b000b40~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440)~^~ -VALIDATION_ERROR_0b000b42~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'if handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441)~^~ -VALIDATION_ERROR_0b000bdc~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handle is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518)~^~ -VALIDATION_ERROR_0b000bde~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-name-01519~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If name is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-name-01519)~^~ -VALIDATION_ERROR_0b009c01~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b02b00b~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0b200a5e~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoNV~^~VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'handleType must not have more than one bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327)~^~ -VALIDATION_ERROR_0b200a60~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoNV~^~VUID-VkImportMemoryWin32HandleInfoNV-handle-01328~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'handle must be a valid handle to memory, obtained as specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handle-01328)~^~ -VALIDATION_ERROR_0b209c01~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoNV~^~VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b22b00b~^~N~^~Unknown~^~VkImportMemoryWin32HandleInfoNV~^~VUID-VkImportMemoryWin32HandleInfoNV-sType-sType~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_0b4008ee~^~N~^~Unknown~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-handleType-01143~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreFdInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-01143)~^~ -VALIDATION_ERROR_0b400c10~^~N~^~None~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-fd-01544~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'fd must obey any requirements listed for handleType in external semaphore handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-fd-01544)~^~ -VALIDATION_ERROR_0b409001~^~Y~^~None~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-flags-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-flags-parameter)~^~implicit -VALIDATION_ERROR_0b409c01~^~Y~^~Unknown~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b41c40d~^~Y~^~Unknown~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_0b42b00b~^~Y~^~Unknown~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-sType-sType~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0b42b801~^~Y~^~Unknown~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter)~^~implicit -VALIDATION_ERROR_0b6008e8~^~N~^~Unknown~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140)~^~ -VALIDATION_ERROR_0b600b74~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466)~^~ -VALIDATION_ERROR_0b600b76~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467)~^~ -VALIDATION_ERROR_0b600b78~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468)~^~ -VALIDATION_ERROR_0b600b7a~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469)~^~ -VALIDATION_ERROR_0b600c0c~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handle is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542)~^~ -VALIDATION_ERROR_0b600c0e~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If name is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543)~^~ -VALIDATION_ERROR_0b609001~^~Y~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter)~^~implicit -VALIDATION_ERROR_0b609c01~^~Y~^~Unknown~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b61c40d~^~Y~^~Unknown~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_0b62b00b~^~Y~^~Unknown~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0b62b801~^~Y~^~Unknown~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter)~^~implicit -VALIDATION_ERROR_0b800a86~^~N~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'tokenCount must be greater than 0 and below VkDeviceGeneratedCommandsLimitsNVX::maxIndirectCommandsLayoutTokenCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347)~^~ -VALIDATION_ERROR_0b800a88~^~N~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, then pipelineBindPoint must not be VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348)~^~ -VALIDATION_ERROR_0b800a8a~^~N~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX it must be the first element of the array and there must be only a single element of such token type.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349)~^~ -VALIDATION_ERROR_0b800a8c~^~N~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01350~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'All state binding tokens in pTokens must occur prior work provoking tokens (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01350)~^~ -VALIDATION_ERROR_0b800a8e~^~N~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01351~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The content of pTokens must include one single work provoking token that is compatible with the pipelineBindPoint.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01351)~^~ -VALIDATION_ERROR_0b809001~^~N~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must be a valid combination of VkIndirectCommandsLayoutUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter)~^~implicit -VALIDATION_ERROR_0b809003~^~Y~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0b81c40d~^~Y~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-pNext-pNext~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0b826001~^~Y~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pTokens must be a valid pointer to an array of tokenCount valid VkIndirectCommandsLayoutTokenNVX structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter)~^~implicit -VALIDATION_ERROR_0b827e01~^~Y~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter)~^~implicit -VALIDATION_ERROR_0b82b00b~^~Y~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-sType-sType~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-sType-sType)~^~implicit -VALIDATION_ERROR_0b82fc1b~^~Y~^~Unknown~^~VkIndirectCommandsLayoutCreateInfoNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'tokenCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength)~^~implicit -VALIDATION_ERROR_0ba00a7c~^~N~^~Unknown~^~VkIndirectCommandsLayoutTokenNVX~^~VUID-VkIndirectCommandsLayoutTokenNVX-bindingUnit-01342~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'bindingUnit must stay within device supported limits for the appropriate commands.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-bindingUnit-01342)~^~ -VALIDATION_ERROR_0ba00a7e~^~N~^~Unknown~^~VkIndirectCommandsLayoutTokenNVX~^~VUID-VkIndirectCommandsLayoutTokenNVX-dynamicCount-01343~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'dynamicCount must stay within device supported limits for the appropriate commands.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-dynamicCount-01343)~^~ -VALIDATION_ERROR_0ba00a80~^~N~^~Unknown~^~VkIndirectCommandsLayoutTokenNVX~^~VUID-VkIndirectCommandsLayoutTokenNVX-divisor-01344~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'divisor must be greater than 0 and a power of two.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-divisor-01344)~^~ -VALIDATION_ERROR_0ba2fe01~^~Y~^~Unknown~^~VkIndirectCommandsLayoutTokenNVX~^~VUID-VkIndirectCommandsLayoutTokenNVX-tokenType-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'tokenType must be a valid VkIndirectCommandsTokenTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-tokenType-parameter)~^~implicit -VALIDATION_ERROR_0bc00a82~^~N~^~Unknown~^~VkIndirectCommandsTokenNVX~^~VUID-VkIndirectCommandsTokenNVX-buffer-01345~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The buffer's usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-buffer-01345)~^~ -VALIDATION_ERROR_0bc00a84~^~N~^~Unknown~^~VkIndirectCommandsTokenNVX~^~VUID-VkIndirectCommandsTokenNVX-offset-01346~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The offset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minCommandsTokenBufferOffsetAlignment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-offset-01346)~^~ -VALIDATION_ERROR_0bc01a01~^~Y~^~Unknown~^~VkIndirectCommandsTokenNVX~^~VUID-VkIndirectCommandsTokenNVX-buffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-buffer-parameter)~^~implicit -VALIDATION_ERROR_0bc2fe01~^~Y~^~Unknown~^~VkIndirectCommandsTokenNVX~^~VUID-VkIndirectCommandsTokenNVX-tokenType-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'tokenType must be a valid VkIndirectCommandsTokenTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-tokenType-parameter)~^~implicit -VALIDATION_ERROR_0be09005~^~Y~^~Unknown~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0be0ee01~^~N~^~Unknown~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-pApplicationInfo-parameter~^~core~^~The spec valid usage text states 'If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid VkApplicationInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pApplicationInfo-parameter)~^~implicit -VALIDATION_ERROR_0be1c40d~^~N~^~Unknown~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT, VkDebugUtilsMessengerCreateInfoEXT, or VkValidationFlagsEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_0be28e01~^~Y~^~Unknown~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter~^~core~^~The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter)~^~implicit -VALIDATION_ERROR_0be29001~^~Y~^~Unknown~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter~^~core~^~The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter)~^~implicit -VALIDATION_ERROR_0be2b00b~^~Y~^~Unknown~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0be2b00f~^~N~^~None~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_0c000a4a~^~N~^~Unknown~^~VkMacOSSurfaceCreateInfoMVK~^~VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'pView must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317)~^~ -VALIDATION_ERROR_0c009005~^~Y~^~Unknown~^~VkMacOSSurfaceCreateInfoMVK~^~VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_0c01c40d~^~Y~^~Unknown~^~VkMacOSSurfaceCreateInfoMVK~^~VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext)~^~implicit -VALIDATION_ERROR_0c02b00b~^~Y~^~Unknown~^~VkMacOSSurfaceCreateInfoMVK~^~VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType)~^~implicit -VALIDATION_ERROR_0c200558~^~N~^~Unknown~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-memory-00684~^~core~^~The spec valid usage text states 'memory must be currently mapped' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-memory-00684)~^~ -VALIDATION_ERROR_0c20055a~^~Y~^~InvalidMemoryMapping~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-size-00685~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, offset and size must specify a range contained within the currently mapped range of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-00685)~^~ -VALIDATION_ERROR_0c20055c~^~Y~^~InvalidMemoryMapping~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-size-00686~^~core~^~The spec valid usage text states 'If size is equal to VK_WHOLE_SIZE, offset must be within the currently mapped range of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-00686)~^~ -VALIDATION_ERROR_0c20055e~^~Y~^~InvalidMemoryMapping~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-offset-00687~^~core~^~The spec valid usage text states 'offset must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-offset-00687)~^~see issues gitlab 611 and github 329 -VALIDATION_ERROR_0c200ada~^~N~^~None~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-size-01389~^~core~^~The spec valid usage text states 'If size is equal to VK_WHOLE_SIZE, the end of the current mapping of memory must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize bytes from the beginning of the memory object.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-01389)~^~ -VALIDATION_ERROR_0c200adc~^~Y~^~InvalidMemoryMapping~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-size-01390~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must either be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, or offset plus size must equal the size of memory.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-01390)~^~ -VALIDATION_ERROR_0c20c601~^~Y~^~None~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-memory-parameter~^~core~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-memory-parameter)~^~implicit, This error applies to both vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges. -VALIDATION_ERROR_0c21c40d~^~Y~^~Unknown~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0c22b00b~^~N~^~Unknown~^~VkMappedMemoryRange~^~VUID-VkMappedMemoryRange-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0c400546~^~N~^~Unknown~^~VkMemoryAllocateFlagsInfo~^~VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must be a valid device mask.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675)~^~ -VALIDATION_ERROR_0c400548~^~N~^~Unknown~^~VkMemoryAllocateFlagsInfo~^~VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676)~^~ -VALIDATION_ERROR_0c409001~^~N~^~Unknown~^~VkMemoryAllocateFlagsInfo~^~VUID-VkMemoryAllocateFlagsInfo-flags-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'flags must be a valid combination of VkMemoryAllocateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-flags-parameter)~^~implicit -VALIDATION_ERROR_0c42b00b~^~N~^~Unknown~^~VkMemoryAllocateFlagsInfo~^~VUID-VkMemoryAllocateFlagsInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-sType-sType)~^~implicit -VALIDATION_ERROR_0c6004fc~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-allocationSize-00638~^~!(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'allocationSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00638)~^~ -VALIDATION_ERROR_0c6004fe~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-pNext-00639~^~(VK_KHR_external_memory)+(VK_KHR_dedicated_allocation,VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfo, and any of the handle types specified in VkExportMemoryAllocateInfo::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2 in VkExternalImageFormatProperties::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferProperties::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of ifdef::VK_KHR_dedicated_allocation[VkMemoryDedicatedAllocateInfo]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00639)~^~ -VALIDATION_ERROR_0c600500~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-pNext-00640~^~(VK_KHR_external_memory)+(VK_NV_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfo, it must not contain an instance of VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00640)~^~ -VALIDATION_ERROR_0c600502~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-pNext-00641~^~(VK_KHR_external_memory_win32+VK_NV_external_memory_win32)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkImportMemoryWin32HandleInfoKHR, it must not contain an instance of VkImportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00641)~^~ -VALIDATION_ERROR_0c600506~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-None-00643~^~(VK_KHR_external_memory+VK_KHR_device_group)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfo must match that specified when the memory object being imported was allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00643)~^~ -VALIDATION_ERROR_0c600508~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-None-00644~^~(VK_KHR_external_memory+VK_KHR_device_group)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the memory was originally allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00644)~^~ -VALIDATION_ERROR_0c60050a~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645)~^~ -VALIDATION_ERROR_0c60050c~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-allocationSize-00646~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, allocationSize must match the size reported in the memory requirements of the image or buffer member of the instance of VkDedicatedAllocationMemoryAllocateInfoNV included in the pNext chain.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00646)~^~ -VALIDATION_ERROR_0c60050e~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-allocationSize-00647~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00647)~^~ -VALIDATION_ERROR_0c600510~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648)~^~ -VALIDATION_ERROR_0c600d9c~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-allocationSize-01742~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-01742)~^~ -VALIDATION_ERROR_0c600d9e~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-allocationSize-01743~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-01743)~^~ -VALIDATION_ERROR_0c600da0~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle is a host pointer, the value of memoryTypeIndex must be one of those returned by vkGetMemoryHostPointerPropertiesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744)~^~ -VALIDATION_ERROR_0c600da2~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-allocationSize-01745~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle is a host pointer, allocationSize must be an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-01745)~^~ -VALIDATION_ERROR_0c600ea0~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If the protected memory feature is not enabled, the VkMemoryAllocateInfo::memoryTypeIndex must not indicate a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872)~^~ -VALIDATION_ERROR_0c600ea2~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-None-01873~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BIT_ANDROID:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-01873)~^~ -VALIDATION_ERROR_0c600ea4~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-pNext-01874~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the parameters do not define an import operation, and the pNext chain contains an instance of VkExportMemoryAllocateInfo with VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID included in its handleTypes member, and the pNext contains an instance of VkMemoryDedicatedAllocateInfo with image not equal to VK_NULL_HANDLE, then allocationSize must be 0, otherwise allocationSize must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-01874)~^~ -VALIDATION_ERROR_0c600ea6~^~N~^~None~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-pNext-01875~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-01875)~^~ -VALIDATION_ERROR_0c61c40d~^~Y~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkMemoryAllocateFlagsInfo, or VkMemoryDedicatedAllocateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_0c62b00b~^~Y~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0c62b00f~^~N~^~Unknown~^~VkMemoryAllocateInfo~^~VUID-VkMemoryAllocateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_0c806801~^~Y~^~Unknown~^~VkMemoryBarrier~^~VUID-VkMemoryBarrier-dstAccessMask-parameter~^~core~^~The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-dstAccessMask-parameter)~^~implicit -VALIDATION_ERROR_0c81c40d~^~Y~^~Unknown~^~VkMemoryBarrier~^~VUID-VkMemoryBarrier-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0c82b00b~^~N~^~Unknown~^~VkMemoryBarrier~^~VUID-VkMemoryBarrier-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0c82c401~^~Y~^~Unknown~^~VkMemoryBarrier~^~VUID-VkMemoryBarrier-srcAccessMask-parameter~^~core~^~The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-srcAccessMask-parameter)~^~implicit -VALIDATION_ERROR_0ca009de~^~N~^~Unknown~^~VkMirSurfaceCreateInfoKHR~^~VUID-VkMirSurfaceCreateInfoKHR-connection-01263~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'connection must point to a valid MirConnection.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-connection-01263)~^~TBD in parameter validation layer. -VALIDATION_ERROR_0ca009e0~^~N~^~Unknown~^~VkMirSurfaceCreateInfoKHR~^~VUID-VkMirSurfaceCreateInfoKHR-surface-01264~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'surface must point to a valid MirSurface.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-surface-01264)~^~TBD in parameter validation layer. -VALIDATION_ERROR_0ca09005~^~Y~^~Unknown~^~VkMirSurfaceCreateInfoKHR~^~VUID-VkMirSurfaceCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_0ca1c40d~^~Y~^~Unknown~^~VkMirSurfaceCreateInfoKHR~^~VUID-VkMirSurfaceCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_0ca2b00b~^~Y~^~Unknown~^~VkMirSurfaceCreateInfoKHR~^~VUID-VkMirSurfaceCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0cc00a96~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-computeBindingPointSupport-01355~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, pObjectEntryUsageFlags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-computeBindingPointSupport-01355)~^~ -VALIDATION_ERROR_0cc00a98~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-01356~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'Any value within pObjectEntryCounts must not exceed VkDeviceGeneratedCommandsLimitsNVX::maxObjectEntryCounts' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-01356)~^~ -VALIDATION_ERROR_0cc00a9a~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-maxUniformBuffersPerDescriptor-01357~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'maxUniformBuffersPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxUniformBuffersPerDescriptor-01357)~^~ -VALIDATION_ERROR_0cc00a9c~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-maxStorageBuffersPerDescriptor-01358~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'maxStorageBuffersPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxStorageBuffersPerDescriptor-01358)~^~ -VALIDATION_ERROR_0cc00a9e~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-maxStorageImagesPerDescriptor-01359~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'maxStorageImagesPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxStorageImagesPerDescriptor-01359)~^~ -VALIDATION_ERROR_0cc00aa0~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-maxSampledImagesPerDescriptor-01360~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'maxSampledImagesPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxSampledImagesPerDescriptor-01360)~^~ -VALIDATION_ERROR_0cc0d61b~^~Y~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-objectCount-arraylength~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-objectCount-arraylength)~^~implicit -VALIDATION_ERROR_0cc1c40d~^~Y~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-pNext-pNext~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0cc1c601~^~Y~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pObjectEntryCounts must be a valid pointer to an array of objectCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-parameter)~^~implicit -VALIDATION_ERROR_0cc1c801~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-pObjectEntryTypes-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryTypes-parameter)~^~implicit -VALIDATION_ERROR_0cc1ca01~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pObjectEntryUsageFlags must be a valid pointer to an array of objectCount valid combinations of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-parameter)~^~implicit -VALIDATION_ERROR_0cc1ca03~^~N~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'Each element of pObjectEntryUsageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0cc2b00b~^~Y~^~Unknown~^~VkObjectTableCreateInfoNVX~^~VUID-VkObjectTableCreateInfoNVX-sType-sType~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-sType-sType)~^~implicit -VALIDATION_ERROR_0ce00009~^~N~^~Unknown~^~VkObjectTableDescriptorSetEntryNVX~^~VUID-VkObjectTableDescriptorSetEntryNVX-commonparent~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'Both of descriptorSet, and pipelineLayout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-commonparent)~^~implicit -VALIDATION_ERROR_0ce00ab2~^~N~^~Unknown~^~VkObjectTableDescriptorSetEntryNVX~^~VUID-VkObjectTableDescriptorSetEntryNVX-type-01369~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-type-01369)~^~ -VALIDATION_ERROR_0ce04801~^~N~^~Unknown~^~VkObjectTableDescriptorSetEntryNVX~^~VUID-VkObjectTableDescriptorSetEntryNVX-descriptorSet-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'descriptorSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-descriptorSet-parameter)~^~implicit -VALIDATION_ERROR_0ce09001~^~N~^~Unknown~^~VkObjectTableDescriptorSetEntryNVX~^~VUID-VkObjectTableDescriptorSetEntryNVX-flags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-flags-parameter)~^~implicit -VALIDATION_ERROR_0ce09003~^~N~^~Unknown~^~VkObjectTableDescriptorSetEntryNVX~^~VUID-VkObjectTableDescriptorSetEntryNVX-flags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0ce28201~^~N~^~Unknown~^~VkObjectTableDescriptorSetEntryNVX~^~VUID-VkObjectTableDescriptorSetEntryNVX-pipelineLayout-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-pipelineLayout-parameter)~^~implicit -VALIDATION_ERROR_0ce30401~^~N~^~Unknown~^~VkObjectTableDescriptorSetEntryNVX~^~VUID-VkObjectTableDescriptorSetEntryNVX-type-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-type-parameter)~^~implicit -VALIDATION_ERROR_0d000aae~^~N~^~Unknown~^~VkObjectTableEntryNVX~^~VUID-VkObjectTableEntryNVX-computeBindingPointSupport-01367~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, flags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-computeBindingPointSupport-01367)~^~ -VALIDATION_ERROR_0d009001~^~N~^~Unknown~^~VkObjectTableEntryNVX~^~VUID-VkObjectTableEntryNVX-flags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-flags-parameter)~^~implicit -VALIDATION_ERROR_0d009003~^~Y~^~Unknown~^~VkObjectTableEntryNVX~^~VUID-VkObjectTableEntryNVX-flags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0d030401~^~Y~^~Unknown~^~VkObjectTableEntryNVX~^~VUID-VkObjectTableEntryNVX-type-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-type-parameter)~^~implicit -VALIDATION_ERROR_0d200ab6~^~N~^~Unknown~^~VkObjectTableIndexBufferEntryNVX~^~VUID-VkObjectTableIndexBufferEntryNVX-type-01371~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-type-01371)~^~ -VALIDATION_ERROR_0d201a01~^~N~^~Unknown~^~VkObjectTableIndexBufferEntryNVX~^~VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter)~^~implicit -VALIDATION_ERROR_0d209001~^~N~^~Unknown~^~VkObjectTableIndexBufferEntryNVX~^~VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter)~^~implicit -VALIDATION_ERROR_0d209003~^~N~^~Unknown~^~VkObjectTableIndexBufferEntryNVX~^~VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0d20b201~^~N~^~Unknown~^~VkObjectTableIndexBufferEntryNVX~^~VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'indexType must be a valid VkIndexType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter)~^~implicit -VALIDATION_ERROR_0d230401~^~N~^~Unknown~^~VkObjectTableIndexBufferEntryNVX~^~VUID-VkObjectTableIndexBufferEntryNVX-type-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-type-parameter)~^~implicit -VALIDATION_ERROR_0d400ab0~^~N~^~Unknown~^~VkObjectTablePipelineEntryNVX~^~VUID-VkObjectTablePipelineEntryNVX-type-01368~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-type-01368)~^~ -VALIDATION_ERROR_0d409001~^~N~^~Unknown~^~VkObjectTablePipelineEntryNVX~^~VUID-VkObjectTablePipelineEntryNVX-flags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-flags-parameter)~^~implicit -VALIDATION_ERROR_0d409003~^~N~^~Unknown~^~VkObjectTablePipelineEntryNVX~^~VUID-VkObjectTablePipelineEntryNVX-flags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0d427c01~^~N~^~Unknown~^~VkObjectTablePipelineEntryNVX~^~VUID-VkObjectTablePipelineEntryNVX-pipeline-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-pipeline-parameter)~^~implicit -VALIDATION_ERROR_0d430401~^~N~^~Unknown~^~VkObjectTablePipelineEntryNVX~^~VUID-VkObjectTablePipelineEntryNVX-type-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-type-parameter)~^~implicit -VALIDATION_ERROR_0d600ab8~^~N~^~Unknown~^~VkObjectTablePushConstantEntryNVX~^~VUID-VkObjectTablePushConstantEntryNVX-type-01372~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-type-01372)~^~ -VALIDATION_ERROR_0d609001~^~N~^~Unknown~^~VkObjectTablePushConstantEntryNVX~^~VUID-VkObjectTablePushConstantEntryNVX-flags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-flags-parameter)~^~implicit -VALIDATION_ERROR_0d609003~^~N~^~Unknown~^~VkObjectTablePushConstantEntryNVX~^~VUID-VkObjectTablePushConstantEntryNVX-flags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0d628201~^~N~^~Unknown~^~VkObjectTablePushConstantEntryNVX~^~VUID-VkObjectTablePushConstantEntryNVX-pipelineLayout-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-pipelineLayout-parameter)~^~implicit -VALIDATION_ERROR_0d62dc01~^~N~^~Unknown~^~VkObjectTablePushConstantEntryNVX~^~VUID-VkObjectTablePushConstantEntryNVX-stageFlags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-stageFlags-parameter)~^~implicit -VALIDATION_ERROR_0d62dc03~^~N~^~Unknown~^~VkObjectTablePushConstantEntryNVX~^~VUID-VkObjectTablePushConstantEntryNVX-stageFlags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'stageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-stageFlags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0d630401~^~N~^~Unknown~^~VkObjectTablePushConstantEntryNVX~^~VUID-VkObjectTablePushConstantEntryNVX-type-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-type-parameter)~^~implicit -VALIDATION_ERROR_0d800ab4~^~N~^~Unknown~^~VkObjectTableVertexBufferEntryNVX~^~VUID-VkObjectTableVertexBufferEntryNVX-type-01370~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-type-01370)~^~ -VALIDATION_ERROR_0d801a01~^~N~^~Unknown~^~VkObjectTableVertexBufferEntryNVX~^~VUID-VkObjectTableVertexBufferEntryNVX-buffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-buffer-parameter)~^~implicit -VALIDATION_ERROR_0d809001~^~N~^~Unknown~^~VkObjectTableVertexBufferEntryNVX~^~VUID-VkObjectTableVertexBufferEntryNVX-flags-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-flags-parameter)~^~implicit -VALIDATION_ERROR_0d809003~^~N~^~Unknown~^~VkObjectTableVertexBufferEntryNVX~^~VUID-VkObjectTableVertexBufferEntryNVX-flags-requiredbitmask~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_0d830401~^~N~^~Unknown~^~VkObjectTableVertexBufferEntryNVX~^~VUID-VkObjectTableVertexBufferEntryNVX-type-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-type-parameter)~^~implicit -VALIDATION_ERROR_0da2b00b~^~N~^~Unknown~^~VkPhysicalDeviceDiscardRectanglePropertiesEXT~^~VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_0dc09001~^~Y~^~Unknown~^~VkPhysicalDeviceExternalBufferInfo~^~VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter)~^~implicit -VALIDATION_ERROR_0dc09c01~^~Y~^~Unknown~^~VkPhysicalDeviceExternalBufferInfo~^~VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter)~^~implicit -VALIDATION_ERROR_0dc1c40d~^~Y~^~Unknown~^~VkPhysicalDeviceExternalBufferInfo~^~VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_0dc2b00b~^~Y~^~Unknown~^~VkPhysicalDeviceExternalBufferInfo~^~VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType)~^~implicit -VALIDATION_ERROR_0dc30601~^~N~^~Unknown~^~VkPhysicalDeviceExternalBufferInfo~^~VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter)~^~implicit -VALIDATION_ERROR_0dc30603~^~Y~^~Unknown~^~VkPhysicalDeviceExternalBufferInfo~^~VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_0de09c01~^~N~^~Unknown~^~VkPhysicalDeviceExternalImageFormatInfo~^~VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter)~^~implicit -VALIDATION_ERROR_0de2b00b~^~N~^~Unknown~^~VkPhysicalDeviceExternalImageFormatInfo~^~VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType)~^~implicit -VALIDATION_ERROR_0e009c01~^~Y~^~Unknown~^~VkPhysicalDeviceExternalSemaphoreInfo~^~VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter)~^~implicit -VALIDATION_ERROR_0e01c40d~^~Y~^~Unknown~^~VkPhysicalDeviceExternalSemaphoreInfo~^~VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_0e02b00b~^~Y~^~Unknown~^~VkPhysicalDeviceExternalSemaphoreInfo~^~VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType)~^~implicit -VALIDATION_ERROR_0e42b00b~^~Y~^~Unknown~^~VkPhysicalDeviceFeatures2~^~VUID-VkPhysicalDeviceFeatures2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceFeatures2-sType-sType)~^~implicit -VALIDATION_ERROR_0e609001~^~Y~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter)~^~implicit -VALIDATION_ERROR_0e609201~^~Y~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter)~^~implicit -VALIDATION_ERROR_0e61c40d~^~Y~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceExternalImageFormatInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext)~^~implicit -VALIDATION_ERROR_0e62b00b~^~Y~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType)~^~implicit -VALIDATION_ERROR_0e62fa01~^~Y~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter)~^~implicit -VALIDATION_ERROR_0e630401~^~Y~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter)~^~implicit -VALIDATION_ERROR_0e630601~^~N~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter)~^~implicit -VALIDATION_ERROR_0e630603~^~Y~^~Unknown~^~VkPhysicalDeviceImageFormatInfo2~^~VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_0e800488~^~N~^~Unknown~^~VkPhysicalDeviceMultiviewFeatures~^~VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If multiviewGeometryShader is enabled then multiview must also be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580)~^~ -VALIDATION_ERROR_0e80048a~^~N~^~Unknown~^~VkPhysicalDeviceMultiviewFeatures~^~VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If multiviewTessellationShader is enabled then multiview must also be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581)~^~ -VALIDATION_ERROR_0e82b00b~^~N~^~Unknown~^~VkPhysicalDeviceMultiviewFeatures~^~VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType)~^~implicit -VALIDATION_ERROR_0ea2b00b~^~N~^~Unknown~^~VkPhysicalDevicePushDescriptorPropertiesKHR~^~VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType)~^~implicit -VALIDATION_ERROR_0ec0088e~^~N~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095)~^~ -VALIDATION_ERROR_0ec09201~^~Y~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter)~^~implicit -VALIDATION_ERROR_0ec1c40d~^~Y~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-pNext-pNext)~^~implicit -VALIDATION_ERROR_0ec2b00b~^~Y~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType)~^~implicit -VALIDATION_ERROR_0ec2b401~^~Y~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter)~^~implicit -VALIDATION_ERROR_0ec2fa01~^~Y~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter)~^~implicit -VALIDATION_ERROR_0ec30401~^~Y~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter)~^~implicit -VALIDATION_ERROR_0ec30601~^~N~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter)~^~implicit -VALIDATION_ERROR_0ec30603~^~Y~^~Unknown~^~VkPhysicalDeviceSparseImageFormatInfo2~^~VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_0ee1c40d~^~Y~^~Unknown~^~VkPhysicalDeviceSurfaceInfo2KHR~^~VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_0ee2b00b~^~Y~^~Unknown~^~VkPhysicalDeviceSurfaceInfo2KHR~^~VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType)~^~implicit -VALIDATION_ERROR_0ee2ec01~^~Y~^~Unknown~^~VkPhysicalDeviceSurfaceInfo2KHR~^~VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter)~^~implicit -VALIDATION_ERROR_0f000600~^~N~^~Unknown~^~VkPipelineCacheCreateInfo~^~VUID-VkPipelineCacheCreateInfo-initialDataSize-00768~^~core~^~The spec valid usage text states 'If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-initialDataSize-00768)~^~ -VALIDATION_ERROR_0f000602~^~N~^~Unknown~^~VkPipelineCacheCreateInfo~^~VUID-VkPipelineCacheCreateInfo-initialDataSize-00769~^~core~^~The spec valid usage text states 'If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-initialDataSize-00769)~^~ -VALIDATION_ERROR_0f009005~^~Y~^~Unknown~^~VkPipelineCacheCreateInfo~^~VUID-VkPipelineCacheCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f019601~^~Y~^~Unknown~^~VkPipelineCacheCreateInfo~^~VUID-VkPipelineCacheCreateInfo-pInitialData-parameter~^~core~^~The spec valid usage text states 'If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-pInitialData-parameter)~^~implicit -VALIDATION_ERROR_0f01c40d~^~Y~^~Unknown~^~VkPipelineCacheCreateInfo~^~VUID-VkPipelineCacheCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f02b00b~^~Y~^~Unknown~^~VkPipelineCacheCreateInfo~^~VUID-VkPipelineCacheCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f2004c0~^~Y~^~ColorBlendUnsupportedDualSourceBlend~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608~^~core~^~The spec valid usage text states 'If the dual source blending feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608)~^~ -VALIDATION_ERROR_0f2004c2~^~Y~^~ColorBlendUnsupportedDualSourceBlend~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609~^~core~^~The spec valid usage text states 'If the dual source blending feature is not enabled, dstColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609)~^~ -VALIDATION_ERROR_0f2004c4~^~Y~^~ColorBlendUnsupportedDualSourceBlend~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610~^~core~^~The spec valid usage text states 'If the dual source blending feature is not enabled, srcAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610)~^~ -VALIDATION_ERROR_0f2004c6~^~Y~^~ColorBlendUnsupportedDualSourceBlend~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611~^~core~^~The spec valid usage text states 'If the dual source blending feature is not enabled, dstAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611)~^~ -VALIDATION_ERROR_0f200801~^~Y~^~Unknown~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter~^~core~^~The spec valid usage text states 'alphaBlendOp must be a valid VkBlendOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter)~^~implicit -VALIDATION_ERROR_0f200afc~^~N~^~None~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If either of colorBlendOp or alphaBlendOp is an advanced blend operation, then colorBlendOp must equal alphaBlendOp' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406)~^~ -VALIDATION_ERROR_0f200afe~^~N~^~None~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and colorBlendOp is an advanced blend operation, then colorBlendOp must be the same for all attachments.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407)~^~ -VALIDATION_ERROR_0f200b00~^~N~^~None~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and alphaBlendOp is an advanced blend operation, then alphaBlendOp must be the same for all attachments.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408)~^~ -VALIDATION_ERROR_0f200b02~^~N~^~None~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendAllOperations is VK_FALSE, then colorBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409)~^~ -VALIDATION_ERROR_0f200b04~^~N~^~None~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If colorBlendOp or alphaBlendOp is an advanced blend operation, then VkSubpassDescription::colorAttachmentCount of the subpass this pipeline is compiled against must be less than or equal to VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendMaxColorAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410)~^~ -VALIDATION_ERROR_0f202001~^~Y~^~Unknown~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter~^~core~^~The spec valid usage text states 'colorBlendOp must be a valid VkBlendOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter)~^~implicit -VALIDATION_ERROR_0f202201~^~Y~^~Unknown~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter~^~core~^~The spec valid usage text states 'colorWriteMask must be a valid combination of VkColorComponentFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter)~^~implicit -VALIDATION_ERROR_0f206a01~^~Y~^~Unknown~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter~^~core~^~The spec valid usage text states 'dstAlphaBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter)~^~implicit -VALIDATION_ERROR_0f207001~^~Y~^~Unknown~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter~^~core~^~The spec valid usage text states 'dstColorBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter)~^~implicit -VALIDATION_ERROR_0f22c601~^~Y~^~Unknown~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter~^~core~^~The spec valid usage text states 'srcAlphaBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter)~^~implicit -VALIDATION_ERROR_0f22cc01~^~Y~^~Unknown~^~VkPipelineColorBlendAttachmentState~^~VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter~^~core~^~The spec valid usage text states 'srcColorBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter)~^~implicit -VALIDATION_ERROR_0f4004ba~^~Y~^~Unknown~^~VkPipelineColorBlendStateCreateInfo~^~VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605~^~core~^~The spec valid usage text states 'If the independent blending feature is not enabled, all elements of pAttachments must be identical' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605)~^~ -VALIDATION_ERROR_0f4004bc~^~Y~^~ColorBlendUnsupportedLogicOp~^~VkPipelineColorBlendStateCreateInfo~^~VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606~^~core~^~The spec valid usage text states 'If the logic operations feature is not enabled, logicOpEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606)~^~ -VALIDATION_ERROR_0f4004be~^~Y~^~ColorBlendInvalidLogicOp~^~VkPipelineColorBlendStateCreateInfo~^~VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607~^~core~^~The spec valid usage text states 'If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607)~^~ -VALIDATION_ERROR_0f409005~^~Y~^~Unknown~^~VkPipelineColorBlendStateCreateInfo~^~VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f40f201~^~N~^~Unknown~^~VkPipelineColorBlendStateCreateInfo~^~VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter~^~core~^~The spec valid usage text states 'If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter)~^~implicit -VALIDATION_ERROR_0f41c40d~^~Y~^~Unknown~^~VkPipelineColorBlendStateCreateInfo~^~VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f42b00b~^~N~^~Unknown~^~VkPipelineColorBlendStateCreateInfo~^~VUID-VkPipelineColorBlendStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f6004ac~^~Y~^~Unknown~^~VkPipelineDepthStencilStateCreateInfo~^~VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598~^~core~^~The spec valid usage text states 'If the depth bounds testing feature is not enabled, depthBoundsTestEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598)~^~ -VALIDATION_ERROR_0f601201~^~N~^~Unknown~^~VkPipelineDepthStencilStateCreateInfo~^~VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter~^~core~^~The spec valid usage text states 'back must be a valid VkStencilOpState structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter)~^~implicit -VALIDATION_ERROR_0f604001~^~Y~^~Unknown~^~VkPipelineDepthStencilStateCreateInfo~^~VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter~^~core~^~The spec valid usage text states 'depthCompareOp must be a valid VkCompareOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter)~^~implicit -VALIDATION_ERROR_0f609005~^~Y~^~Unknown~^~VkPipelineDepthStencilStateCreateInfo~^~VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f609601~^~N~^~Unknown~^~VkPipelineDepthStencilStateCreateInfo~^~VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter~^~core~^~The spec valid usage text states 'front must be a valid VkStencilOpState structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter)~^~implicit -VALIDATION_ERROR_0f61c40d~^~Y~^~Unknown~^~VkPipelineDepthStencilStateCreateInfo~^~VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f62b00b~^~N~^~Unknown~^~VkPipelineDepthStencilStateCreateInfo~^~VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0f80048c~^~N~^~Unknown~^~VkPipelineDiscardRectangleStateCreateInfoEXT~^~VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'discardRectangleCount must be between 0 and VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582)~^~ -VALIDATION_ERROR_0f805e01~^~N~^~Unknown~^~VkPipelineDiscardRectangleStateCreateInfoEXT~^~VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'discardRectangleMode must be a valid VkDiscardRectangleModeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter)~^~implicit -VALIDATION_ERROR_0f809005~^~N~^~Unknown~^~VkPipelineDiscardRectangleStateCreateInfoEXT~^~VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_0f82b00b~^~N~^~Unknown~^~VkPipelineDiscardRectangleStateCreateInfoEXT~^~VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_0fa00b44~^~N~^~None~^~VkPipelineDynamicStateCreateInfo~^~VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442~^~core~^~The spec valid usage text states 'Each element of pDynamicStates must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442)~^~ -VALIDATION_ERROR_0fa07c1b~^~N~^~Unknown~^~VkPipelineDynamicStateCreateInfo~^~VUID-VkPipelineDynamicStateCreateInfo-dynamicStateCount-arraylength~^~core~^~The spec valid usage text states 'dynamicStateCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-dynamicStateCount-arraylength)~^~implicit -VALIDATION_ERROR_0fa09005~^~Y~^~Unknown~^~VkPipelineDynamicStateCreateInfo~^~VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fa15801~^~N~^~Unknown~^~VkPipelineDynamicStateCreateInfo~^~VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter~^~core~^~The spec valid usage text states 'pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter)~^~implicit -VALIDATION_ERROR_0fa1c40d~^~Y~^~Unknown~^~VkPipelineDynamicStateCreateInfo~^~VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fa2b00b~^~Y~^~Unknown~^~VkPipelineDynamicStateCreateInfo~^~VUID-VkPipelineDynamicStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fc00358~^~N~^~Unknown~^~VkPipelineInputAssemblyStateCreateInfo~^~VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428~^~core~^~The spec valid usage text states 'If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, primitiveRestartEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428)~^~ -VALIDATION_ERROR_0fc0035a~^~N~^~Unknown~^~VkPipelineInputAssemblyStateCreateInfo~^~VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, topology must not be any of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429)~^~ -VALIDATION_ERROR_0fc0035c~^~N~^~Unknown~^~VkPipelineInputAssemblyStateCreateInfo~^~VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, topology must not be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430)~^~ -VALIDATION_ERROR_0fc09005~^~Y~^~Unknown~^~VkPipelineInputAssemblyStateCreateInfo~^~VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fc1c40d~^~Y~^~Unknown~^~VkPipelineInputAssemblyStateCreateInfo~^~VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fc2b00b~^~Y~^~Unknown~^~VkPipelineInputAssemblyStateCreateInfo~^~VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fc30001~^~Y~^~Unknown~^~VkPipelineInputAssemblyStateCreateInfo~^~VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter~^~core~^~The spec valid usage text states 'topology must be a valid VkPrimitiveTopology value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter)~^~implicit -VALIDATION_ERROR_0fe0023c~^~Y~^~CreatePipelineLayoutExceedsSetLimit~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286~^~core~^~The spec valid usage text states 'setLayoutCount must be less than or equal to VkPhysicalDeviceLimits::maxBoundDescriptorSets' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286)~^~ -VALIDATION_ERROR_0fe0023e~^~Y~^~CreatePipelineLayoutExcessPerStageDescriptors~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00287~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00287)~^~ -VALIDATION_ERROR_0fe00240~^~Y~^~CreatePipelineLayoutExcessPerStageDescriptors~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00288~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00288)~^~ -VALIDATION_ERROR_0fe00242~^~Y~^~CreatePipelineLayoutExcessPerStageDescriptors~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00289~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00289)~^~ -VALIDATION_ERROR_0fe00244~^~Y~^~CreatePipelineLayoutExcessPerStageDescriptors~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00290~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00290)~^~ -VALIDATION_ERROR_0fe00246~^~Y~^~CreatePipelineLayoutExcessPerStageDescriptors~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00291~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00291)~^~ -VALIDATION_ERROR_0fe00248~^~Y~^~InvalidPushConstants~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292~^~core~^~The spec valid usage text states 'Any two elements of pPushConstantRanges must not include the same stage in stageFlags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292)~^~ -VALIDATION_ERROR_0fe0024a~^~Y~^~MultiplePushDescriptorSets~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293)~^~ -VALIDATION_ERROR_0fe00d18~^~Y~^~CreatePipelineLayoutExcessPerStageDescriptors~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01676~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01676)~^~ -VALIDATION_ERROR_0fe00d1a~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01677~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01677)~^~ -VALIDATION_ERROR_0fe00d1c~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01678~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stagess and and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01678)~^~ -VALIDATION_ERROR_0fe00d1e~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01679~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01679)~^~ -VALIDATION_ERROR_0fe00d20~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01680~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01680)~^~ -VALIDATION_ERROR_0fe00d22~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01681~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01681)~^~ -VALIDATION_ERROR_0fe00d24~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01682~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01682)~^~ -VALIDATION_ERROR_0fe00d26~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01683~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01683)~^~ -VALIDATION_ERROR_0fe00d28~^~Y~^~CreatePipelineLayoutExcessDescriptorsOverall~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01684~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01684)~^~ -VALIDATION_ERROR_0fe01790~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03016~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03016)~^~ -VALIDATION_ERROR_0fe01792~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03017~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03017)~^~ -VALIDATION_ERROR_0fe01794~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03018~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03018)~^~ -VALIDATION_ERROR_0fe01796~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03019~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03019)~^~ -VALIDATION_ERROR_0fe01798~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03020~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03020)~^~ -VALIDATION_ERROR_0fe0179a~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03021~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03021)~^~ -VALIDATION_ERROR_0fe0179c~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03022~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03022)~^~ -VALIDATION_ERROR_0fe0179e~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03023~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03023)~^~ -VALIDATION_ERROR_0fe017a0~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03024~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03024)~^~ -VALIDATION_ERROR_0fe017a2~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03025~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03025)~^~ -VALIDATION_ERROR_0fe017a4~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03026~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03026)~^~ -VALIDATION_ERROR_0fe017a6~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03027~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03027)~^~ -VALIDATION_ERROR_0fe017a8~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03028~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03028)~^~ -VALIDATION_ERROR_0fe017aa~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03029~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stagess and and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03029)~^~ -VALIDATION_ERROR_0fe017ac~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03030~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03030)~^~ -VALIDATION_ERROR_0fe017ae~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03031~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03031)~^~ -VALIDATION_ERROR_0fe017b0~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03032~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03032)~^~ -VALIDATION_ERROR_0fe017b2~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03033~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03033)~^~ -VALIDATION_ERROR_0fe017b4~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03034~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03034)~^~ -VALIDATION_ERROR_0fe017b6~^~N~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-descriptorType-03035~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03035)~^~ -VALIDATION_ERROR_0fe017b8~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036)~^~ -VALIDATION_ERROR_0fe017ba~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stagess and and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037)~^~ -VALIDATION_ERROR_0fe017bc~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038)~^~ -VALIDATION_ERROR_0fe017be~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039)~^~ -VALIDATION_ERROR_0fe017c0~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040)~^~ -VALIDATION_ERROR_0fe017c2~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041)~^~ -VALIDATION_ERROR_0fe017c4~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042)~^~ -VALIDATION_ERROR_0fe017c6~^~Y~^~None~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043)~^~ -VALIDATION_ERROR_0fe09005~^~Y~^~Unknown~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fe1c40d~^~Y~^~Unknown~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0fe1f801~^~Y~^~Unknown~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter~^~core~^~The spec valid usage text states 'If pushConstantRangeCount is not 0, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter)~^~implicit -VALIDATION_ERROR_0fe22c01~^~Y~^~InvalidDescriptorSetLayout~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter~^~core~^~The spec valid usage text states 'If setLayoutCount is not 0, pSetLayouts must be a valid pointer to an array of setLayoutCount valid VkDescriptorSetLayout handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter)~^~implicit -VALIDATION_ERROR_0fe2b00b~^~Y~^~Unknown~^~VkPipelineLayoutCreateInfo~^~VUID-VkPipelineLayoutCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10000620~^~Y~^~InvalidPipelineSampleRateFeatureDisable~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784~^~core~^~The spec valid usage text states 'If the sample rate shading feature is not enabled, sampleShadingEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784)~^~ -VALIDATION_ERROR_10000622~^~Y~^~None~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785~^~core~^~The spec valid usage text states 'If the alpha to one feature is not enabled, alphaToOneEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785)~^~ -VALIDATION_ERROR_10000624~^~Y~^~InvalidPipelineSampleRateFeatureEnable~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786~^~core~^~The spec valid usage text states 'minSampleShading must be in the range [0,1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786)~^~ -VALIDATION_ERROR_10000b0e~^~N~^~None~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'If the subpass has any color attachments and rasterizationSamples is greater than the number of color samples, then sampleShadingEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415)~^~ -VALIDATION_ERROR_10009005~^~Y~^~Unknown~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1001c40d~^~Y~^~InvalidPipelineSamplePNext~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, or VkPipelineSampleLocationsStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10022201~^~N~^~Unknown~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter~^~core~^~The spec valid usage text states 'If pSampleMask is not NULL, pSampleMask must be a valid pointer to an array of (lceil{mathit{rasterizationSamples} over 32}rceil) VkSampleMask values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter)~^~implicit -VALIDATION_ERROR_1002a801~^~N~^~Unknown~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter~^~core~^~The spec valid usage text states 'rasterizationSamples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter)~^~implicit -VALIDATION_ERROR_1002b00b~^~N~^~Unknown~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1002b00f~^~N~^~None~^~VkPipelineMultisampleStateCreateInfo~^~VUID-VkPipelineMultisampleStateCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_1020061c~^~Y~^~None~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782~^~core~^~The spec valid usage text states 'If the depth clamping feature is not enabled, depthClampEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782)~^~ -VALIDATION_ERROR_10200b0a~^~N~^~None~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413~^~!(VK_NV_fill_rectangle)~^~The spec valid usage text states 'If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413)~^~ -VALIDATION_ERROR_10200b0c~^~N~^~None~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414~^~(VK_NV_fill_rectangle)~^~The spec valid usage text states 'If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414)~^~ -VALIDATION_ERROR_10200bc6~^~N~^~None~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507~^~(VK_NV_fill_rectangle)~^~The spec valid usage text states 'If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507)~^~ -VALIDATION_ERROR_10203a01~^~Y~^~Unknown~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter~^~core~^~The spec valid usage text states 'cullMode must be a valid combination of VkCullModeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter)~^~implicit -VALIDATION_ERROR_10209005~^~Y~^~Unknown~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_10209801~^~Y~^~Unknown~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter~^~core~^~The spec valid usage text states 'frontFace must be a valid VkFrontFace value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter)~^~implicit -VALIDATION_ERROR_1021c40d~^~Y~^~Unknown~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT or VkPipelineRasterizationStateRasterizationOrderAMD' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_10228601~^~Y~^~Unknown~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter~^~core~^~The spec valid usage text states 'polygonMode must be a valid VkPolygonMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter)~^~implicit -VALIDATION_ERROR_1022b00b~^~Y~^~Unknown~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1022b00f~^~N~^~None~^~VkPipelineRasterizationStateCreateInfo~^~VUID-VkPipelineRasterizationStateCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_1042a601~^~N~^~Unknown~^~VkPipelineRasterizationStateRasterizationOrderAMD~^~VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter~^~(VK_AMD_rasterization_order)~^~The spec valid usage text states 'rasterizationOrder must be a valid VkRasterizationOrderAMD value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter)~^~implicit -VALIDATION_ERROR_1042b00b~^~N~^~Unknown~^~VkPipelineRasterizationStateRasterizationOrderAMD~^~VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType~^~(VK_AMD_rasterization_order)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10600580~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00704~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00704)~^~ -VALIDATION_ERROR_10600582~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00705~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00705)~^~ -VALIDATION_ERROR_10600584~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00706~^~core~^~The spec valid usage text states 'stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00706)~^~ -VALIDATION_ERROR_10600586~^~Y~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-pName-00707~^~core~^~The spec valid usage text states 'pName must be the name of an OpEntryPoint in module with an execution model that matches stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pName-00707)~^~ -VALIDATION_ERROR_10600588~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708~^~core~^~The spec valid usage text states 'If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708)~^~ -VALIDATION_ERROR_1060058a~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709~^~core~^~The spec valid usage text states 'If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709)~^~ -VALIDATION_ERROR_1060058c~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710~^~core~^~The spec valid usage text states 'If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710)~^~ -VALIDATION_ERROR_1060058e~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711~^~core~^~The spec valid usage text states 'If the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711)~^~ -VALIDATION_ERROR_10600590~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00712~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00712)~^~ -VALIDATION_ERROR_10600592~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00713~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction that specifies a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00713)~^~ -VALIDATION_ERROR_10600594~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00714~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00714)~^~ -VALIDATION_ERROR_10600596~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00715~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00715)~^~ -VALIDATION_ERROR_10600598~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00716~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00716)~^~ -VALIDATION_ERROR_1060059a~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00717~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00717)~^~ -VALIDATION_ERROR_1060059c~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00718~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00718)~^~ -VALIDATION_ERROR_1060059e~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-00719~^~core~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, it must write to FragDepth in all execution paths' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00719)~^~ -VALIDATION_ERROR_10600bce~^~N~^~None~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-01511~^~(VK_EXT_shader_stencil_export)~^~The spec valid usage text states 'If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragStencilRefEXT in any execution path, it must write to FragStencilRefEXT in all execution paths' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-01511)~^~ -VALIDATION_ERROR_10609005~^~Y~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1060d201~^~Y~^~None~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-module-parameter~^~core~^~The spec valid usage text states 'module must be a valid VkShaderModule handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-module-parameter)~^~implicit, This error applies to both vkCreateComputePipelines and vkCreateGraphicsPipelines. -VALIDATION_ERROR_1061c001~^~Y~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-pName-parameter~^~core~^~The spec valid usage text states 'pName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pName-parameter)~^~implicit -VALIDATION_ERROR_1061c40d~^~Y~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10623a01~^~N~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter~^~core~^~The spec valid usage text states 'If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter)~^~implicit -VALIDATION_ERROR_1062b00b~^~Y~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1062d801~^~Y~^~Unknown~^~VkPipelineShaderStageCreateInfo~^~VUID-VkPipelineShaderStageCreateInfo-stage-parameter~^~core~^~The spec valid usage text states 'stage must be a valid VkShaderStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1080097c~^~Y~^~CreatePipelineTessErrors~^~VkPipelineTessellationStateCreateInfo~^~VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214~^~core~^~The spec valid usage text states 'patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214)~^~ -VALIDATION_ERROR_10809005~^~Y~^~Unknown~^~VkPipelineTessellationStateCreateInfo~^~VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1081c40d~^~N~^~Unknown~^~VkPipelineTessellationStateCreateInfo~^~VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineTessellationDomainOriginStateCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1082b00b~^~Y~^~CreatePipelineTessErrors~^~VkPipelineTessellationStateCreateInfo~^~VUID-VkPipelineTessellationStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10a004ca~^~N~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613~^~core~^~The spec valid usage text states 'vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613)~^~ -VALIDATION_ERROR_10a004cc~^~N~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614~^~core~^~The spec valid usage text states 'vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614)~^~ -VALIDATION_ERROR_10a004ce~^~N~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-binding-00615~^~core~^~The spec valid usage text states 'For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription must exist in pVertexBindingDescriptions with the same value of binding' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-binding-00615)~^~ -VALIDATION_ERROR_10a004d0~^~N~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616~^~core~^~The spec valid usage text states 'All elements of pVertexBindingDescriptions must describe distinct binding numbers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616)~^~ -VALIDATION_ERROR_10a004d2~^~N~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617~^~core~^~The spec valid usage text states 'All elements of pVertexAttributeDescriptions must describe distinct attribute locations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617)~^~ -VALIDATION_ERROR_10a09005~^~Y~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10a1c40d~^~Y~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineVertexInputDivisorStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10a26401~^~Y~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter~^~core~^~The spec valid usage text states 'If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter)~^~implicit -VALIDATION_ERROR_10a26601~^~Y~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter~^~core~^~The spec valid usage text states 'If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter)~^~implicit -VALIDATION_ERROR_10a2b00b~^~Y~^~Unknown~^~VkPipelineVertexInputStateCreateInfo~^~VUID-VkPipelineVertexInputStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10c00980~^~Y~^~PSOViewportStateTests~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216~^~core~^~The spec valid usage text states 'If the multiple viewports feature is not enabled, viewportCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216)~^~ -VALIDATION_ERROR_10c00982~^~Y~^~PSOViewportStateTests~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217~^~core~^~The spec valid usage text states 'If the multiple viewports feature is not enabled, scissorCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217)~^~ -VALIDATION_ERROR_10c00984~^~Y~^~PSOViewportStateMultiViewportTests~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218~^~core~^~The spec valid usage text states 'viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218)~^~ -VALIDATION_ERROR_10c00986~^~Y~^~PSOViewportStateMultiViewportTests~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219~^~core~^~The spec valid usage text states 'scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219)~^~ -VALIDATION_ERROR_10c00988~^~Y~^~PSOViewportStateTests,PSOViewportStateMultiViewportTests~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220~^~core~^~The spec valid usage text states 'scissorCount and viewportCount must be identical' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220)~^~ -VALIDATION_ERROR_10c00d7c~^~N~^~None~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'If the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure chained to the pNext chain is VK_TRUE, the viewportCount member of the VkPipelineViewportWScalingStateCreateInfoNV structure must be equal to viewportCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726)~^~ -VALIDATION_ERROR_10c09005~^~Y~^~Unknown~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_10c1c40d~^~Y~^~Unknown~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineViewportSwizzleStateCreateInfoNV or VkPipelineViewportWScalingStateCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_10c2b00b~^~Y~^~Unknown~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_10c2b00f~^~N~^~None~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_10c2b61b~^~Y~^~PSOViewportStateMultiViewportTests~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength~^~core~^~The spec valid usage text states 'scissorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength)~^~implicit -VALIDATION_ERROR_10c30a1b~^~Y~^~PSOViewportStateMultiViewportTests~^~VkPipelineViewportStateCreateInfo~^~VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength~^~core~^~The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength)~^~implicit -VALIDATION_ERROR_10e0097e~^~N~^~Unknown~^~VkPipelineViewportSwizzleStateCreateInfoNV~^~VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'viewportCount must match the viewportCount set in VkPipelineViewportStateCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215)~^~ -VALIDATION_ERROR_10e09005~^~N~^~Unknown~^~VkPipelineViewportSwizzleStateCreateInfoNV~^~VUID-VkPipelineViewportSwizzleStateCreateInfoNV-flags-zerobitmask~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_10e2b00b~^~N~^~Unknown~^~VkPipelineViewportSwizzleStateCreateInfoNV~^~VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_10e30a1b~^~N~^~Unknown~^~VkPipelineViewportSwizzleStateCreateInfoNV~^~VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength)~^~implicit -VALIDATION_ERROR_1102b00b~^~N~^~Unknown~^~VkPipelineViewportWScalingStateCreateInfoNV~^~VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_11030a1b~^~N~^~Unknown~^~VkPipelineViewportWScalingStateCreateInfoNV~^~VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength)~^~implicit -VALIDATION_ERROR_11200009~^~Y~^~None~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Both of the elements of pSwapchains, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-commonparent)~^~implicit -VALIDATION_ERROR_11200a20~^~Y~^~Unknown~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-pImageIndices-01296~^~(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR layout at the time the operation is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPresentInfoKHR-pImageIndices-01296)~^~ -VALIDATION_ERROR_11200b2c~^~N~^~None~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-pImageIndices-01430~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pImageIndices-01430)~^~ -VALIDATION_ERROR_11218801~^~Y~^~Unknown~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-pImageIndices-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'pImageIndices must be a valid pointer to an array of swapchainCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pImageIndices-parameter)~^~implicit -VALIDATION_ERROR_1121c40d~^~Y~^~Unknown~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupPresentInfoKHR, VkDisplayPresentInfoKHR, VkPresentRegionsKHR, or VkPresentTimesInfoGOOGLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_11221e01~^~Y~^~Unknown~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-pResults-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If pResults is not NULL, pResults must be a valid pointer to an array of swapchainCount VkResult values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pResults-parameter)~^~implicit -VALIDATION_ERROR_11225801~^~Y~^~None~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-pSwapchains-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pSwapchains-parameter)~^~implicit -VALIDATION_ERROR_11227601~^~Y~^~None~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-pWaitSemaphores-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pWaitSemaphores-parameter)~^~implicit -VALIDATION_ERROR_1122b00b~^~Y~^~Unknown~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1122b00f~^~N~^~Unknown~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-sType-unique~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-sType-unique)~^~implicit -VALIDATION_ERROR_1122f21b~^~Y~^~Unknown~^~VkPresentInfoKHR~^~VUID-VkPresentInfoKHR-swapchainCount-arraylength~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-swapchainCount-arraylength)~^~implicit -VALIDATION_ERROR_11420c01~^~N~^~Unknown~^~VkPresentRegionKHR~^~VUID-VkPresentRegionKHR-pRectangles-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)~^~The spec valid usage text states 'If rectangleCount is not 0, and pRectangles is not NULL, pRectangles must be a valid pointer to an array of rectangleCount VkRectLayerKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionKHR-pRectangles-parameter)~^~implicit -VALIDATION_ERROR_116009d8~^~N~^~Unknown~^~VkPresentRegionsKHR~^~VUID-VkPresentRegionsKHR-swapchainCount-01260~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)~^~The spec valid usage text states 'swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext-chain of this VkPresentRegionsKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-swapchainCount-01260)~^~ -VALIDATION_ERROR_11621001~^~N~^~Unknown~^~VkPresentRegionsKHR~^~VUID-VkPresentRegionsKHR-pRegions-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)~^~The spec valid usage text states 'If pRegions is not NULL, pRegions must be a valid pointer to an array of swapchainCount valid VkPresentRegionKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-pRegions-parameter)~^~implicit -VALIDATION_ERROR_1162b00b~^~N~^~Unknown~^~VkPresentRegionsKHR~^~VUID-VkPresentRegionsKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-sType-sType)~^~implicit -VALIDATION_ERROR_1162f21b~^~N~^~Unknown~^~VkPresentRegionsKHR~^~VUID-VkPresentRegionsKHR-swapchainCount-arraylength~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)~^~The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-swapchainCount-arraylength)~^~implicit -VALIDATION_ERROR_118009be~^~Y~^~Unknown~^~VkPresentTimesInfoGOOGLE~^~VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext chain of this VkPresentTimesInfoGOOGLE structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247)~^~ -VALIDATION_ERROR_11825e01~^~N~^~Unknown~^~VkPresentTimesInfoGOOGLE~^~VUID-VkPresentTimesInfoGOOGLE-pTimes-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'If pTimes is not NULL, pTimes must be a valid pointer to an array of swapchainCount VkPresentTimeGOOGLE structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-pTimes-parameter)~^~implicit -VALIDATION_ERROR_1182b00b~^~N~^~Unknown~^~VkPresentTimesInfoGOOGLE~^~VUID-VkPresentTimesInfoGOOGLE-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-sType-sType)~^~implicit -VALIDATION_ERROR_1182f21b~^~N~^~Unknown~^~VkPresentTimesInfoGOOGLE~^~VUID-VkPresentTimesInfoGOOGLE-swapchainCount-arraylength~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-swapchainCount-arraylength)~^~implicit -VALIDATION_ERROR_11a0024c~^~Y~^~InvalidPushConstants~^~VkPushConstantRange~^~VUID-VkPushConstantRange-offset-00294~^~core~^~The spec valid usage text states 'offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-offset-00294)~^~ -VALIDATION_ERROR_11a0024e~^~Y~^~Unknown~^~VkPushConstantRange~^~VUID-VkPushConstantRange-offset-00295~^~core~^~The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-offset-00295)~^~ -VALIDATION_ERROR_11a00250~^~Y~^~InvalidPushConstants~^~VkPushConstantRange~^~VUID-VkPushConstantRange-size-00296~^~core~^~The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-size-00296)~^~ -VALIDATION_ERROR_11a00252~^~Y~^~InvalidPushConstants~^~VkPushConstantRange~^~VUID-VkPushConstantRange-size-00297~^~core~^~The spec valid usage text states 'size must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-size-00297)~^~ -VALIDATION_ERROR_11a00254~^~Y~^~InvalidPushConstants~^~VkPushConstantRange~^~VUID-VkPushConstantRange-size-00298~^~core~^~The spec valid usage text states 'size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-size-00298)~^~ -VALIDATION_ERROR_11a2dc01~^~N~^~Unknown~^~VkPushConstantRange~^~VUID-VkPushConstantRange-stageFlags-parameter~^~core~^~The spec valid usage text states 'stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-stageFlags-parameter)~^~implicit -VALIDATION_ERROR_11a2dc03~^~Y~^~Unknown~^~VkPushConstantRange~^~VUID-VkPushConstantRange-stageFlags-requiredbitmask~^~core~^~The spec valid usage text states 'stageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-stageFlags-requiredbitmask)~^~implicit -VALIDATION_ERROR_11c0062e~^~Y~^~InvalidQueryPoolCreate~^~VkQueryPoolCreateInfo~^~VUID-VkQueryPoolCreateInfo-queryType-00791~^~core~^~The spec valid usage text states 'If the pipeline statistics queries feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-00791)~^~ -VALIDATION_ERROR_11c00630~^~Y~^~Unknown~^~VkQueryPoolCreateInfo~^~VUID-VkQueryPoolCreateInfo-queryType-00792~^~core~^~The spec valid usage text states 'If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-00792)~^~ -VALIDATION_ERROR_11c09005~^~Y~^~Unknown~^~VkQueryPoolCreateInfo~^~VUID-VkQueryPoolCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_11c1c40d~^~Y~^~Unknown~^~VkQueryPoolCreateInfo~^~VUID-VkQueryPoolCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_11c29a01~^~Y~^~Unknown~^~VkQueryPoolCreateInfo~^~VUID-VkQueryPoolCreateInfo-queryType-parameter~^~core~^~The spec valid usage text states 'queryType must be a valid VkQueryType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-parameter)~^~implicit -VALIDATION_ERROR_11c2b00b~^~Y~^~Unknown~^~VkQueryPoolCreateInfo~^~VUID-VkQueryPoolCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_11e009da~^~Y~^~None~^~VkRectLayerKHR~^~VUID-VkRectLayerKHR-offset-01261~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)~^~The spec valid usage text states 'The sum of offset and extent must be no greater than the imageExtent member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRectLayerKHR-offset-01261)~^~ -VALIDATION_ERROR_11e009dc~^~Y~^~None~^~VkRectLayerKHR~^~VUID-VkRectLayerKHR-layer-01262~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)~^~The spec valid usage text states 'layer must be less than imageArrayLayers member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRectLayerKHR-layer-01262)~^~ -VALIDATION_ERROR_12000009~^~Y~^~Unknown~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-commonparent~^~core~^~The spec valid usage text states 'Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-commonparent)~^~implicit -VALIDATION_ERROR_1200070c~^~Y~^~RenderPassClearOpMismatch~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-clearValueCount-00902~^~core~^~The spec valid usage text states 'clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-clearValueCount-00902)~^~ -VALIDATION_ERROR_1200070e~^~N~^~Unknown~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-clearValueCount-00903~^~core~^~The spec valid usage text states 'If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount valid VkClearValue unions' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-clearValueCount-00903)~^~ -VALIDATION_ERROR_12000710~^~Y~^~Unknown~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-renderPass-00904~^~core~^~The spec valid usage text states 'renderPass must be compatible with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-renderPass-00904)~^~ -VALIDATION_ERROR_12009401~^~Y~^~None~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-framebuffer-parameter~^~core~^~The spec valid usage text states 'framebuffer must be a valid VkFramebuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-parameter)~^~implicit -VALIDATION_ERROR_1201c40d~^~Y~^~Unknown~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo or VkRenderPassSampleLocationsBeginInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_1202ae01~^~Y~^~None~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-renderPass-parameter~^~core~^~The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-renderPass-parameter)~^~implicit -VALIDATION_ERROR_1202b00b~^~Y~^~Unknown~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1202b00f~^~N~^~None~^~VkRenderPassBeginInfo~^~VUID-VkRenderPassBeginInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-sType-unique)~^~implicit -VALIDATION_ERROR_12200680~^~N~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-None-00832~^~core~^~The spec valid usage text states 'If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-None-00832)~^~ -VALIDATION_ERROR_12200682~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-attachment-00833~^~core~^~The spec valid usage text states 'If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-attachment-00833)~^~ -VALIDATION_ERROR_12200684~^~Y~^~RenderPassAttachmentIndexOutOfRange~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-attachment-00834~^~core~^~The spec valid usage text states 'If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-attachment-00834)~^~ -VALIDATION_ERROR_12200686~^~N~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pPreserveAttachments-00835~^~core~^~The spec valid usage text states 'The value of each element of the pPreserveAttachments member in each element of pSubpasses must not be VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pPreserveAttachments-00835)~^~ -VALIDATION_ERROR_12200688~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pAttachments-00836~^~core~^~The spec valid usage text states 'For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-00836)~^~ -VALIDATION_ERROR_1220068a~^~N~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pDependencies-00837~^~core~^~The spec valid usage text states 'For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-00837)~^~ -VALIDATION_ERROR_1220068c~^~N~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pDependencies-00838~^~core~^~The spec valid usage text states 'For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-00838)~^~ -VALIDATION_ERROR_12200c3c~^~Y~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pAttachments-01566~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-01566)~^~ -VALIDATION_ERROR_12200c3e~^~Y~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pAttachments-01567~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-01567)~^~ -VALIDATION_ERROR_12200f0c~^~N~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pNext-01926~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the subpass member of each element of its pAspectReferences member must be less than subpassCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01926)~^~ -VALIDATION_ERROR_12200f0e~^~N~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pNext-01927~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the member of pSubpasses identified by its subpass member' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01927)~^~ -VALIDATION_ERROR_12200f10~^~N~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pNext-01928~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, and its subpassCount member is not zero, that member must be equal to the value of subpassCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01928)~^~ -VALIDATION_ERROR_12200f12~^~N~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pNext-01929~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, if its dependencyCount member is not zero, it must be equal to dependencyCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01929)~^~ -VALIDATION_ERROR_12200f14~^~N~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pNext-01930~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01930)~^~ -VALIDATION_ERROR_12209005~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1220f201~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pAttachments-parameter~^~core~^~The spec valid usage text states 'If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-parameter)~^~implicit -VALIDATION_ERROR_12212601~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pDependencies-parameter~^~core~^~The spec valid usage text states 'If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-parameter)~^~implicit -VALIDATION_ERROR_1221c40d~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassInputAttachmentAspectCreateInfo or VkRenderPassMultiviewCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_12224201~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-pSubpasses-parameter~^~core~^~The spec valid usage text states 'pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pSubpasses-parameter)~^~implicit -VALIDATION_ERROR_1222b00b~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1222b00f~^~N~^~None~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_1222e61b~^~Y~^~Unknown~^~VkRenderPassCreateInfo~^~VUID-VkRenderPassCreateInfo-subpassCount-arraylength~^~core~^~The spec valid usage text states 'subpassCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-subpassCount-arraylength)~^~implicit -VALIDATION_ERROR_12400692~^~N~^~Unknown~^~VkRenderPassMultiviewCreateInfo~^~VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'Each view index must not be set in more than one element of pCorrelationMasks' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841)~^~ -VALIDATION_ERROR_12411a01~^~N~^~Unknown~^~VkRenderPassMultiviewCreateInfo~^~VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If correlationMaskCount is not 0, pCorrelationMasks must be a valid pointer to an array of correlationMaskCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter)~^~implicit -VALIDATION_ERROR_12426c01~^~N~^~Unknown~^~VkRenderPassMultiviewCreateInfo~^~VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If subpassCount is not 0, pViewMasks must be a valid pointer to an array of subpassCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter)~^~implicit -VALIDATION_ERROR_12426e01~^~N~^~Unknown~^~VkRenderPassMultiviewCreateInfo~^~VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If dependencyCount is not 0, pViewOffsets must be a valid pointer to an array of dependencyCount int32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter)~^~implicit -VALIDATION_ERROR_1242b00b~^~N~^~Unknown~^~VkRenderPassMultiviewCreateInfo~^~VUID-VkRenderPassMultiviewCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_12600201~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-addressModeU-parameter~^~core~^~The spec valid usage text states 'addressModeU must be a valid VkSamplerAddressMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-parameter)~^~implicit -VALIDATION_ERROR_12600401~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-addressModeV-parameter~^~core~^~The spec valid usage text states 'addressModeV must be a valid VkSamplerAddressMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeV-parameter)~^~implicit -VALIDATION_ERROR_12600601~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-addressModeW-parameter~^~core~^~The spec valid usage text states 'addressModeW must be a valid VkSamplerAddressMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeW-parameter)~^~implicit -VALIDATION_ERROR_1260085a~^~N~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-mipLodBias-01069~^~core~^~The spec valid usage text states 'The absolute value of mipLodBias must be less than or equal to VkPhysicalDeviceLimits::maxSamplerLodBias' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-mipLodBias-01069)~^~ -VALIDATION_ERROR_1260085c~^~Y~^~AnisotropyFeatureDisabled~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-anisotropyEnable-01070~^~core~^~The spec valid usage text states 'If the anisotropic sampling feature is not enabled, anisotropyEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-anisotropyEnable-01070)~^~ -VALIDATION_ERROR_1260085e~^~Y~^~AnisotropyFeatureEnabled~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-anisotropyEnable-01071~^~core~^~The spec valid usage text states 'If anisotropyEnable is VK_TRUE, maxAnisotropy must be between 1.0 and VkPhysicalDeviceLimits::maxSamplerAnisotropy, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-anisotropyEnable-01071)~^~ -VALIDATION_ERROR_12600860~^~N~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072~^~core~^~The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, minFilter and magFilter must be equal' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072)~^~ -VALIDATION_ERROR_12600862~^~N~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073~^~core~^~The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073)~^~ -VALIDATION_ERROR_12600864~^~N~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074~^~core~^~The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, minLod and maxLod must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074)~^~ -VALIDATION_ERROR_12600866~^~N~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075~^~core~^~The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075)~^~ -VALIDATION_ERROR_12600868~^~Y~^~AnisotropyFeatureEnabled~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076~^~core~^~The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, anisotropyEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076)~^~ -VALIDATION_ERROR_1260086a~^~N~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077~^~core~^~The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, compareEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077)~^~ -VALIDATION_ERROR_1260086c~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-addressModeU-01078~^~core~^~The spec valid usage text states 'If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a valid VkBorderColor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-01078)~^~ -VALIDATION_ERROR_1260086e~^~Y~^~MirrorClampToEdgeNotEnabled~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-addressModeU-01079~^~core~^~The spec valid usage text states 'If the VK_KHR_sampler_mirror_clamp_to_edge extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-01079)~^~ -VALIDATION_ERROR_12600870~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-compareEnable-01080~^~core~^~The spec valid usage text states 'If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-compareEnable-01080)~^~ -VALIDATION_ERROR_12600872~^~Y~^~AnisotropyFeatureEnabled~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-magFilter-01081~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, anisotropyEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-magFilter-01081)~^~ -VALIDATION_ERROR_12600b1c~^~N~^~None~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-magFilter-01422~^~(VK_IMG_filter_cubic+VK_EXT_sampler_filter_minmax)~^~The spec valid usage text states 'If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-magFilter-01422)~^~ -VALIDATION_ERROR_12600b1e~^~N~^~None~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-compareEnable-01423~^~(VK_EXT_sampler_filter_minmax)~^~The spec valid usage text states 'If compareEnable is VK_TRUE, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-compareEnable-01423)~^~ -VALIDATION_ERROR_12600cda~^~N~^~None~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-minFilter-01645~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If sampler Y'CBCR conversion is enabled and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT is not set for the format, minFilter and magFilter must be equal to the sampler Y'CBCR conversion's chromaFilter' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-minFilter-01645)~^~ -VALIDATION_ERROR_12600cdc~^~N~^~None~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-addressModeU-01646~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If sampler Y'CBCR conversion is enabled, addressModeU, addressModeV, and addressModeW must be VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE, and unnormalizedCoordinates must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-01646)~^~ -VALIDATION_ERROR_12600cde~^~N~^~None~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-None-01647~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_sampler_filter_minmax)~^~The spec valid usage text states 'The sampler reduction mode must be set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT if sampler Y'CBCR conversion is enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-None-01647)~^~ -VALIDATION_ERROR_12609005~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1260c401~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-magFilter-parameter~^~core~^~The spec valid usage text states 'magFilter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-magFilter-parameter)~^~implicit -VALIDATION_ERROR_1260ca01~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-minFilter-parameter~^~core~^~The spec valid usage text states 'minFilter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-minFilter-parameter)~^~implicit -VALIDATION_ERROR_1260cc01~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-mipmapMode-parameter~^~core~^~The spec valid usage text states 'mipmapMode must be a valid VkSamplerMipmapMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-mipmapMode-parameter)~^~implicit -VALIDATION_ERROR_1261c40d~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSamplerReductionModeCreateInfoEXT or VkSamplerYcbcrConversionInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1262b00b~^~Y~^~Unknown~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1262b00f~^~N~^~None~^~VkSamplerCreateInfo~^~VUID-VkSamplerCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_12809005~^~Y~^~Unknown~^~VkSemaphoreCreateInfo~^~VUID-VkSemaphoreCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1281c40d~^~Y~^~Unknown~^~VkSemaphoreCreateInfo~^~VUID-VkSemaphoreCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportSemaphoreCreateInfo or VkExportSemaphoreWin32HandleInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1282b00b~^~Y~^~Unknown~^~VkSemaphoreCreateInfo~^~VUID-VkSemaphoreCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1282b00f~^~N~^~None~^~VkSemaphoreCreateInfo~^~VUID-VkSemaphoreCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-sType-unique)~^~implicit -VALIDATION_ERROR_12a0087a~^~N~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-codeSize-01085~^~core~^~The spec valid usage text states 'codeSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01085)~^~ -VALIDATION_ERROR_12a0087c~^~N~^~None~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-codeSize-01086~^~!(VK_NV_glsl_shader)~^~The spec valid usage text states 'codeSize must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01086)~^~ -VALIDATION_ERROR_12a0087e~^~N~^~None~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01087~^~!(VK_NV_glsl_shader)~^~The spec valid usage text states 'pCode must point to valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01087)~^~ -VALIDATION_ERROR_12a00880~^~N~^~None~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01088~^~!(VK_NV_glsl_shader)~^~The spec valid usage text states 'pCode must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01088)~^~ -VALIDATION_ERROR_12a00882~^~N~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01089~^~core~^~The spec valid usage text states 'pCode must declare the Shader capability for SPIR-V code' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01089)~^~ -VALIDATION_ERROR_12a00884~^~N~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01090~^~core~^~The spec valid usage text states 'pCode must not declare any capability that is not supported by the API, as described by the Capabilities section of the SPIR-V Environment appendix' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01090)~^~ -VALIDATION_ERROR_12a00886~^~N~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01091~^~core~^~The spec valid usage text states 'If pCode declares any of the capabilities listed as optional in the SPIR-V Environment appendix, the corresponding feature(s) must be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01091)~^~ -VALIDATION_ERROR_12a00ac0~^~Y~^~InvalidSPIRVCodeSize~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01376~^~(VK_NV_glsl_shader)~^~The spec valid usage text states 'If pCode points to SPIR-V code, codeSize must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01376)~^~ -VALIDATION_ERROR_12a00ac2~^~N~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01377~^~(VK_NV_glsl_shader)~^~The spec valid usage text states 'pCode must point to either valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification or valid GLSL code which must be written to the GL_KHR_vulkan_glsl extension specification' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01377)~^~ -VALIDATION_ERROR_12a00ac4~^~N~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01378~^~(VK_NV_glsl_shader)~^~The spec valid usage text states 'If pCode points to SPIR-V code, that code must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01378)~^~ -VALIDATION_ERROR_12a00ac6~^~N~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-01379~^~(VK_NV_glsl_shader)~^~The spec valid usage text states 'If pCode points to GLSL code, it must be valid GLSL code written to the GL_KHR_vulkan_glsl GLSL extension specification' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01379)~^~ -VALIDATION_ERROR_12a09005~^~Y~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_12a10c01~^~Y~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pCode-parameter~^~core~^~The spec valid usage text states 'pCode must be a valid pointer to an array of (codeSize over 4) uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-parameter)~^~implicit -VALIDATION_ERROR_12a1c40d~^~Y~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkShaderModuleValidationCacheCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_12a2b00b~^~Y~^~Unknown~^~VkShaderModuleCreateInfo~^~VUID-VkShaderModuleCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_12c0141b~^~Y~^~Unknown~^~VkSparseBufferMemoryBindInfo~^~VUID-VkSparseBufferMemoryBindInfo-bindCount-arraylength~^~core~^~The spec valid usage text states 'bindCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseBufferMemoryBindInfo-bindCount-arraylength)~^~implicit -VALIDATION_ERROR_12c01a01~^~Y~^~Unknown~^~VkSparseBufferMemoryBindInfo~^~VUID-VkSparseBufferMemoryBindInfo-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseBufferMemoryBindInfo-buffer-parameter)~^~implicit -VALIDATION_ERROR_12c0fe01~^~Y~^~Unknown~^~VkSparseBufferMemoryBindInfo~^~VUID-VkSparseBufferMemoryBindInfo-pBinds-parameter~^~core~^~The spec valid usage text states 'pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseBufferMemoryBindInfo-pBinds-parameter)~^~implicit -VALIDATION_ERROR_12e008a0~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-memory-01104~^~core~^~The spec valid usage text states 'If the sparse aliased residency feature is not enabled, and if any other resources are bound to ranges of memory, the range of memory being bound must not overlap with those bound ranges' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-memory-01104)~^~ -VALIDATION_ERROR_12e008a2~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-memory-01105~^~core~^~The spec valid usage text states 'memory and memoryOffset must match the memory requirements of the calling command's image, as described in section resources-association' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-memory-01105)~^~ -VALIDATION_ERROR_12e008a4~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-subresource-01106~^~core~^~The spec valid usage text states 'subresource must be a valid image subresource for image (see resources-image-views)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-subresource-01106)~^~ -VALIDATION_ERROR_12e008a6~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-offset-01107~^~core~^~The spec valid usage text states 'offset.x must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-offset-01107)~^~ -VALIDATION_ERROR_12e008a8~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-extent-01108~^~core~^~The spec valid usage text states 'extent.width must either be a multiple of the sparse image block width of the image, or else (extent.width + offset.x) must equal the width of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-extent-01108)~^~ -VALIDATION_ERROR_12e008aa~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-offset-01109~^~core~^~The spec valid usage text states 'offset.y must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-offset-01109)~^~ -VALIDATION_ERROR_12e008ac~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-extent-01110~^~core~^~The spec valid usage text states 'extent.height must either be a multiple of the sparse image block height of the image, or else (extent.height + offset.y) must equal the height of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-extent-01110)~^~ -VALIDATION_ERROR_12e008ae~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-offset-01111~^~core~^~The spec valid usage text states 'offset.z must be a multiple of the sparse image block depth (VkSparseImageFormatProperties::imageGranularity.depth) of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-offset-01111)~^~ -VALIDATION_ERROR_12e008b0~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-extent-01112~^~core~^~The spec valid usage text states 'extent.depth must either be a multiple of the sparse image block depth of the image, or else (extent.depth + offset.z) must equal the depth of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-extent-01112)~^~ -VALIDATION_ERROR_12e09001~^~Y~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkSparseMemoryBindFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_12e0c601~^~Y~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-memory-parameter~^~core~^~The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-memory-parameter)~^~implicit -VALIDATION_ERROR_12e2e801~^~N~^~Unknown~^~VkSparseImageMemoryBind~^~VUID-VkSparseImageMemoryBind-subresource-parameter~^~core~^~The spec valid usage text states 'subresource must be a valid VkImageSubresource structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-subresource-parameter)~^~implicit -VALIDATION_ERROR_13000d74~^~N~^~None~^~VkSparseImageMemoryBindInfo~^~VUID-VkSparseImageMemoryBindInfo-subresource-01722~^~core~^~The spec valid usage text states 'The subresource.mipLevel member of each element of pBinds must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-subresource-01722)~^~ -VALIDATION_ERROR_13000d76~^~N~^~None~^~VkSparseImageMemoryBindInfo~^~VUID-VkSparseImageMemoryBindInfo-subresource-01723~^~core~^~The spec valid usage text states 'The subresource.arrayLayer member of each element of pBinds must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-subresource-01723)~^~ -VALIDATION_ERROR_1300141b~^~Y~^~Unknown~^~VkSparseImageMemoryBindInfo~^~VUID-VkSparseImageMemoryBindInfo-bindCount-arraylength~^~core~^~The spec valid usage text states 'bindCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-bindCount-arraylength)~^~implicit -VALIDATION_ERROR_1300a001~^~Y~^~Unknown~^~VkSparseImageMemoryBindInfo~^~VUID-VkSparseImageMemoryBindInfo-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-image-parameter)~^~implicit -VALIDATION_ERROR_1300fe01~^~Y~^~Unknown~^~VkSparseImageMemoryBindInfo~^~VUID-VkSparseImageMemoryBindInfo-pBinds-parameter~^~core~^~The spec valid usage text states 'pBinds must be a valid pointer to an array of bindCount valid VkSparseImageMemoryBind structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-pBinds-parameter)~^~implicit -VALIDATION_ERROR_1320089e~^~N~^~Unknown~^~VkSparseImageOpaqueMemoryBindInfo~^~VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103~^~core~^~The spec valid usage text states 'If the flags member of any element of pBinds contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must be within the mip tail region of the metadata aspect of image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103)~^~ -VALIDATION_ERROR_1320141b~^~Y~^~Unknown~^~VkSparseImageOpaqueMemoryBindInfo~^~VUID-VkSparseImageOpaqueMemoryBindInfo-bindCount-arraylength~^~core~^~The spec valid usage text states 'bindCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-bindCount-arraylength)~^~implicit -VALIDATION_ERROR_1320a001~^~Y~^~Unknown~^~VkSparseImageOpaqueMemoryBindInfo~^~VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter)~^~implicit -VALIDATION_ERROR_1320fe01~^~Y~^~Unknown~^~VkSparseImageOpaqueMemoryBindInfo~^~VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-parameter~^~core~^~The spec valid usage text states 'pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-parameter)~^~implicit -VALIDATION_ERROR_13400890~^~N~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-memory-01096~^~core~^~The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory and memoryOffset must match the memory requirements of the resource, as described in section resources-association' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memory-01096)~^~ -VALIDATION_ERROR_13400892~^~N~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-memory-01097~^~core~^~The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must not have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memory-01097)~^~ -VALIDATION_ERROR_13400894~^~N~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-size-01098~^~core~^~The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-size-01098)~^~ -VALIDATION_ERROR_13400896~^~N~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-resourceOffset-01099~^~core~^~The spec valid usage text states 'resourceOffset must be less than the size of the resource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-resourceOffset-01099)~^~ -VALIDATION_ERROR_13400898~^~N~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-size-01100~^~core~^~The spec valid usage text states 'size must be less than or equal to the size of the resource minus resourceOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-size-01100)~^~ -VALIDATION_ERROR_1340089a~^~N~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-memoryOffset-01101~^~core~^~The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memoryOffset-01101)~^~ -VALIDATION_ERROR_1340089c~^~N~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-size-01102~^~core~^~The spec valid usage text states 'size must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-size-01102)~^~ -VALIDATION_ERROR_13409001~^~Y~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkSparseMemoryBindFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1340c601~^~Y~^~Unknown~^~VkSparseMemoryBind~^~VUID-VkSparseMemoryBind-memory-parameter~^~core~^~The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memory-parameter)~^~implicit -VALIDATION_ERROR_1360060a~^~N~^~Unknown~^~VkSpecializationInfo~^~VUID-VkSpecializationInfo-offset-00773~^~core~^~The spec valid usage text states 'The offset member of each element of pMapEntries must be less than dataSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-offset-00773)~^~ -VALIDATION_ERROR_1360060c~^~Y~^~Unknown~^~VkSpecializationInfo~^~VUID-VkSpecializationInfo-pMapEntries-00774~^~core~^~The spec valid usage text states 'The size member of each element of pMapEntries must be less than or equal to dataSize minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-pMapEntries-00774)~^~ -VALIDATION_ERROR_1360060e~^~N~^~Unknown~^~VkSpecializationInfo~^~VUID-VkSpecializationInfo-mapEntryCount-00775~^~core~^~The spec valid usage text states 'If mapEntryCount is not 0, pMapEntries must be a valid pointer to an array of mapEntryCount valid VkSpecializationMapEntry structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-mapEntryCount-00775)~^~ -VALIDATION_ERROR_13612201~^~Y~^~Unknown~^~VkSpecializationInfo~^~VUID-VkSpecializationInfo-pData-parameter~^~core~^~The spec valid usage text states 'If dataSize is not 0, pData must be a valid pointer to an array of dataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-pData-parameter)~^~implicit -VALIDATION_ERROR_13800610~^~N~^~Unknown~^~VkSpecializationMapEntry~^~VUID-VkSpecializationMapEntry-constantID-00776~^~core~^~The spec valid usage text states 'For a constantID specialization constant declared in a shader, size must match the byte size of the constantID. If the specialization constant is of type boolean, size must be the byte size of VkBool32' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationMapEntry-constantID-00776)~^~ -VALIDATION_ERROR_13a02a01~^~N~^~Unknown~^~VkStencilOpState~^~VUID-VkStencilOpState-compareOp-parameter~^~core~^~The spec valid usage text states 'compareOp must be a valid VkCompareOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-compareOp-parameter)~^~implicit -VALIDATION_ERROR_13a04201~^~Y~^~Unknown~^~VkStencilOpState~^~VUID-VkStencilOpState-depthFailOp-parameter~^~core~^~The spec valid usage text states 'depthFailOp must be a valid VkStencilOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-depthFailOp-parameter)~^~implicit -VALIDATION_ERROR_13a08601~^~Y~^~Unknown~^~VkStencilOpState~^~VUID-VkStencilOpState-failOp-parameter~^~core~^~The spec valid usage text states 'failOp must be a valid VkStencilOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-failOp-parameter)~^~implicit -VALIDATION_ERROR_13a27801~^~Y~^~Unknown~^~VkStencilOpState~^~VUID-VkStencilOpState-passOp-parameter~^~core~^~The spec valid usage text states 'passOp must be a valid VkStencilOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-passOp-parameter)~^~implicit -VALIDATION_ERROR_13c00009~^~Y~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-commonparent~^~core~^~The spec valid usage text states 'Each of the elements of pCommandBuffers, the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-commonparent)~^~implicit -VALIDATION_ERROR_13c00096~^~N~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pCommandBuffers-00075~^~core~^~The spec valid usage text states 'Each element of pCommandBuffers must not have been allocated with VK_COMMAND_BUFFER_LEVEL_SECONDARY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pCommandBuffers-00075)~^~ -VALIDATION_ERROR_13c00098~^~Y~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pWaitDstStageMask-00076~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00076)~^~ -VALIDATION_ERROR_13c0009a~^~Y~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pWaitDstStageMask-00077~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00077)~^~ -VALIDATION_ERROR_13c0009c~^~N~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pWaitDstStageMask-00078~^~core~^~The spec valid usage text states 'Each element of pWaitDstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00078)~^~ -VALIDATION_ERROR_13c11401~^~Y~^~None~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pCommandBuffers-parameter~^~core~^~The spec valid usage text states 'If commandBufferCount is not 0, pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pCommandBuffers-parameter)~^~implicit -VALIDATION_ERROR_13c1c40d~^~Y~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfo, VkProtectedSubmitInfo, VkWin32KeyedMutexAcquireReleaseInfoKHR, or VkWin32KeyedMutexAcquireReleaseInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_13c23401~^~Y~^~None~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pSignalSemaphores-parameter~^~core~^~The spec valid usage text states 'If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pSignalSemaphores-parameter)~^~implicit -VALIDATION_ERROR_13c27001~^~N~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pWaitDstStageMask-parameter~^~core~^~The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitDstStageMask must be a valid pointer to an array of waitSemaphoreCount valid combinations of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-parameter)~^~implicit -VALIDATION_ERROR_13c27003~^~N~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask~^~core~^~The spec valid usage text states 'Each element of pWaitDstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_13c27601~^~Y~^~None~^~VkSubmitInfo~^~VUID-VkSubmitInfo-pWaitSemaphores-parameter~^~core~^~The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitSemaphores-parameter)~^~implicit -VALIDATION_ERROR_13c2b00b~^~N~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SUBMIT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_13c2b00f~^~N~^~Unknown~^~VkSubmitInfo~^~VUID-VkSubmitInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-sType-unique)~^~implicit -VALIDATION_ERROR_13e006b4~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcSubpass-00858~^~core~^~The spec valid usage text states 'If srcSubpass is not VK_SUBPASS_EXTERNAL, srcStageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00858)~^~ -VALIDATION_ERROR_13e006b6~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dstSubpass-00859~^~core~^~The spec valid usage text states 'If dstSubpass is not VK_SUBPASS_EXTERNAL, dstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstSubpass-00859)~^~ -VALIDATION_ERROR_13e006b8~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcStageMask-00860~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-00860)~^~ -VALIDATION_ERROR_13e006ba~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dstStageMask-00861~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-00861)~^~ -VALIDATION_ERROR_13e006bc~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcStageMask-00862~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-00862)~^~ -VALIDATION_ERROR_13e006be~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dstStageMask-00863~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-00863)~^~ -VALIDATION_ERROR_13e006c0~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcSubpass-00864~^~core~^~The spec valid usage text states 'srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00864)~^~ -VALIDATION_ERROR_13e006c2~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcSubpass-00865~^~core~^~The spec valid usage text states 'srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00865)~^~ -VALIDATION_ERROR_13e006c4~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcSubpass-00866~^~core~^~The spec valid usage text states 'If srcSubpass is equal to dstSubpass, srcStageMask and dstStageMask must only contain one of VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, or VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00866)~^~ -VALIDATION_ERROR_13e006c6~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcSubpass-00867~^~core~^~The spec valid usage text states 'If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00867)~^~ -VALIDATION_ERROR_13e006c8~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcAccessMask-00868~^~core~^~The spec valid usage text states 'Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcAccessMask-00868)~^~ -VALIDATION_ERROR_13e006ca~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dstAccessMask-00869~^~core~^~The spec valid usage text states 'Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstAccessMask-00869)~^~ -VALIDATION_ERROR_13e006cc~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dependencyFlags-00870~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then both srcSubpass and dstSubpass must not equal VK_SUBPASS_EXTERNAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDependency-dependencyFlags-00870)~^~ -VALIDATION_ERROR_13e006ce~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dependencyFlags-00871~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then the render pass must have multiview enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDependency-dependencyFlags-00871)~^~ -VALIDATION_ERROR_13e006d0~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcSubpass-00872~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00872)~^~ -VALIDATION_ERROR_13e03e01~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dependencyFlags-parameter~^~core~^~The spec valid usage text states 'dependencyFlags must be a valid combination of VkDependencyFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dependencyFlags-parameter)~^~implicit -VALIDATION_ERROR_13e06801~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dstAccessMask-parameter~^~core~^~The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstAccessMask-parameter)~^~implicit -VALIDATION_ERROR_13e07801~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dstStageMask-parameter~^~core~^~The spec valid usage text states 'dstStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-parameter)~^~implicit -VALIDATION_ERROR_13e07803~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-dstStageMask-requiredbitmask~^~core~^~The spec valid usage text states 'dstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_13e2c401~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcAccessMask-parameter~^~core~^~The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcAccessMask-parameter)~^~implicit -VALIDATION_ERROR_13e2d401~^~N~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcStageMask-parameter~^~core~^~The spec valid usage text states 'srcStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-parameter)~^~implicit -VALIDATION_ERROR_13e2d403~^~Y~^~Unknown~^~VkSubpassDependency~^~VUID-VkSubpassDependency-srcStageMask-requiredbitmask~^~core~^~The spec valid usage text states 'srcStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_14000698~^~Y~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pipelineBindPoint-00844~^~core~^~The spec valid usage text states 'pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pipelineBindPoint-00844)~^~ -VALIDATION_ERROR_1400069a~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-colorAttachmentCount-00845~^~core~^~The spec valid usage text states 'colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-colorAttachmentCount-00845)~^~ -VALIDATION_ERROR_1400069c~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-loadOp-00846~^~core~^~The spec valid usage text states 'If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-loadOp-00846)~^~ -VALIDATION_ERROR_1400069e~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pResolveAttachments-00847~^~core~^~The spec valid usage text states 'If pResolveAttachments is not NULL, for each resolve attachment that does not have the value VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have the value VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00847)~^~ -VALIDATION_ERROR_140006a0~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pResolveAttachments-00848~^~core~^~The spec valid usage text states 'If pResolveAttachments is not NULL, the sample count of each element of pColorAttachments must be anything other than VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00848)~^~ -VALIDATION_ERROR_140006a2~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pResolveAttachments-00849~^~core~^~The spec valid usage text states 'Each element of pResolveAttachments must have a sample count of VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00849)~^~ -VALIDATION_ERROR_140006a4~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pResolveAttachments-00850~^~core~^~The spec valid usage text states 'Each element of pResolveAttachments must have the same VkFormat as its corresponding color attachment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00850)~^~ -VALIDATION_ERROR_140006a8~^~N~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-None-00852~^~core~^~The spec valid usage text states 'If any input attachments are VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass must not access those input attachments from the fragment shader' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-None-00852)~^~ -VALIDATION_ERROR_140006aa~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-attachment-00853~^~core~^~The spec valid usage text states 'The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-attachment-00853)~^~ -VALIDATION_ERROR_140006ac~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pPreserveAttachments-00854~^~core~^~The spec valid usage text states 'Each element of pPreserveAttachments must not also be an element of any other member of the subpass description' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pPreserveAttachments-00854)~^~ -VALIDATION_ERROR_140006ae~^~Y~^~CreateRenderPassAttachments~^~VkSubpassDescription~^~VUID-VkSubpassDescription-layout-00855~^~core~^~The spec valid usage text states 'If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same layout' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-layout-00855)~^~ -VALIDATION_ERROR_140006b0~^~N~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-flags-00856~^~(VK_NVX_multiview_per_view_attributes)~^~The spec valid usage text states 'If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDescription-flags-00856)~^~ -VALIDATION_ERROR_14000b12~^~N~^~None~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pColorAttachments-01417~^~core~^~The spec valid usage text states 'All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pColorAttachments-01417)~^~ -VALIDATION_ERROR_14000b14~^~N~^~None~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pDepthStencilAttachment-01418~^~!(VK_AMD_mixed_attachment_samples)+!(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'If pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pDepthStencilAttachment-01418)~^~ -VALIDATION_ERROR_14000bc4~^~Y~^~None~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pColorAttachments-01506~^~(VK_AMD_mixed_attachment_samples)~^~The spec valid usage text states 'All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDescription-pColorAttachments-01506)~^~ -VALIDATION_ERROR_14009001~^~Y~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkSubpassDescriptionFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-flags-parameter)~^~implicit -VALIDATION_ERROR_14011001~^~Y~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pColorAttachments-parameter~^~core~^~The spec valid usage text states 'If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pColorAttachments-parameter)~^~implicit -VALIDATION_ERROR_14012a01~^~N~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pDepthStencilAttachment-parameter~^~core~^~The spec valid usage text states 'If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pDepthStencilAttachment-parameter)~^~implicit -VALIDATION_ERROR_14019a01~^~Y~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pInputAttachments-parameter~^~core~^~The spec valid usage text states 'If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pInputAttachments-parameter)~^~implicit -VALIDATION_ERROR_1401f001~^~Y~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pPreserveAttachments-parameter~^~core~^~The spec valid usage text states 'If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pPreserveAttachments-parameter)~^~implicit -VALIDATION_ERROR_14021c01~^~N~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pResolveAttachments-parameter~^~core~^~The spec valid usage text states 'If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-parameter)~^~implicit -VALIDATION_ERROR_14027e01~^~Y~^~Unknown~^~VkSubpassDescription~^~VUID-VkSubpassDescription-pipelineBindPoint-parameter~^~core~^~The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pipelineBindPoint-parameter)~^~implicit -VALIDATION_ERROR_142009bc~^~N~^~Unknown~^~VkSurfaceCapabilities2EXT~^~VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246~^~(VK_KHR_surface)+(VK_EXT_display_surface_counter)~^~The spec valid usage text states 'supportedSurfaceCounters must not include VK_SURFACE_COUNTER_VBLANK_EXT unless the surface queried is a display surface.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246)~^~ -VALIDATION_ERROR_1421c40d~^~N~^~None~^~VkSurfaceCapabilities2EXT~^~VUID-VkSurfaceCapabilities2EXT-pNext-pNext~^~(VK_KHR_surface)+(VK_EXT_display_surface_counter)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2EXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_1422b00b~^~Y~^~None~^~VkSurfaceCapabilities2EXT~^~VUID-VkSurfaceCapabilities2EXT-sType-sType~^~(VK_KHR_surface)+(VK_EXT_display_surface_counter)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2EXT-sType-sType)~^~implicit -VALIDATION_ERROR_144009b8~^~N~^~Unknown~^~VkSwapchainCounterCreateInfoEXT~^~VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'The bits in surfaceCounters must be supported by VkSwapchainCreateInfoKHR::surface, as reported by vkGetPhysicalDeviceSurfaceCapabilities2EXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244)~^~ -VALIDATION_ERROR_1442b00b~^~N~^~Unknown~^~VkSwapchainCounterCreateInfoEXT~^~VUID-VkSwapchainCounterCreateInfoEXT-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCounterCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_1442ee01~^~N~^~Unknown~^~VkSwapchainCounterCreateInfoEXT~^~VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'surfaceCounters must be a valid combination of VkSurfaceCounterFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter)~^~implicit -VALIDATION_ERROR_14600009~^~Y~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Both of oldSwapchain, and surface that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-commonparent)~^~implicit -VALIDATION_ERROR_146009ec~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-surface-01270~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'surface must be a surface that is supported by the device as determined using vkGetPhysicalDeviceSurfaceSupportKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-surface-01270)~^~ -VALIDATION_ERROR_146009ee~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-minImageCount-01271~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'minImageCount must be greater than or equal to the value returned in the minImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-minImageCount-01271)~^~ -VALIDATION_ERROR_146009f0~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-minImageCount-01272~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'minImageCount must be less than or equal to the value returned in the maxImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface if the returned maxImageCount is not zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-minImageCount-01272)~^~ -VALIDATION_ERROR_146009f2~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageFormat-01273~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageFormat and imageColorSpace must match the format and colorSpace members, respectively, of one of the VkSurfaceFormatKHR structures returned by vkGetPhysicalDeviceSurfaceFormatsKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageFormat-01273)~^~ -VALIDATION_ERROR_146009f4~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageExtent-01274~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageExtent must be between minImageExtent and maxImageExtent, inclusive, where minImageExtent and maxImageExtent are members of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageExtent-01274)~^~ -VALIDATION_ERROR_146009f6~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageArrayLayers must be greater than 0 and less than or equal to the maxImageArrayLayers member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275)~^~ -VALIDATION_ERROR_146009f8~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageUsage-01276~^~(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-01276)~^~ -VALIDATION_ERROR_146009fa~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277)~^~ -VALIDATION_ERROR_146009fc~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278)~^~ -VALIDATION_ERROR_146009fe~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-preTransform-01279~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'preTransform must be one of the bits present in the supportedTransforms member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-preTransform-01279)~^~ -VALIDATION_ERROR_14600a00~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'compositeAlpha must be one of the bits present in the supportedCompositeAlpha member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280)~^~ -VALIDATION_ERROR_14600a02~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-presentMode-01281~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'presentMode must be one of the VkPresentModeKHR values returned by vkGetPhysicalDeviceSurfacePresentModesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-presentMode-01281)~^~ -VALIDATION_ERROR_14600ace~^~Y~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-minImageCount-01383~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'minImageCount must be 1 if presentMode is either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-minImageCount-01383)~^~ -VALIDATION_ERROR_14600ad0~^~N~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageUsage-01384~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'If presentMode is VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, imageUsage must be a subset of the supported usage flags present in the sharedPresentSupportedUsageFlags member of the VkSharedPresentSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-01384)~^~ -VALIDATION_ERROR_14600ae2~^~N~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01393~^~(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01393)~^~ -VALIDATION_ERROR_14600b26~^~N~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-presentMode-01427~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'If presentMode is VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_FIFO_RELAXED_KHR, imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-presentMode-01427)~^~ -VALIDATION_ERROR_14600b28~^~N~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428)~^~ -VALIDATION_ERROR_14600b2a~^~N~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429)~^~ -VALIDATION_ERROR_14600d32~^~Y~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageExtent-01689~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageExtent members width and height must both be non-zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageExtent-01689)~^~ -VALIDATION_ERROR_14600de4~^~N~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageFormat-01778~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageFormat, imageUsage, imageExtent, and imageArrayLayers must be supported for VK_IMAGE_TYPE_2D VK_IMAGE_TILING_OPTIMAL images as reported by vkGetPhysicalDeviceImageFormatProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageFormat-01778)~^~ -VALIDATION_ERROR_14600f1a~^~N~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933)~^~ -VALIDATION_ERROR_14602e01~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'compositeAlpha must be a valid VkCompositeAlphaFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter)~^~implicit -VALIDATION_ERROR_14609001~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-flags-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'flags must be a valid combination of VkSwapchainCreateFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-flags-parameter)~^~implicit -VALIDATION_ERROR_1460a201~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageColorSpace must be a valid VkColorSpaceKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter)~^~implicit -VALIDATION_ERROR_1460a401~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageFormat must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter)~^~implicit -VALIDATION_ERROR_1460a801~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageSharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter)~^~implicit -VALIDATION_ERROR_1460ae01~^~N~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageUsage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter)~^~implicit -VALIDATION_ERROR_1460ae03~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'imageUsage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask)~^~implicit -VALIDATION_ERROR_1460de01~^~Y~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter)~^~implicit, This error applies to both vkCreateSwapchainKHR and vkCreateSharedSwapchainsKHR. -VALIDATION_ERROR_1460de07~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If oldSwapchain is a valid handle, it must have been created, allocated, or retrieved from surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent)~^~implicit -VALIDATION_ERROR_1461c40d~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHR or VkSwapchainCounterCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_14629401~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-preTransform-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'preTransform must be a valid VkSurfaceTransformFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-preTransform-parameter)~^~implicit -VALIDATION_ERROR_14629601~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-presentMode-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'presentMode must be a valid VkPresentModeKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-presentMode-parameter)~^~implicit -VALIDATION_ERROR_1462b00b~^~Y~^~Unknown~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1462b00f~^~N~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-sType-unique~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-sType-unique)~^~implicit -VALIDATION_ERROR_1462ec01~^~Y~^~None~^~VkSwapchainCreateInfoKHR~^~VUID-VkSwapchainCreateInfoKHR-surface-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-surface-parameter)~^~implicit, This error applies to both vkCreateSwapchainKHR and vkCreateSharedSwapchainsKHR. -VALIDATION_ERROR_14805a1b~^~N~^~Unknown~^~VkValidationFlagsEXT~^~VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength~^~(VK_EXT_validation_flags)~^~The spec valid usage text states 'disabledValidationCheckCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength)~^~implicit -VALIDATION_ERROR_14814401~^~N~^~Unknown~^~VkValidationFlagsEXT~^~VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter~^~(VK_EXT_validation_flags)~^~The spec valid usage text states 'pDisabledValidationChecks must be a valid pointer to an array of disabledValidationCheckCount VkValidationCheckEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter)~^~implicit -VALIDATION_ERROR_1482b00b~^~N~^~Unknown~^~VkValidationFlagsEXT~^~VUID-VkValidationFlagsEXT-sType-sType~^~(VK_EXT_validation_flags)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationFlagsEXT-sType-sType)~^~implicit -VALIDATION_ERROR_14a004d8~^~Y~^~VALIDATION_ERROR_14a004d8~^~VkVertexInputAttributeDescription~^~VUID-VkVertexInputAttributeDescription-location-00620~^~core~^~The spec valid usage text states 'location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-location-00620)~^~ -VALIDATION_ERROR_14a004da~^~Y~^~VALIDATION_ERROR_14a004da~^~VkVertexInputAttributeDescription~^~VUID-VkVertexInputAttributeDescription-binding-00621~^~core~^~The spec valid usage text states 'binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-binding-00621)~^~ -VALIDATION_ERROR_14a004dc~^~Y~^~VALIDATION_ERROR_14a004dc~^~VkVertexInputAttributeDescription~^~VUID-VkVertexInputAttributeDescription-offset-00622~^~core~^~The spec valid usage text states 'offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-offset-00622)~^~ -VALIDATION_ERROR_14a004de~^~Y~^~CreatePipelineBadVertexAttributeFormat~^~VkVertexInputAttributeDescription~^~VUID-VkVertexInputAttributeDescription-format-00623~^~core~^~The spec valid usage text states 'format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-format-00623)~^~ -VALIDATION_ERROR_14a09201~^~Y~^~Unknown~^~VkVertexInputAttributeDescription~^~VUID-VkVertexInputAttributeDescription-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-format-parameter)~^~implicit -VALIDATION_ERROR_14c004d4~^~Y~^~VALIDATION_ERROR_14c004d4~^~VkVertexInputBindingDescription~^~VUID-VkVertexInputBindingDescription-binding-00618~^~core~^~The spec valid usage text states 'binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputBindingDescription-binding-00618)~^~ -VALIDATION_ERROR_14c004d6~^~Y~^~VALIDATION_ERROR_14c004d6~^~VkVertexInputBindingDescription~^~VUID-VkVertexInputBindingDescription-stride-00619~^~core~^~The spec valid usage text states 'stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputBindingDescription-stride-00619)~^~ -VALIDATION_ERROR_14c0ba01~^~Y~^~Unknown~^~VkVertexInputBindingDescription~^~VUID-VkVertexInputBindingDescription-inputRate-parameter~^~core~^~The spec valid usage text states 'inputRate must be a valid VkVertexInputRate value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputBindingDescription-inputRate-parameter)~^~implicit -VALIDATION_ERROR_14e00a4c~^~N~^~Unknown~^~VkViSurfaceCreateInfoNN~^~VUID-VkViSurfaceCreateInfoNN-window-01318~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'window must be a valid nn::vi::NativeWindowHandle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-window-01318)~^~ -VALIDATION_ERROR_14e09005~^~Y~^~Unknown~^~VkViSurfaceCreateInfoNN~^~VUID-VkViSurfaceCreateInfoNN-flags-zerobitmask~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_14e1c40d~^~Y~^~Unknown~^~VkViSurfaceCreateInfoNN~^~VUID-VkViSurfaceCreateInfoNN-pNext-pNext~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-pNext-pNext)~^~implicit -VALIDATION_ERROR_14e2b00b~^~Y~^~Unknown~^~VkViSurfaceCreateInfoNN~^~VUID-VkViSurfaceCreateInfoNN-sType-sType~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-sType-sType)~^~implicit -VALIDATION_ERROR_150009a0~^~Y~^~SetDynViewportParamTests~^~VkViewport~^~VUID-VkViewport-x-01232~^~core~^~The spec valid usage text states '(x + width) must be less than or equal to viewportBoundsRange[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-x-01232)~^~ -VALIDATION_ERROR_150009a2~^~Y~^~SetDynViewportParamTests,SetDynViewportParamMaintenance1Tests~^~VkViewport~^~VUID-VkViewport-y-01233~^~core~^~The spec valid usage text states '(y + height) must be less than or equal to viewportBoundsRange[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-y-01233)~^~ -VALIDATION_ERROR_150009a4~^~Y~^~SetDynViewportParamTests~^~VkViewport~^~VUID-VkViewport-minDepth-01234~^~(VK_EXT_depth_range_unrestricted)~^~The spec valid usage text states 'Unless VK_EXT_depth_range_unrestricted extension is enabled minDepth must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-minDepth-01234)~^~ -VALIDATION_ERROR_150009a6~^~Y~^~SetDynViewportParamTests~^~VkViewport~^~VUID-VkViewport-maxDepth-01235~^~(VK_EXT_depth_range_unrestricted)~^~The spec valid usage text states 'Unless VK_EXT_depth_range_unrestricted extension is enabled maxDepth must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-maxDepth-01235)~^~ -VALIDATION_ERROR_15000dd4~^~Y~^~SetDynViewportParamTests~^~VkViewport~^~VUID-VkViewport-width-01770~^~core~^~The spec valid usage text states 'width must be greater than 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-width-01770)~^~ -VALIDATION_ERROR_15000dd6~^~Y~^~SetDynViewportParamTests~^~VkViewport~^~VUID-VkViewport-width-01771~^~core~^~The spec valid usage text states 'width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-width-01771)~^~ -VALIDATION_ERROR_15000dd8~^~Y~^~SetDynViewportParamTests~^~VkViewport~^~VUID-VkViewport-height-01772~^~!(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)~^~The spec valid usage text states 'height must be greater than 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-height-01772)~^~ -VALIDATION_ERROR_15000dda~^~Y~^~SetDynViewportParamTests,SetDynViewportParamMaintenance1Tests~^~VkViewport~^~VUID-VkViewport-height-01773~^~core~^~The spec valid usage text states 'The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-height-01773)~^~ -VALIDATION_ERROR_15000ddc~^~Y~^~SetDynViewportParamTests~^~VkViewport~^~VUID-VkViewport-x-01774~^~core~^~The spec valid usage text states 'x must be greater than or equal to viewportBoundsRange[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-x-01774)~^~ -VALIDATION_ERROR_15000dde~^~Y~^~SetDynViewportParamTests,SetDynViewportParamMaintenance1Tests~^~VkViewport~^~VUID-VkViewport-y-01775~^~core~^~The spec valid usage text states 'y must be greater than or equal to viewportBoundsRange[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-y-01775)~^~ -VALIDATION_ERROR_15000de0~^~Y~^~SetDynViewportParamMaintenance1Tests~^~VkViewport~^~VUID-VkViewport-y-01776~^~(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)~^~The spec valid usage text states 'y must be less than or equal to viewportBoundsRange[1]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-y-01776)~^~ -VALIDATION_ERROR_15000de2~^~Y~^~SetDynViewportParamMaintenance1Tests~^~VkViewport~^~VUID-VkViewport-y-01777~^~(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)~^~The spec valid usage text states '(y + height) must be greater than or equal to viewportBoundsRange[0]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-y-01777)~^~ -VALIDATION_ERROR_15230c01~^~N~^~Unknown~^~VkViewportSwizzleNV~^~VUID-VkViewportSwizzleNV-w-parameter~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'w must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-w-parameter)~^~implicit -VALIDATION_ERROR_15231001~^~N~^~Unknown~^~VkViewportSwizzleNV~^~VUID-VkViewportSwizzleNV-x-parameter~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'x must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-x-parameter)~^~implicit -VALIDATION_ERROR_15231201~^~N~^~Unknown~^~VkViewportSwizzleNV~^~VUID-VkViewportSwizzleNV-y-parameter~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'y must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-y-parameter)~^~implicit -VALIDATION_ERROR_15231401~^~N~^~Unknown~^~VkViewportSwizzleNV~^~VUID-VkViewportSwizzleNV-z-parameter~^~(VK_NV_viewport_swizzle)~^~The spec valid usage text states 'z must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-z-parameter)~^~implicit -VALIDATION_ERROR_15400a30~^~N~^~Unknown~^~VkWaylandSurfaceCreateInfoKHR~^~VUID-VkWaylandSurfaceCreateInfoKHR-display-01304~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'display must point to a valid Wayland wl_display.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-display-01304)~^~TBD in parameter validation layer. -VALIDATION_ERROR_15400a32~^~N~^~Unknown~^~VkWaylandSurfaceCreateInfoKHR~^~VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'surface must point to a valid Wayland wl_surface.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305)~^~TBD in parameter validation layer. -VALIDATION_ERROR_15409005~^~Y~^~Unknown~^~VkWaylandSurfaceCreateInfoKHR~^~VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_1541c40d~^~Y~^~Unknown~^~VkWaylandSurfaceCreateInfoKHR~^~VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_1542b00b~^~Y~^~Unknown~^~VkWaylandSurfaceCreateInfoKHR~^~VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15600009~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent)~^~implicit -VALIDATION_ERROR_156000a2~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHR::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081)~^~ -VALIDATION_ERROR_1560e201~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter)~^~implicit -VALIDATION_ERROR_1560e401~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter)~^~implicit -VALIDATION_ERROR_1560e801~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'If acquireCount is not 0, pAcquireTimeouts must be a valid pointer to an array of acquireCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter)~^~implicit -VALIDATION_ERROR_15621201~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter)~^~implicit -VALIDATION_ERROR_15621401~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter)~^~implicit -VALIDATION_ERROR_1562b00b~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoKHR~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType~^~(VK_KHR_win32_keyed_mutex)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_15800009~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoNV~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent~^~(VK_NV_win32_keyed_mutex)~^~The spec valid usage text states 'Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent)~^~implicit -VALIDATION_ERROR_1580e201~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoNV~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter~^~(VK_NV_win32_keyed_mutex)~^~The spec valid usage text states 'If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter)~^~implicit -VALIDATION_ERROR_1580e401~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoNV~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter~^~(VK_NV_win32_keyed_mutex)~^~The spec valid usage text states 'If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter)~^~implicit -VALIDATION_ERROR_1580e601~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoNV~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireTimeoutMilliseconds-parameter~^~(VK_NV_win32_keyed_mutex)~^~The spec valid usage text states 'If acquireCount is not 0, pAcquireTimeoutMilliseconds must be a valid pointer to an array of acquireCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireTimeoutMilliseconds-parameter)~^~implicit -VALIDATION_ERROR_15821201~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoNV~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseKeys-parameter~^~(VK_NV_win32_keyed_mutex)~^~The spec valid usage text states 'If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseKeys-parameter)~^~implicit -VALIDATION_ERROR_15821401~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoNV~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseSyncs-parameter~^~(VK_NV_win32_keyed_mutex)~^~The spec valid usage text states 'If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseSyncs-parameter)~^~implicit -VALIDATION_ERROR_1582b00b~^~N~^~Unknown~^~VkWin32KeyedMutexAcquireReleaseInfoNV~^~VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-sType-sType~^~(VK_NV_win32_keyed_mutex)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15a00a36~^~N~^~Unknown~^~VkWin32SurfaceCreateInfoKHR~^~VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'hinstance must be a valid Win32 HINSTANCE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307)~^~ -VALIDATION_ERROR_15a00a38~^~Y~^~None~^~VkWin32SurfaceCreateInfoKHR~^~VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'hwnd must be a valid Win32 HWND.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308)~^~ -VALIDATION_ERROR_15a09005~^~Y~^~Unknown~^~VkWin32SurfaceCreateInfoKHR~^~VUID-VkWin32SurfaceCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15a1c40d~^~Y~^~Unknown~^~VkWin32SurfaceCreateInfoKHR~^~VUID-VkWin32SurfaceCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15a2b00b~^~Y~^~Unknown~^~VkWin32SurfaceCreateInfoKHR~^~VUID-VkWin32SurfaceCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15c00009~^~Y~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-commonparent~^~core~^~The spec valid usage text states 'Both of dstSet, and the elements of pTexelBufferView that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-commonparent)~^~implicit -VALIDATION_ERROR_15c00276~^~Y~^~InvalidDSUpdateIndex~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-dstBinding-00315~^~core~^~The spec valid usage text states 'dstBinding must be less than or equal to the maximum value of binding of all VkDescriptorSetLayoutBinding structures specified when dstSet's descriptor set layout was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstBinding-00315)~^~ -VALIDATION_ERROR_15c00278~^~Y~^~DSUpdateEmptyBinding~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-dstBinding-00316~^~core~^~The spec valid usage text states 'dstBinding must be a binding with a non-zero descriptorCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstBinding-00316)~^~ -VALIDATION_ERROR_15c0027a~^~N~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorCount-00317~^~core~^~The spec valid usage text states 'All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical descriptorType and stageFlags.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-00317)~^~ -VALIDATION_ERROR_15c0027c~^~N~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorCount-00318~^~core~^~The spec valid usage text states 'All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must all either use immutable samplers or must all not use immutable samplers.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-00318)~^~ -VALIDATION_ERROR_15c0027e~^~Y~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00319~^~core~^~The spec valid usage text states 'descriptorType must match the type of dstBinding within dstSet' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00319)~^~ -VALIDATION_ERROR_15c00280~^~Y~^~UpdateDestroyDescriptorSetLayout~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-dstSet-00320~^~core~^~The spec valid usage text states 'dstSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstSet-00320)~^~implicit -VALIDATION_ERROR_15c00282~^~Y~^~WriteDescriptorSetIntegrityCheck,DSUpdateOutOfBounds~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-dstArrayElement-00321~^~core~^~The spec valid usage text states 'The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstArrayElement-00321)~^~ -VALIDATION_ERROR_15c00284~^~Y~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00322~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pImageInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorImageInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00322)~^~ -VALIDATION_ERROR_15c00286~^~Y~^~InvalidBufferViewObject~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00323~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pTexelBufferView must be a valid pointer to an array of descriptorCount valid VkBufferView handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00323)~^~ -VALIDATION_ERROR_15c00288~^~Y~^~WriteDescriptorSetIntegrityCheck~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00324~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00324)~^~ -VALIDATION_ERROR_15c0028a~^~Y~^~SampleDescriptorUpdateError~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00325~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was not allocated with a layout that included immutable samplers for dstBinding with descriptorType, the sampler member of each element of pImageInfo must be a valid VkSampler object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00325)~^~ -VALIDATION_ERROR_15c0028c~^~Y~^~ImageViewDescriptorUpdateError~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00326~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView and imageLayout members of each element of pImageInfo must be a valid VkImageView and VkImageLayout, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00326)~^~ -VALIDATION_ERROR_15c0028e~^~Y~^~DSBufferLimitErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00327~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00327)~^~ -VALIDATION_ERROR_15c00290~^~Y~^~DSBufferLimitErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00328~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00328)~^~ -VALIDATION_ERROR_15c00292~^~Y~^~DSUsageBitsErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00329~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, and the buffer member of any element of pBufferInfo is the handle of a non-sparse buffer, then that buffer must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00329)~^~ -VALIDATION_ERROR_15c00294~^~Y~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00330~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00330)~^~ -VALIDATION_ERROR_15c00296~^~Y~^~DSUsageBitsErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00331~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00331)~^~ -VALIDATION_ERROR_15c00298~^~Y~^~DSBufferLimitErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00332~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxUniformBufferRange' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00332)~^~ -VALIDATION_ERROR_15c0029a~^~Y~^~DSBufferLimitErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00333~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxStorageBufferRange' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00333)~^~ -VALIDATION_ERROR_15c0029c~^~Y~^~DSUsageBitsErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00334~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00334)~^~ -VALIDATION_ERROR_15c0029e~^~Y~^~DSUsageBitsErrors~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00335~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00335)~^~ -VALIDATION_ERROR_15c002a0~^~N~^~None~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00336~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the identity swizzle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00336)~^~ -VALIDATION_ERROR_15c002a2~^~N~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00337~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_SAMPLED_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00337)~^~ -VALIDATION_ERROR_15c002a4~^~N~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00338~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00338)~^~ -VALIDATION_ERROR_15c002a6~^~N~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-00339~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00339)~^~ -VALIDATION_ERROR_15c00af4~^~N~^~None~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-01402~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, for each descriptor that will be accessed via load or store operations the imageLayout member for corresponding elements of pImageInfo must be VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-01402)~^~ -VALIDATION_ERROR_15c00af6~^~N~^~None~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-01403~^~core~^~The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageLayout member of each element of pImageInfo must be VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-01403)~^~ -VALIDATION_ERROR_15c017d0~^~N~^~None~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorCount-03048~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical VkDescriptorBindingFlagBitsEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-03048)~^~ -VALIDATION_ERROR_15c0441b~^~Y~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorCount-arraylength~^~core~^~The spec valid usage text states 'descriptorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-arraylength)~^~implicit -VALIDATION_ERROR_15c04e01~^~Y~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-descriptorType-parameter~^~core~^~The spec valid usage text states 'descriptorType must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-parameter)~^~implicit -VALIDATION_ERROR_15c1c40d~^~Y~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15c2b00b~^~N~^~Unknown~^~VkWriteDescriptorSet~^~VUID-VkWriteDescriptorSet-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15e00a3c~^~N~^~Unknown~^~VkXcbSurfaceCreateInfoKHR~^~VUID-VkXcbSurfaceCreateInfoKHR-connection-01310~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'connection must point to a valid X11 xcb_connection_t.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-connection-01310)~^~ -VALIDATION_ERROR_15e00a3e~^~N~^~Unknown~^~VkXcbSurfaceCreateInfoKHR~^~VUID-VkXcbSurfaceCreateInfoKHR-window-01311~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'window must be a valid X11 xcb_window_t.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-window-01311)~^~ -VALIDATION_ERROR_15e09005~^~Y~^~Unknown~^~VkXcbSurfaceCreateInfoKHR~^~VUID-VkXcbSurfaceCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15e1c40d~^~Y~^~Unknown~^~VkXcbSurfaceCreateInfoKHR~^~VUID-VkXcbSurfaceCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_15e2b00b~^~Y~^~Unknown~^~VkXcbSurfaceCreateInfoKHR~^~VUID-VkXcbSurfaceCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_16000a42~^~N~^~Unknown~^~VkXlibSurfaceCreateInfoKHR~^~VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'dpy must point to a valid Xlib Display.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313)~^~ -VALIDATION_ERROR_16000a44~^~N~^~Unknown~^~VkXlibSurfaceCreateInfoKHR~^~VUID-VkXlibSurfaceCreateInfoKHR-window-01314~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'window must be a valid Xlib Window.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-window-01314)~^~ -VALIDATION_ERROR_16009005~^~Y~^~Unknown~^~VkXlibSurfaceCreateInfoKHR~^~VUID-VkXlibSurfaceCreateInfoKHR-flags-zerobitmask~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1601c40d~^~Y~^~Unknown~^~VkXlibSurfaceCreateInfoKHR~^~VUID-VkXlibSurfaceCreateInfoKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1602b00b~^~Y~^~Unknown~^~VkXlibSurfaceCreateInfoKHR~^~VUID-VkXlibSurfaceCreateInfoKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_16200e16~^~N~^~None~^~vkAcquireNextImage2KHR~^~VUID-vkAcquireNextImage2KHR-swapchain-01803~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the number of currently acquired images is greater than the difference between the number of images in the swapchain member of pAcquireInfo and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, the timeout member of pAcquireInfo must not be UINT64_MAX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-swapchain-01803)~^~ -VALIDATION_ERROR_16205601~^~Y~^~Unknown~^~vkAcquireNextImage2KHR~^~VUID-vkAcquireNextImage2KHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-device-parameter)~^~implicit -VALIDATION_ERROR_1620e001~^~N~^~Unknown~^~vkAcquireNextImage2KHR~^~VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pAcquireInfo must be a valid pointer to a valid VkAcquireNextImageInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter)~^~implicit -VALIDATION_ERROR_16218601~^~Y~^~Unknown~^~vkAcquireNextImage2KHR~^~VUID-vkAcquireNextImage2KHR-pImageIndex-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pImageIndex must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-pImageIndex-parameter)~^~implicit -VALIDATION_ERROR_16400009~^~Y~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-commonparent)~^~implicit -VALIDATION_ERROR_16400a0a~^~N~^~Unknown~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-swapchain-01285~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'swapchain must not be in the retired state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-swapchain-01285)~^~ -VALIDATION_ERROR_16400a0c~^~Y~^~Unknown~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-semaphore-01286~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-01286)~^~ -VALIDATION_ERROR_16400a0e~^~N~^~Unknown~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-fence-01287~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-fence-01287)~^~ -VALIDATION_ERROR_16400de6~^~N~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-semaphore-01779~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-01779)~^~ -VALIDATION_ERROR_16400de8~^~N~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-semaphore-01780~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'semaphore and fence must not both be equal to VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-01780)~^~ -VALIDATION_ERROR_16400e14~^~N~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-swapchain-01802~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-swapchain-01802)~^~ -VALIDATION_ERROR_16405601~^~Y~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-device-parameter)~^~implicit -VALIDATION_ERROR_16408801~^~Y~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-fence-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-fence-parameter)~^~implicit -VALIDATION_ERROR_16408807~^~Y~^~Unknown~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-fence-parent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If fence is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-fence-parent)~^~implicit -VALIDATION_ERROR_16418601~^~Y~^~Unknown~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-pImageIndex-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'pImageIndex must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-pImageIndex-parameter)~^~implicit -VALIDATION_ERROR_1642b801~^~Y~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-semaphore-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-parameter)~^~implicit -VALIDATION_ERROR_1642b807~^~Y~^~Unknown~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-semaphore-parent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If semaphore is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-parent)~^~implicit -VALIDATION_ERROR_1642f001~^~Y~^~None~^~vkAcquireNextImageKHR~^~VUID-vkAcquireNextImageKHR-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-swapchain-parameter)~^~implicit -VALIDATION_ERROR_16606001~^~Y~^~Unknown~^~vkAcquireXlibDisplayEXT~^~VUID-vkAcquireXlibDisplayEXT-display-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)~^~The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireXlibDisplayEXT-display-parameter)~^~implicit -VALIDATION_ERROR_16606601~^~Y~^~Unknown~^~vkAcquireXlibDisplayEXT~^~VUID-vkAcquireXlibDisplayEXT-dpy-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)~^~The spec valid usage text states 'dpy must be a valid pointer to a Display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireXlibDisplayEXT-dpy-parameter)~^~implicit -VALIDATION_ERROR_16627a01~^~Y~^~Unknown~^~vkAcquireXlibDisplayEXT~^~VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_16805601~^~Y~^~None~^~vkAllocateCommandBuffers~^~VUID-vkAllocateCommandBuffers-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateCommandBuffers-device-parameter)~^~implicit -VALIDATION_ERROR_1680ea01~^~N~^~Unknown~^~vkAllocateCommandBuffers~^~VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter~^~core~^~The spec valid usage text states 'pAllocateInfo must be a valid pointer to a valid VkCommandBufferAllocateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter)~^~implicit -VALIDATION_ERROR_16811401~^~Y~^~Unknown~^~vkAllocateCommandBuffers~^~VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter~^~core~^~The spec valid usage text states 'pCommandBuffers must be a valid pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter)~^~implicit -VALIDATION_ERROR_16a05601~^~Y~^~None~^~vkAllocateDescriptorSets~^~VUID-vkAllocateDescriptorSets-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateDescriptorSets-device-parameter)~^~implicit -VALIDATION_ERROR_16a0ea01~^~N~^~Unknown~^~vkAllocateDescriptorSets~^~VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter~^~core~^~The spec valid usage text states 'pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter)~^~implicit -VALIDATION_ERROR_16a13001~^~Y~^~Unknown~^~vkAllocateDescriptorSets~^~VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter~^~core~^~The spec valid usage text states 'pDescriptorSets must be a valid pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter)~^~implicit -VALIDATION_ERROR_16c00d62~^~N~^~None~^~vkAllocateMemory~^~VUID-vkAllocateMemory-pAllocateInfo-01713~^~core~^~The spec valid usage text states 'pAllocateInfo-&gt;allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[pAllocateInfo-&gt;memoryTypeIndex].size as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-01713)~^~ -VALIDATION_ERROR_16c00d64~^~N~^~None~^~vkAllocateMemory~^~VUID-vkAllocateMemory-pAllocateInfo-01714~^~core~^~The spec valid usage text states 'pAllocateInfo-&gt;memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-01714)~^~ -VALIDATION_ERROR_16c05601~^~Y~^~None~^~vkAllocateMemory~^~VUID-vkAllocateMemory-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-device-parameter)~^~implicit -VALIDATION_ERROR_16c0ea01~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-vkAllocateMemory-pAllocateInfo-parameter~^~core~^~The spec valid usage text states 'pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-parameter)~^~implicit -VALIDATION_ERROR_16c0ec01~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-vkAllocateMemory-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_16c1aa01~^~Y~^~Unknown~^~vkAllocateMemory~^~VUID-vkAllocateMemory-pMemory-parameter~^~core~^~The spec valid usage text states 'pMemory must be a valid pointer to a VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pMemory-parameter)~^~implicit -VALIDATION_ERROR_16e00062~^~Y~^~Unknown~^~vkBeginCommandBuffer~^~VUID-vkBeginCommandBuffer-commandBuffer-00049~^~core~^~The spec valid usage text states 'commandBuffer must not be in the recording or pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00049)~^~ -VALIDATION_ERROR_16e00064~^~Y~^~CommandBufferResetErrors~^~vkBeginCommandBuffer~^~VUID-vkBeginCommandBuffer-commandBuffer-00050~^~core~^~The spec valid usage text states 'If commandBuffer was allocated from a VkCommandPool which did not have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the initial state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00050)~^~ -VALIDATION_ERROR_16e00066~^~Y~^~Unknown~^~vkBeginCommandBuffer~^~VUID-vkBeginCommandBuffer-commandBuffer-00051~^~core~^~The spec valid usage text states 'If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00051)~^~ -VALIDATION_ERROR_16e00068~^~Y~^~Unknown~^~vkBeginCommandBuffer~^~VUID-vkBeginCommandBuffer-commandBuffer-00052~^~core~^~The spec valid usage text states 'If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is VK_FALSE, or the precise occlusion queries feature is not enabled, the queryFlags member of the pInheritanceInfo member pBeginInfo must not contain VK_QUERY_CONTROL_PRECISE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00052)~^~ -VALIDATION_ERROR_16e02401~^~Y~^~None~^~vkBeginCommandBuffer~^~VUID-vkBeginCommandBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_16e0f601~^~N~^~Unknown~^~vkBeginCommandBuffer~^~VUID-vkBeginCommandBuffer-pBeginInfo-parameter~^~core~^~The spec valid usage text states 'pBeginInfo must be a valid pointer to a valid VkCommandBufferBeginInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-pBeginInfo-parameter)~^~implicit -VALIDATION_ERROR_1700080a~^~Y~^~BindInvalidMemory~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01029~^~core~^~The spec valid usage text states 'buffer must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01029)~^~ -VALIDATION_ERROR_1700080c~^~Y~^~BindInvalidMemory~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01030~^~core~^~The spec valid usage text states 'buffer must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01030)~^~ -VALIDATION_ERROR_1700080e~^~Y~^~BindInvalidMemory~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-memoryOffset-01031~^~core~^~The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memoryOffset-01031)~^~ -VALIDATION_ERROR_17000810~^~Y~^~Unknown~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01032~^~core~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01032)~^~ -VALIDATION_ERROR_17000812~^~Y~^~Unknown~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01033~^~core~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01033)~^~ -VALIDATION_ERROR_17000814~^~Y~^~Unknown~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01034~^~core~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01034)~^~ -VALIDATION_ERROR_17000816~^~Y~^~BindInvalidMemory~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-memory-01035~^~core~^~The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memory-01035)~^~ -VALIDATION_ERROR_17000818~^~Y~^~BindInvalidMemory~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-memoryOffset-01036~^~core~^~The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memoryOffset-01036)~^~ -VALIDATION_ERROR_1700081a~^~Y~^~BindInvalidMemory~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-size-01037~^~core~^~The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-size-01037)~^~ -VALIDATION_ERROR_1700081c~^~N~^~Unknown~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01038~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01038)~^~ -VALIDATION_ERROR_1700081e~^~N~^~Unknown~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01039~^~(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01039)~^~ -VALIDATION_ERROR_17000b48~^~N~^~None~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-01444~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01444)~^~ -VALIDATION_ERROR_17000bc8~^~Y~^~DedicatedAllocation~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-memory-01508~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-01508)~^~ -VALIDATION_ERROR_17000ed4~^~N~^~None~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-None-01898~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-None-01898)~^~ -VALIDATION_ERROR_17000ed6~^~N~^~None~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-None-01899~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-None-01899)~^~ -VALIDATION_ERROR_17001a01~^~Y~^~VertexBufferInvalid~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-parameter)~^~implicit -VALIDATION_ERROR_17001a07~^~Y~^~Unknown~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-buffer-parent~^~core~^~The spec valid usage text states 'buffer must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-parent)~^~implicit -VALIDATION_ERROR_17005601~^~Y~^~None~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-device-parameter)~^~implicit -VALIDATION_ERROR_1700c601~^~Y~^~BindInvalidMemory~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-memory-parameter~^~core~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memory-parameter)~^~implicit -VALIDATION_ERROR_1700c607~^~Y~^~Unknown~^~vkBindBufferMemory~^~VUID-vkBindBufferMemory-memory-parent~^~core~^~The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memory-parent)~^~implicit -VALIDATION_ERROR_1720161b~^~N~^~None~^~vkBindBufferMemory2~^~VUID-vkBindBufferMemory2-bindInfoCount-arraylength~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'bindInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory2-bindInfoCount-arraylength)~^~implicit -VALIDATION_ERROR_17205601~^~Y~^~None~^~vkBindBufferMemory2~^~VUID-vkBindBufferMemory2-device-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory2-device-parameter)~^~implicit -VALIDATION_ERROR_1720fa01~^~Y~^~None~^~vkBindBufferMemory2~^~VUID-vkBindBufferMemory2-pBindInfos-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindBufferMemoryInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory2-pBindInfos-parameter)~^~implicit -VALIDATION_ERROR_17400828~^~Y~^~BindInvalidMemory~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-01044~^~core~^~The spec valid usage text states 'image must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-01044)~^~ -VALIDATION_ERROR_1740082a~^~Y~^~BindInvalidMemory~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-01045~^~core~^~The spec valid usage text states 'image must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-01045)~^~ -VALIDATION_ERROR_1740082c~^~Y~^~BindInvalidMemory~^~vkBindImageMemory~^~VUID-vkBindImageMemory-memoryOffset-01046~^~core~^~The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memoryOffset-01046)~^~ -VALIDATION_ERROR_1740082e~^~Y~^~BindInvalidMemory~^~vkBindImageMemory~^~VUID-vkBindImageMemory-memory-01047~^~core~^~The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memory-01047)~^~ -VALIDATION_ERROR_17400830~^~Y~^~BindInvalidMemory~^~vkBindImageMemory~^~VUID-vkBindImageMemory-memoryOffset-01048~^~core~^~The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memoryOffset-01048)~^~ -VALIDATION_ERROR_17400832~^~Y~^~BindInvalidMemory~^~vkBindImageMemory~^~VUID-vkBindImageMemory-size-01049~^~core~^~The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-size-01049)~^~ -VALIDATION_ERROR_17400834~^~N~^~Unknown~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-01050~^~(VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01050)~^~ -VALIDATION_ERROR_17400836~^~N~^~Unknown~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-01051~^~(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-01051)~^~ -VALIDATION_ERROR_17400b4a~^~N~^~None~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-01445~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01445)~^~ -VALIDATION_ERROR_17400bca~^~Y~^~DedicatedAllocation~^~vkBindImageMemory~^~VUID-vkBindImageMemory-memory-01509~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-01509)~^~ -VALIDATION_ERROR_17400c90~^~N~^~None~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-01608~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01608)~^~ -VALIDATION_ERROR_17400eda~^~N~^~None~^~vkBindImageMemory~^~VUID-vkBindImageMemory-None-01901~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-None-01901)~^~ -VALIDATION_ERROR_17400edc~^~N~^~None~^~vkBindImageMemory~^~VUID-vkBindImageMemory-None-01902~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-None-01902)~^~ -VALIDATION_ERROR_17405601~^~Y~^~None~^~vkBindImageMemory~^~VUID-vkBindImageMemory-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-device-parameter)~^~implicit -VALIDATION_ERROR_1740a001~^~Y~^~BindMemoryToDestroyedObject~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-parameter)~^~implicit -VALIDATION_ERROR_1740a007~^~Y~^~Unknown~^~vkBindImageMemory~^~VUID-vkBindImageMemory-image-parent~^~core~^~The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-parent)~^~implicit -VALIDATION_ERROR_1740c601~^~Y~^~BindInvalidMemory~^~vkBindImageMemory~^~VUID-vkBindImageMemory-memory-parameter~^~core~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memory-parameter)~^~implicit -VALIDATION_ERROR_1740c607~^~Y~^~Unknown~^~vkBindImageMemory~^~VUID-vkBindImageMemory-memory-parent~^~core~^~The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memory-parent)~^~implicit -VALIDATION_ERROR_1760161b~^~N~^~None~^~vkBindImageMemory2~^~VUID-vkBindImageMemory2-bindInfoCount-arraylength~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'bindInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory2-bindInfoCount-arraylength)~^~implicit -VALIDATION_ERROR_17605601~^~Y~^~None~^~vkBindImageMemory2~^~VUID-vkBindImageMemory2-device-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory2-device-parameter)~^~implicit -VALIDATION_ERROR_1760fa01~^~Y~^~None~^~vkBindImageMemory2~^~VUID-vkBindImageMemory2-pBindInfos-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)~^~The spec valid usage text states 'pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindImageMemoryInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory2-pBindInfos-parameter)~^~implicit -VALIDATION_ERROR_17800009~^~Y~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commonparent)~^~implicit -VALIDATION_ERROR_17800640~^~N~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-queryType-00800~^~core~^~The spec valid usage text states 'If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00800)~^~ -VALIDATION_ERROR_17800644~^~N~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-query-00802~^~core~^~The spec valid usage text states 'query must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-query-00802)~^~ -VALIDATION_ERROR_17800646~^~N~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-queryType-00803~^~core~^~The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00803)~^~ -VALIDATION_ERROR_17800648~^~N~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-queryType-00804~^~core~^~The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00804)~^~ -VALIDATION_ERROR_1780064a~^~N~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-queryType-00805~^~core~^~The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00805)~^~ -VALIDATION_ERROR_1780064e~^~N~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-None-00807~^~core~^~The spec valid usage text states 'All queries used by the command must be unavailable' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-None-00807)~^~ -VALIDATION_ERROR_17800650~^~N~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-query-00808~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If vkCmdBeginQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass's view mask must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginQuery-query-00808)~^~ -VALIDATION_ERROR_17800eba~^~N~^~None~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-commandBuffer-01885~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'commandBuffer must not be a protected command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-01885)~^~ -VALIDATION_ERROR_17800f04~^~N~^~None~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-queryPool-01922~^~core~^~The spec valid usage text states 'queryPool must have been created with a queryType that differs from that of any queries that are active within commandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryPool-01922)~^~ -VALIDATION_ERROR_17802401~^~Y~^~None~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_17802413~^~Y~^~None~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_17802415~^~Y~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_17809001~^~Y~^~Unknown~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkQueryControlFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_17829801~^~Y~^~None~^~vkCmdBeginQuery~^~VUID-vkCmdBeginQuery-queryPool-parameter~^~core~^~The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryPool-parameter)~^~implicit -VALIDATION_ERROR_17a00017~^~Y~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-renderpass)~^~implicit -VALIDATION_ERROR_17a00019~^~Y~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-bufferlevel~^~core~^~The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-bufferlevel)~^~implicit -VALIDATION_ERROR_17a006fe~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-initialLayout-00895~^~core~^~The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00895)~^~ -VALIDATION_ERROR_17a00700~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-initialLayout-00896~^~!(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00896)~^~ -VALIDATION_ERROR_17a00702~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-initialLayout-00897~^~core~^~The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00897)~^~ -VALIDATION_ERROR_17a00704~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-initialLayout-00898~^~core~^~The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00898)~^~ -VALIDATION_ERROR_17a00706~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-initialLayout-00899~^~core~^~The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00899)~^~ -VALIDATION_ERROR_17a00708~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-initialLayout-00900~^~core~^~The spec valid usage text states 'If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00900)~^~ -VALIDATION_ERROR_17a0070a~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-srcStageMask-00901~^~core~^~The spec valid usage text states 'The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-srcStageMask-00901)~^~ -VALIDATION_ERROR_17a00dbc~^~N~^~None~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-initialLayout-01758~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-01758)~^~ -VALIDATION_ERROR_17a02401~^~Y~^~None~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_17a02413~^~Y~^~None~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_17a02415~^~Y~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_17a03201~^~Y~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-contents-parameter~^~core~^~The spec valid usage text states 'contents must be a valid VkSubpassContents value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-contents-parameter)~^~implicit -VALIDATION_ERROR_17a21801~^~N~^~Unknown~^~vkCmdBeginRenderPass~^~VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter~^~core~^~The spec valid usage text states 'pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter)~^~implicit -VALIDATION_ERROR_17c00009~^~Y~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commonparent)~^~implicit -VALIDATION_ERROR_17c002cc~^~Y~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358~^~core~^~The spec valid usage text states 'Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358)~^~ -VALIDATION_ERROR_17c002ce~^~Y~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359~^~core~^~The spec valid usage text states 'dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359)~^~ -VALIDATION_ERROR_17c002d0~^~N~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-firstSet-00360~^~core~^~The spec valid usage text states 'The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-firstSet-00360)~^~ -VALIDATION_ERROR_17c002d2~^~N~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361~^~core~^~The spec valid usage text states 'pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361)~^~ -VALIDATION_ERROR_17c002d4~^~Y~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-pDynamicOffsets-00362~^~core~^~The spec valid usage text states 'Each element of pDynamicOffsets must satisfy the required alignment for the corresponding descriptor binding's descriptor type' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDynamicOffsets-00362)~^~ -VALIDATION_ERROR_17c02401~^~Y~^~None~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_17c02413~^~Y~^~None~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_17c02415~^~Y~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_17c04a1b~^~N~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength~^~core~^~The spec valid usage text states 'descriptorSetCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength)~^~implicit -VALIDATION_ERROR_17c0be01~^~Y~^~DescriptorSetCompatibility~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-layout-parameter~^~core~^~The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-layout-parameter)~^~implicit -VALIDATION_ERROR_17c13001~^~Y~^~InvalidDescriptorSet~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter~^~core~^~The spec valid usage text states 'pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter)~^~implicit -VALIDATION_ERROR_17c15401~^~Y~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter~^~core~^~The spec valid usage text states 'If dynamicOffsetCount is not 0, pDynamicOffsets must be a valid pointer to an array of dynamicOffsetCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter)~^~implicit -VALIDATION_ERROR_17c27e01~^~Y~^~Unknown~^~vkCmdBindDescriptorSets~^~VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter~^~core~^~The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter)~^~implicit -VALIDATION_ERROR_17e00009~^~Y~^~Unknown~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-commonparent~^~core~^~The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commonparent)~^~implicit -VALIDATION_ERROR_17e0035e~^~N~^~Unknown~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-offset-00431~^~core~^~The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-offset-00431)~^~ -VALIDATION_ERROR_17e00360~^~Y~^~Unknown~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-offset-00432~^~core~^~The spec valid usage text states 'The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-offset-00432)~^~ -VALIDATION_ERROR_17e00362~^~Y~^~Unknown~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-buffer-00433~^~core~^~The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-buffer-00433)~^~ -VALIDATION_ERROR_17e00364~^~Y~^~Unknown~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-buffer-00434~^~core~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-buffer-00434)~^~ -VALIDATION_ERROR_17e01a01~^~Y~^~None~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-buffer-parameter)~^~implicit -VALIDATION_ERROR_17e02401~^~Y~^~None~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_17e02413~^~Y~^~None~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_17e02415~^~Y~^~Unknown~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_17e0b201~^~Y~^~Unknown~^~vkCmdBindIndexBuffer~^~VUID-vkCmdBindIndexBuffer-indexType-parameter~^~core~^~The spec valid usage text states 'indexType must be a valid VkIndexType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-indexType-parameter)~^~implicit -VALIDATION_ERROR_18000009~^~Y~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and pipeline must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commonparent)~^~implicit -VALIDATION_ERROR_18000612~^~N~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-pipelineBindPoint-00777~^~core~^~The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00777)~^~ -VALIDATION_ERROR_18000614~^~N~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-pipelineBindPoint-00778~^~core~^~The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00778)~^~ -VALIDATION_ERROR_18000616~^~N~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-pipelineBindPoint-00779~^~core~^~The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00779)~^~ -VALIDATION_ERROR_18000618~^~N~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-pipelineBindPoint-00780~^~core~^~The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00780)~^~ -VALIDATION_ERROR_1800061a~^~N~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-pipeline-00781~^~core~^~The spec valid usage text states 'If the variable multisample rate feature is not supported, pipeline is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipeline-00781)~^~ -VALIDATION_ERROR_18000bea~^~N~^~None~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-variableSampleLocations-01525~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, and pipeline is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its sampleLocationsEnable member set to VK_TRUE but without VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sampleLocationsInfo specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBindPipeline-variableSampleLocations-01525)~^~ -VALIDATION_ERROR_18002401~^~Y~^~None~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18002413~^~Y~^~None~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18002415~^~Y~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_18027c01~^~Y~^~PipelineNotBound,InvalidPipeline~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-pipeline-parameter~^~core~^~The spec valid usage text states 'pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipeline-parameter)~^~implicit -VALIDATION_ERROR_18027e01~^~Y~^~Unknown~^~vkCmdBindPipeline~^~VUID-vkCmdBindPipeline-pipelineBindPoint-parameter~^~core~^~The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-parameter)~^~implicit -VALIDATION_ERROR_18200009~^~Y~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and the elements of pBuffers must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commonparent)~^~implicit -VALIDATION_ERROR_182004e0~^~N~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-firstBinding-00624~^~core~^~The spec valid usage text states 'firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-firstBinding-00624)~^~ -VALIDATION_ERROR_182004e2~^~N~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-firstBinding-00625~^~core~^~The spec valid usage text states 'The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-firstBinding-00625)~^~ -VALIDATION_ERROR_182004e4~^~Y~^~BadVertexBufferOffset~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-pOffsets-00626~^~core~^~The spec valid usage text states 'All elements of pOffsets must be less than the size of the corresponding element in pBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pOffsets-00626)~^~ -VALIDATION_ERROR_182004e6~^~Y~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-pBuffers-00627~^~core~^~The spec valid usage text states 'All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pBuffers-00627)~^~ -VALIDATION_ERROR_182004e8~^~Y~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-pBuffers-00628~^~core~^~The spec valid usage text states 'Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pBuffers-00628)~^~ -VALIDATION_ERROR_1820181b~^~Y~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-bindingCount-arraylength~^~core~^~The spec valid usage text states 'bindingCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-bindingCount-arraylength)~^~implicit -VALIDATION_ERROR_18202401~^~Y~^~None~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18202413~^~Y~^~None~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18202415~^~Y~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_18210601~^~Y~^~None~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-pBuffers-parameter~^~core~^~The spec valid usage text states 'pBuffers must be a valid pointer to an array of bindingCount valid VkBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pBuffers-parameter)~^~implicit -VALIDATION_ERROR_1821d201~^~Y~^~Unknown~^~vkCmdBindVertexBuffers~^~VUID-vkCmdBindVertexBuffers-pOffsets-parameter~^~core~^~The spec valid usage text states 'pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pOffsets-parameter)~^~implicit -VALIDATION_ERROR_18400009~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commonparent)~^~implicit -VALIDATION_ERROR_18400017~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-renderpass)~^~implicit -VALIDATION_ERROR_184001ae~^~Y~^~BlitImageOffsets~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-pRegions-00215~^~core~^~The spec valid usage text states 'The source region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-00215)~^~ -VALIDATION_ERROR_184001b0~^~Y~^~BlitImageOffsets~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-pRegions-00216~^~core~^~The spec valid usage text states 'The destination region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-00216)~^~ -VALIDATION_ERROR_184001b2~^~N~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-pRegions-00217~^~core~^~The spec valid usage text states 'The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-00217)~^~ -VALIDATION_ERROR_184001b4~^~Y~^~NotTestable~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00218~^~core~^~The spec valid usage text states 'srcImage must use a format that supports VK_FORMAT_FEATURE_BLIT_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00218)~^~ -VALIDATION_ERROR_184001b6~^~Y~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00219~^~core~^~The spec valid usage text states 'srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00219)~^~ -VALIDATION_ERROR_184001b8~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00220~^~core~^~The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00220)~^~ -VALIDATION_ERROR_184001ba~^~N~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImageLayout-00221~^~core~^~The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-00221)~^~ -VALIDATION_ERROR_184001bc~^~Y~^~BlitImageLayout~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImageLayout-00222~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-00222)~^~ -VALIDATION_ERROR_184001be~^~Y~^~MiscBlitImageTests~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImage-00223~^~core~^~The spec valid usage text states 'dstImage must use a format that supports VK_FORMAT_FEATURE_BLIT_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00223)~^~ -VALIDATION_ERROR_184001c0~^~Y~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImage-00224~^~core~^~The spec valid usage text states 'dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00224)~^~ -VALIDATION_ERROR_184001c2~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImage-00225~^~core~^~The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00225)~^~ -VALIDATION_ERROR_184001c4~^~N~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImageLayout-00226~^~core~^~The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-00226)~^~ -VALIDATION_ERROR_184001c6~^~Y~^~BlitImageLayout~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImageLayout-00227~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-00227)~^~ -VALIDATION_ERROR_184001c8~^~Y~^~MiscBlitImageTests~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00228~^~core~^~The spec valid usage text states 'The sample count of srcImage and dstImage must both be equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00228)~^~ -VALIDATION_ERROR_184001ca~^~Y~^~BlitImageFormatTypes~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00229~^~core~^~The spec valid usage text states 'If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00229)~^~ -VALIDATION_ERROR_184001cc~^~Y~^~BlitImageFormatTypes~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00230~^~core~^~The spec valid usage text states 'If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00230)~^~ -VALIDATION_ERROR_184001ce~^~Y~^~BlitImageFormatTypes~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00231~^~core~^~The spec valid usage text states 'If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00231)~^~ -VALIDATION_ERROR_184001d0~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00232~^~core~^~The spec valid usage text states 'If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00232)~^~ -VALIDATION_ERROR_184001d2~^~Y~^~MiscBlitImageTests~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-00233~^~core~^~The spec valid usage text states 'srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00233)~^~ -VALIDATION_ERROR_184001d4~^~Y~^~MiscBlitImageTests~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImage-00234~^~core~^~The spec valid usage text states 'dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00234)~^~ -VALIDATION_ERROR_184001d6~^~Y~^~BlitImageFilters~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-filter-00235~^~core~^~The spec valid usage text states 'If filter is VK_FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-filter-00235)~^~ -VALIDATION_ERROR_184001d8~^~Y~^~BlitImageFilters~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-filter-00236~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'If filter is VK_FILTER_CUBIC_IMG, srcImage must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-filter-00236)~^~ -VALIDATION_ERROR_184001da~^~Y~^~BlitImageFilters~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-filter-00237~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'If filter is VK_FILTER_CUBIC_IMG, srcImage must have a VkImageType of VK_IMAGE_TYPE_3D' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-filter-00237)~^~ -VALIDATION_ERROR_18400aec~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImageLayout-01398~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-01398)~^~ -VALIDATION_ERROR_18400aee~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImageLayout-01399~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-01399)~^~ -VALIDATION_ERROR_18400c32~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-01561~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'srcImage must not use a format listed in features-formats-requiring-sampler-ycbcr-conversion' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-01561)~^~ -VALIDATION_ERROR_18400c34~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImage-01562~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'dstImage must not use a format listed in features-formats-requiring-sampler-ycbcr-conversion' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-01562)~^~ -VALIDATION_ERROR_18400d52~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcSubresource-01705~^~core~^~The spec valid usage text states 'The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcSubresource-01705)~^~ -VALIDATION_ERROR_18400d54~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstSubresource-01706~^~core~^~The spec valid usage text states 'The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstSubresource-01706)~^~ -VALIDATION_ERROR_18400d56~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcSubresource-01707~^~core~^~The spec valid usage text states 'The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcSubresource-01707)~^~ -VALIDATION_ERROR_18400d58~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstSubresource-01708~^~core~^~The spec valid usage text states 'The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstSubresource-01708)~^~ -VALIDATION_ERROR_18400e54~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-commandBuffer-01834~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-01834)~^~ -VALIDATION_ERROR_18400e56~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-commandBuffer-01835~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-01835)~^~ -VALIDATION_ERROR_18400e58~^~N~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-commandBuffer-01836~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-01836)~^~ -VALIDATION_ERROR_18402401~^~Y~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18402413~^~Y~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18402415~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_18407201~^~Y~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImage-parameter~^~core~^~The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-parameter)~^~implicit -VALIDATION_ERROR_18407401~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-dstImageLayout-parameter~^~core~^~The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-parameter)~^~implicit -VALIDATION_ERROR_18408c01~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-filter-parameter~^~core~^~The spec valid usage text states 'filter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-filter-parameter)~^~implicit -VALIDATION_ERROR_18421001~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-pRegions-parameter~^~core~^~The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkImageBlit structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-parameter)~^~implicit -VALIDATION_ERROR_1842ac1b~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-regionCount-arraylength~^~core~^~The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-regionCount-arraylength)~^~implicit -VALIDATION_ERROR_1842ce01~^~Y~^~None~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImage-parameter~^~core~^~The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-parameter)~^~implicit -VALIDATION_ERROR_1842d001~^~Y~^~Unknown~^~vkCmdBlitImage~^~VUID-vkCmdBlitImage-srcImageLayout-parameter~^~core~^~The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-parameter)~^~implicit -VALIDATION_ERROR_18600017~^~Y~^~Unknown~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-renderpass~^~core~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-renderpass)~^~implicit -VALIDATION_ERROR_1860001e~^~Y~^~MissingClearAttachment~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-aspectMask-00015~^~core~^~The spec valid usage text states 'If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, the colorAttachment member of that element must refer to a valid color attachment in the current subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-aspectMask-00015)~^~ -VALIDATION_ERROR_18600020~^~Y~^~CmdClearAttachmentTests~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-pRects-00016~^~core~^~The spec valid usage text states 'The rectangular region specified by each element of pRects must be contained within the render area of the current render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pRects-00016)~^~ -VALIDATION_ERROR_18600022~^~Y~^~CmdClearAttachmentTests~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-pRects-00017~^~core~^~The spec valid usage text states 'The layers specified by each element of pRects must be contained within every attachment that pAttachments refers to' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pRects-00017)~^~ -VALIDATION_ERROR_18600024~^~N~^~Unknown~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-baseArrayLayer-00018~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the render pass instance this is recorded in uses multiview, then baseArrayLayer must be zero and layerCount must be one.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearAttachments-baseArrayLayer-00018)~^~ -VALIDATION_ERROR_18600e1b~^~Y~^~Unknown~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-attachmentCount-arraylength~^~core~^~The spec valid usage text states 'attachmentCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-attachmentCount-arraylength)~^~implicit -VALIDATION_ERROR_18600f1c~^~N~^~None~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-layerCount-01934~^~core~^~The spec valid usage text states 'The layerCount member of each element of pRects must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-layerCount-01934)~^~ -VALIDATION_ERROR_18602401~^~Y~^~None~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18602413~^~Y~^~None~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18602415~^~Y~^~Unknown~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1860f201~^~Y~^~Unknown~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-pAttachments-parameter~^~core~^~The spec valid usage text states 'pAttachments must be a valid pointer to an array of attachmentCount valid VkClearAttachment structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pAttachments-parameter)~^~implicit -VALIDATION_ERROR_18620e01~^~Y~^~Unknown~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-pRects-parameter~^~core~^~The spec valid usage text states 'pRects must be a valid pointer to an array of rectCount VkClearRect structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pRects-parameter)~^~implicit -VALIDATION_ERROR_1862aa1b~^~Y~^~Unknown~^~vkCmdClearAttachments~^~VUID-vkCmdClearAttachments-rectCount-arraylength~^~core~^~The spec valid usage text states 'rectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-rectCount-arraylength)~^~implicit -VALIDATION_ERROR_18800002~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-image-00001~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-image-00001)~^~ -VALIDATION_ERROR_18800004~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-image-00002~^~core~^~The spec valid usage text states 'image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-00002)~^~ -VALIDATION_ERROR_18800006~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-image-00003~^~core~^~The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-00003)~^~ -VALIDATION_ERROR_18800008~^~Y~^~InvalidImageLayout~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-imageLayout-00004~^~core~^~The spec valid usage text states 'imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-00004)~^~ -VALIDATION_ERROR_18800009~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commonparent)~^~implicit -VALIDATION_ERROR_1880000a~^~Y~^~InvalidImageLayout~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-imageLayout-00005~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-00005)~^~ -VALIDATION_ERROR_1880000e~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-image-00007~^~core~^~The spec valid usage text states 'image must not have a compressed or depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-00007)~^~ -VALIDATION_ERROR_18800017~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-renderpass)~^~implicit -VALIDATION_ERROR_18800ae4~^~N~^~None~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-imageLayout-01394~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-01394)~^~ -VALIDATION_ERROR_18800b7c~^~Y~^~ClearColorImageWithBadRange~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-baseMipLevel-01470~^~core~^~The spec valid usage text states 'The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-baseMipLevel-01470)~^~ -VALIDATION_ERROR_18800b80~^~Y~^~ClearColorImageWithBadRange~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-baseArrayLayer-01472~^~core~^~The spec valid usage text states 'The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-baseArrayLayer-01472)~^~ -VALIDATION_ERROR_18800c12~^~N~^~None~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-image-01545~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'image must not use a format listed in features-formats-requiring-sampler-ycbcr-conversion' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-image-01545)~^~ -VALIDATION_ERROR_18800d38~^~Y~^~ClearColorImageWithBadRange~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-pRanges-01692~^~core~^~The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pRanges-01692)~^~ -VALIDATION_ERROR_18800d3a~^~Y~^~ClearColorImageWithBadRange~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-pRanges-01693~^~core~^~The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pRanges-01693)~^~ -VALIDATION_ERROR_18800e1a~^~N~^~None~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-commandBuffer-01805~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then image must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-01805)~^~ -VALIDATION_ERROR_18800e1c~^~N~^~None~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-commandBuffer-01806~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then image must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-01806)~^~ -VALIDATION_ERROR_18802401~^~Y~^~None~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18802413~^~Y~^~None~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18802415~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1880a001~^~Y~^~None~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-parameter)~^~implicit -VALIDATION_ERROR_1880a601~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-imageLayout-parameter~^~core~^~The spec valid usage text states 'imageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-parameter)~^~implicit -VALIDATION_ERROR_18810e01~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-pColor-parameter~^~core~^~The spec valid usage text states 'pColor must be a valid pointer to a valid VkClearColorValue union' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pColor-parameter)~^~implicit -VALIDATION_ERROR_18820601~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-pRanges-parameter~^~core~^~The spec valid usage text states 'pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pRanges-parameter)~^~implicit -VALIDATION_ERROR_1882a41b~^~Y~^~Unknown~^~vkCmdClearColorImage~^~VUID-vkCmdClearColorImage-rangeCount-arraylength~^~core~^~The spec valid usage text states 'rangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-rangeCount-arraylength)~^~implicit -VALIDATION_ERROR_18a00009~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commonparent)~^~implicit -VALIDATION_ERROR_18a00010~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-image-00008~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00008)~^~ -VALIDATION_ERROR_18a00012~^~Y~^~ClearDepthStencilImageErrors~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-image-00009~^~core~^~The spec valid usage text states 'image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00009)~^~ -VALIDATION_ERROR_18a00014~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-image-00010~^~core~^~The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00010)~^~ -VALIDATION_ERROR_18a00016~^~Y~^~InvalidImageLayout~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-imageLayout-00011~^~core~^~The spec valid usage text states 'imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-imageLayout-00011)~^~ -VALIDATION_ERROR_18a00017~^~Y~^~ClearDepthStencilImageErrors~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-renderpass)~^~implicit -VALIDATION_ERROR_18a00018~^~Y~^~InvalidImageLayout~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-imageLayout-00012~^~core~^~The spec valid usage text states 'imageLayout must be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-imageLayout-00012)~^~ -VALIDATION_ERROR_18a0001c~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-image-00014~^~core~^~The spec valid usage text states 'image must have a depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00014)~^~ -VALIDATION_ERROR_18a00b84~^~Y~^~ClearDepthStencilWithBadRange~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474~^~core~^~The spec valid usage text states 'The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474)~^~ -VALIDATION_ERROR_18a00b88~^~Y~^~ClearDepthStencilWithBadRange~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476~^~core~^~The spec valid usage text states 'The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476)~^~ -VALIDATION_ERROR_18a00d3c~^~Y~^~ClearDepthStencilWithBadRange~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-pRanges-01694~^~core~^~The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pRanges-01694)~^~ -VALIDATION_ERROR_18a00d3e~^~Y~^~ClearDepthStencilWithBadRange~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-pRanges-01695~^~core~^~The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pRanges-01695)~^~ -VALIDATION_ERROR_18a00e1e~^~N~^~None~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-commandBuffer-01807~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then image must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-01807)~^~ -VALIDATION_ERROR_18a00e20~^~N~^~None~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-commandBuffer-01808~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then image must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-01808)~^~ -VALIDATION_ERROR_18a02401~^~Y~^~None~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18a02413~^~Y~^~None~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18a02415~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_18a0a001~^~Y~^~None~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-parameter)~^~implicit -VALIDATION_ERROR_18a0a601~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-imageLayout-parameter~^~core~^~The spec valid usage text states 'imageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-imageLayout-parameter)~^~implicit -VALIDATION_ERROR_18a12801~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter~^~core~^~The spec valid usage text states 'pDepthStencil must be a valid pointer to a valid VkClearDepthStencilValue structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter)~^~implicit -VALIDATION_ERROR_18a20601~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-pRanges-parameter~^~core~^~The spec valid usage text states 'pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pRanges-parameter)~^~implicit -VALIDATION_ERROR_18a2a41b~^~Y~^~Unknown~^~vkCmdClearDepthStencilImage~^~VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength~^~core~^~The spec valid usage text states 'rangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength)~^~implicit -VALIDATION_ERROR_18c00009~^~Y~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commonparent)~^~implicit -VALIDATION_ERROR_18c00017~^~Y~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-renderpass)~^~implicit -VALIDATION_ERROR_18c000e0~^~N~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-size-00112~^~core~^~The spec valid usage text states 'The size member of each element of pRegions must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-size-00112)~^~ -VALIDATION_ERROR_18c000e2~^~N~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-srcOffset-00113~^~core~^~The spec valid usage text states 'The srcOffset member of each element of pRegions must be less than the size of srcBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcOffset-00113)~^~ -VALIDATION_ERROR_18c000e4~^~N~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-dstOffset-00114~^~core~^~The spec valid usage text states 'The dstOffset member of each element of pRegions must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstOffset-00114)~^~ -VALIDATION_ERROR_18c000e6~^~N~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-size-00115~^~core~^~The spec valid usage text states 'The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-size-00115)~^~ -VALIDATION_ERROR_18c000e8~^~N~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-size-00116~^~core~^~The spec valid usage text states 'The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-size-00116)~^~ -VALIDATION_ERROR_18c000ea~^~N~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-pRegions-00117~^~core~^~The spec valid usage text states 'The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-pRegions-00117)~^~ -VALIDATION_ERROR_18c000ec~^~Y~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-srcBuffer-00118~^~core~^~The spec valid usage text states 'srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcBuffer-00118)~^~ -VALIDATION_ERROR_18c000ee~^~Y~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-srcBuffer-00119~^~core~^~The spec valid usage text states 'If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcBuffer-00119)~^~ -VALIDATION_ERROR_18c000f0~^~Y~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-dstBuffer-00120~^~core~^~The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstBuffer-00120)~^~ -VALIDATION_ERROR_18c000f2~^~Y~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-dstBuffer-00121~^~core~^~The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstBuffer-00121)~^~ -VALIDATION_ERROR_18c00e3c~^~N~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-commandBuffer-01822~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-01822)~^~ -VALIDATION_ERROR_18c00e3e~^~N~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-commandBuffer-01823~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-01823)~^~ -VALIDATION_ERROR_18c00e40~^~N~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-commandBuffer-01824~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-01824)~^~ -VALIDATION_ERROR_18c02401~^~Y~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18c02413~^~Y~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18c02415~^~Y~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_18c06c01~^~Y~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-dstBuffer-parameter~^~core~^~The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstBuffer-parameter)~^~implicit -VALIDATION_ERROR_18c21001~^~Y~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-pRegions-parameter~^~core~^~The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount VkBufferCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-pRegions-parameter)~^~implicit -VALIDATION_ERROR_18c2ac1b~^~Y~^~Unknown~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-regionCount-arraylength~^~core~^~The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-regionCount-arraylength)~^~implicit -VALIDATION_ERROR_18c2c801~^~Y~^~None~^~vkCmdCopyBuffer~^~VUID-vkCmdCopyBuffer-srcBuffer-parameter~^~core~^~The spec valid usage text states 'srcBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcBuffer-parameter)~^~implicit -VALIDATION_ERROR_18e00009~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commonparent)~^~implicit -VALIDATION_ERROR_18e00017~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-renderpass)~^~implicit -VALIDATION_ERROR_18e00156~^~Y~^~ImageBufferCopyTests~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-pRegions-00171~^~core~^~The spec valid usage text states 'srcBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-00171)~^~ -VALIDATION_ERROR_18e00158~^~Y~^~ImageBufferCopyTests~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-pRegions-00172~^~core~^~The spec valid usage text states 'The image region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-00172)~^~ -VALIDATION_ERROR_18e0015a~^~N~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-pRegions-00173~^~core~^~The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-00173)~^~ -VALIDATION_ERROR_18e0015c~^~Y~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-srcBuffer-00174~^~core~^~The spec valid usage text states 'srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-srcBuffer-00174)~^~ -VALIDATION_ERROR_18e0015e~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImage-00175~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00175)~^~ -VALIDATION_ERROR_18e00160~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-srcBuffer-00176~^~core~^~The spec valid usage text states 'If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-srcBuffer-00176)~^~ -VALIDATION_ERROR_18e00162~^~Y~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImage-00177~^~core~^~The spec valid usage text states 'dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00177)~^~ -VALIDATION_ERROR_18e00164~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImage-00178~^~core~^~The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00178)~^~ -VALIDATION_ERROR_18e00166~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImage-00179~^~core~^~The spec valid usage text states 'dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00179)~^~ -VALIDATION_ERROR_18e00168~^~N~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImageLayout-00180~^~core~^~The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-00180)~^~ -VALIDATION_ERROR_18e0016a~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImageLayout-00181~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-00181)~^~ -VALIDATION_ERROR_18e00ae8~^~N~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImageLayout-01396~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-01396)~^~ -VALIDATION_ERROR_18e00d4a~^~N~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-imageSubresource-01701~^~core~^~The spec valid usage text states 'The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-imageSubresource-01701)~^~ -VALIDATION_ERROR_18e00d4c~^~N~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-imageSubresource-01702~^~core~^~The spec valid usage text states 'The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-imageSubresource-01702)~^~ -VALIDATION_ERROR_18e00e02~^~Y~^~CompressedImageMipCopyTests~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-imageOffset-01793~^~core~^~The spec valid usage text states 'The imageOffset and and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-imageOffset-01793)~^~ -VALIDATION_ERROR_18e00e48~^~N~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-commandBuffer-01828~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-01828)~^~ -VALIDATION_ERROR_18e00e4a~^~N~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-commandBuffer-01829~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-01829)~^~ -VALIDATION_ERROR_18e00e4c~^~N~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-commandBuffer-01830~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-01830)~^~ -VALIDATION_ERROR_18e02401~^~Y~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_18e02413~^~Y~^~ImageBufferCopyTests~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_18e02415~^~Y~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_18e07201~^~Y~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImage-parameter~^~core~^~The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-parameter)~^~implicit -VALIDATION_ERROR_18e07401~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter~^~core~^~The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter)~^~implicit -VALIDATION_ERROR_18e21001~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-pRegions-parameter~^~core~^~The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-parameter)~^~implicit -VALIDATION_ERROR_18e2ac1b~^~Y~^~Unknown~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-regionCount-arraylength~^~core~^~The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-regionCount-arraylength)~^~implicit -VALIDATION_ERROR_18e2c801~^~Y~^~None~^~vkCmdCopyBufferToImage~^~VUID-vkCmdCopyBufferToImage-srcBuffer-parameter~^~core~^~The spec valid usage text states 'srcBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-srcBuffer-parameter)~^~implicit -VALIDATION_ERROR_19000009~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commonparent)~^~implicit -VALIDATION_ERROR_19000017~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-renderpass)~^~implicit -VALIDATION_ERROR_190000f4~^~Y~^~CopyImageSrcSizeExceeded~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-pRegions-00122~^~core~^~The spec valid usage text states 'The source region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-00122)~^~ -VALIDATION_ERROR_190000f6~^~Y~^~CopyImageDstSizeExceeded~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-pRegions-00123~^~core~^~The spec valid usage text states 'The destination region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-00123)~^~ -VALIDATION_ERROR_190000f8~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-pRegions-00124~^~core~^~The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-00124)~^~ -VALIDATION_ERROR_190000fa~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-00125~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00125)~^~ -VALIDATION_ERROR_190000fc~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-00126~^~core~^~The spec valid usage text states 'srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00126)~^~ -VALIDATION_ERROR_190000fe~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-00127~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00127)~^~ -VALIDATION_ERROR_19000100~^~N~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImageLayout-00128~^~core~^~The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-00128)~^~ -VALIDATION_ERROR_19000102~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImageLayout-00129~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-00129)~^~ -VALIDATION_ERROR_19000104~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImage-00130~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-00130)~^~ -VALIDATION_ERROR_19000106~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImage-00131~^~core~^~The spec valid usage text states 'dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-00131)~^~ -VALIDATION_ERROR_19000108~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImage-00132~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-00132)~^~ -VALIDATION_ERROR_1900010a~^~N~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImageLayout-00133~^~core~^~The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-00133)~^~ -VALIDATION_ERROR_1900010c~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImageLayout-00134~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-00134)~^~ -VALIDATION_ERROR_1900010e~^~Y~^~CopyImageFormatSizeMismatch~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-00135~^~!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'The VkFormat of each of srcImage and dstImage must be compatible, as defined below' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00135)~^~ -VALIDATION_ERROR_19000110~^~Y~^~CopyImageSampleCountMismatch~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-00136~^~core~^~The spec valid usage text states 'The sample count of srcImage and dstImage must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00136)~^~ -VALIDATION_ERROR_19000ae6~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImageLayout-01395~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-01395)~^~ -VALIDATION_ERROR_19000c14~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-01546~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If srcImage is non-sparse then the image or disjoint plane to be copied must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-01546)~^~ -VALIDATION_ERROR_19000c16~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImage-01547~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-01547)~^~ -VALIDATION_ERROR_19000c18~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-01548~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined below' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-01548)~^~ -VALIDATION_ERROR_19000c1a~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-None-01549~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-None-01549)~^~ -VALIDATION_ERROR_19000c1c~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-aspectMask-01550~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'When a copy is performed to or from an image with a multi-planar format, the aspectMask of the srcSubresource and/or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for a VkFormat with three planes)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-aspectMask-01550)~^~ -VALIDATION_ERROR_19000d40~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcSubresource-01696~^~core~^~The spec valid usage text states 'The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcSubresource-01696)~^~ -VALIDATION_ERROR_19000d42~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstSubresource-01697~^~core~^~The spec valid usage text states 'The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstSubresource-01697)~^~ -VALIDATION_ERROR_19000d44~^~Y~^~CopyImageTypeExtentMismatch~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcSubresource-01698~^~core~^~The spec valid usage text states 'The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcSubresource-01698)~^~ -VALIDATION_ERROR_19000d46~^~Y~^~CopyImageTypeExtentMismatch~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstSubresource-01699~^~core~^~The spec valid usage text states 'The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstSubresource-01699)~^~ -VALIDATION_ERROR_19000dee~^~Y~^~MinImageTransferGranularity~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcOffset-01783~^~core~^~The spec valid usage text states 'The srcOffset and and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcOffset-01783)~^~ -VALIDATION_ERROR_19000df0~^~Y~^~MinImageTransferGranularity~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstOffset-01784~^~core~^~The spec valid usage text states 'The dstOffset and and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstOffset-01784)~^~ -VALIDATION_ERROR_19000e42~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-commandBuffer-01825~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-01825)~^~ -VALIDATION_ERROR_19000e44~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-commandBuffer-01826~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-01826)~^~ -VALIDATION_ERROR_19000e46~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-commandBuffer-01827~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-01827)~^~ -VALIDATION_ERROR_19000efa~^~N~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImageLayout-01917~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-01917)~^~ -VALIDATION_ERROR_19002401~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19002413~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19002415~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_19007201~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImage-parameter~^~core~^~The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-parameter)~^~implicit -VALIDATION_ERROR_19007401~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-dstImageLayout-parameter~^~core~^~The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-parameter)~^~implicit -VALIDATION_ERROR_19021001~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-pRegions-parameter~^~core~^~The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkImageCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-parameter)~^~implicit -VALIDATION_ERROR_1902ac1b~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-regionCount-arraylength~^~core~^~The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-regionCount-arraylength)~^~implicit -VALIDATION_ERROR_1902ce01~^~Y~^~None~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImage-parameter~^~core~^~The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-parameter)~^~implicit -VALIDATION_ERROR_1902d001~^~Y~^~Unknown~^~vkCmdCopyImage~^~VUID-vkCmdCopyImage-srcImageLayout-parameter~^~core~^~The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-parameter)~^~implicit -VALIDATION_ERROR_19200009~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commonparent)~^~implicit -VALIDATION_ERROR_19200017~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-renderpass)~^~implicit -VALIDATION_ERROR_1920016c~^~Y~^~ImageBufferCopyTests~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-pRegions-00182~^~core~^~The spec valid usage text states 'The image region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-00182)~^~ -VALIDATION_ERROR_1920016e~^~Y~^~ImageBufferCopyTests~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-pRegions-00183~^~core~^~The spec valid usage text states 'dstBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-00183)~^~ -VALIDATION_ERROR_19200170~^~N~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-pRegions-00184~^~core~^~The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-00184)~^~ -VALIDATION_ERROR_19200172~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImage-00185~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00185)~^~ -VALIDATION_ERROR_19200174~^~Y~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImage-00186~^~core~^~The spec valid usage text states 'srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00186)~^~ -VALIDATION_ERROR_19200176~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImage-00187~^~core~^~The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00187)~^~ -VALIDATION_ERROR_19200178~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImage-00188~^~core~^~The spec valid usage text states 'srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00188)~^~ -VALIDATION_ERROR_1920017a~^~N~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189~^~core~^~The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189)~^~ -VALIDATION_ERROR_1920017c~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190)~^~ -VALIDATION_ERROR_1920017e~^~Y~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-dstBuffer-00191~^~core~^~The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-dstBuffer-00191)~^~ -VALIDATION_ERROR_19200180~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-dstBuffer-00192~^~core~^~The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-dstBuffer-00192)~^~ -VALIDATION_ERROR_19200aea~^~N~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397)~^~ -VALIDATION_ERROR_19200d4e~^~N~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-imageSubresource-01703~^~core~^~The spec valid usage text states 'The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-imageSubresource-01703)~^~ -VALIDATION_ERROR_19200d50~^~N~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-imageSubresource-01704~^~core~^~The spec valid usage text states 'The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-imageSubresource-01704)~^~ -VALIDATION_ERROR_19200e04~^~Y~^~CompressedImageMipCopyTests~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-imageOffset-01794~^~core~^~The spec valid usage text states 'The imageOffset and and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-imageOffset-01794)~^~ -VALIDATION_ERROR_19200e4e~^~N~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-commandBuffer-01831~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-01831)~^~ -VALIDATION_ERROR_19200e50~^~N~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-commandBuffer-01832~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-01832)~^~ -VALIDATION_ERROR_19200e52~^~N~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-commandBuffer-01833~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-01833)~^~ -VALIDATION_ERROR_19202401~^~Y~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19202413~^~Y~^~ImageBufferCopyTests~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19202415~^~Y~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_19206c01~^~Y~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter~^~core~^~The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter)~^~implicit -VALIDATION_ERROR_19221001~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-pRegions-parameter~^~core~^~The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-parameter)~^~implicit -VALIDATION_ERROR_1922ac1b~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-regionCount-arraylength~^~core~^~The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-regionCount-arraylength)~^~implicit -VALIDATION_ERROR_1922ce01~^~Y~^~None~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImage-parameter~^~core~^~The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-parameter)~^~implicit -VALIDATION_ERROR_1922d001~^~Y~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter~^~core~^~The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter)~^~implicit -VALIDATION_ERROR_19400009~^~Y~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commonparent)~^~implicit -VALIDATION_ERROR_19400017~^~Y~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-renderpass)~^~implicit -VALIDATION_ERROR_19400666~^~N~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-dstOffset-00819~^~core~^~The spec valid usage text states 'dstOffset must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstOffset-00819)~^~ -VALIDATION_ERROR_19400668~^~N~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-firstQuery-00820~^~core~^~The spec valid usage text states 'firstQuery must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-firstQuery-00820)~^~ -VALIDATION_ERROR_1940066a~^~N~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-firstQuery-00821~^~core~^~The spec valid usage text states 'The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-firstQuery-00821)~^~ -VALIDATION_ERROR_1940066c~^~N~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-flags-00822~^~core~^~The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-flags-00822)~^~ -VALIDATION_ERROR_1940066e~^~N~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-flags-00823~^~core~^~The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-flags-00823)~^~ -VALIDATION_ERROR_19400670~^~N~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824~^~core~^~The spec valid usage text states 'dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824)~^~ -VALIDATION_ERROR_19400672~^~Y~^~None~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825~^~core~^~The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825)~^~ -VALIDATION_ERROR_19400674~^~Y~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826~^~core~^~The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826)~^~ -VALIDATION_ERROR_19400676~^~N~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-queryType-00827~^~core~^~The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-queryType-00827)~^~ -VALIDATION_ERROR_19402401~^~Y~^~None~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19402413~^~Y~^~None~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19402415~^~Y~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_19406c01~^~Y~^~None~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter~^~core~^~The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter)~^~implicit -VALIDATION_ERROR_19409001~^~Y~^~Unknown~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkQueryResultFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_19429801~^~Y~^~None~^~vkCmdCopyQueryPoolResults~^~VUID-vkCmdCopyQueryPoolResults-queryPool-parameter~^~core~^~The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-queryPool-parameter)~^~implicit -VALIDATION_ERROR_19602401~^~Y~^~None~^~vkCmdDebugMarkerBeginEXT~^~VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19602413~^~Y~^~None~^~vkCmdDebugMarkerBeginEXT~^~VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19602415~^~N~^~Unknown~^~vkCmdDebugMarkerBeginEXT~^~VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-cmdpool~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1961a601~^~N~^~Unknown~^~vkCmdDebugMarkerBeginEXT~^~VUID-vkCmdDebugMarkerBeginEXT-pMarkerInfo-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-pMarkerInfo-parameter)~^~implicit -VALIDATION_ERROR_198009ae~^~N~^~Unknown~^~vkCmdDebugMarkerEndEXT~^~VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'There must be an outstanding vkCmdDebugMarkerBeginEXT command prior to the vkCmdDebugMarkerEndEXT on the queue that commandBuffer is submitted to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239)~^~ -VALIDATION_ERROR_198009b0~^~N~^~Unknown~^~vkCmdDebugMarkerEndEXT~^~VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240)~^~ -VALIDATION_ERROR_19802401~^~Y~^~None~^~vkCmdDebugMarkerEndEXT~^~VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19802413~^~Y~^~None~^~vkCmdDebugMarkerEndEXT~^~VUID-vkCmdDebugMarkerEndEXT-commandBuffer-recording~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19802415~^~N~^~Unknown~^~vkCmdDebugMarkerEndEXT~^~VUID-vkCmdDebugMarkerEndEXT-commandBuffer-cmdpool~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_19a02401~^~Y~^~None~^~vkCmdDebugMarkerInsertEXT~^~VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19a02413~^~Y~^~None~^~vkCmdDebugMarkerInsertEXT~^~VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-recording~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19a02415~^~N~^~Unknown~^~vkCmdDebugMarkerInsertEXT~^~VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-cmdpool~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_19a1a601~^~N~^~Unknown~^~vkCmdDebugMarkerInsertEXT~^~VUID-vkCmdDebugMarkerInsertEXT-pMarkerInfo-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-pMarkerInfo-parameter)~^~implicit -VALIDATION_ERROR_19c00017~^~Y~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-renderpass)~^~implicit -VALIDATION_ERROR_19c00304~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatch~^~VUID-vkCmdDispatch-groupCountX-00386~^~core~^~The spec valid usage text states 'groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-groupCountX-00386)~^~ -VALIDATION_ERROR_19c00306~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatch~^~VUID-vkCmdDispatch-groupCountY-00387~^~core~^~The spec valid usage text states 'groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-groupCountY-00387)~^~ -VALIDATION_ERROR_19c00308~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatch~^~VUID-vkCmdDispatch-groupCountZ-00388~^~core~^~The spec valid usage text states 'groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-groupCountZ-00388)~^~ -VALIDATION_ERROR_19c0030a~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00389~^~core~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00389)~^~ -VALIDATION_ERROR_19c0030c~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00390~^~core~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00390)~^~ -VALIDATION_ERROR_19c0030e~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00391~^~core~^~The spec valid usage text states 'A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00391)~^~ -VALIDATION_ERROR_19c00310~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00392~^~core~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00392)~^~ -VALIDATION_ERROR_19c00312~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00393~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00393)~^~ -VALIDATION_ERROR_19c00314~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00394~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00394)~^~ -VALIDATION_ERROR_19c00316~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00395~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00395)~^~ -VALIDATION_ERROR_19c00318~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00396~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00396)~^~ -VALIDATION_ERROR_19c0031a~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00397~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00397)~^~ -VALIDATION_ERROR_19c0031c~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-linearTilingFeatures-00398~^~core~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-linearTilingFeatures-00398)~^~ -VALIDATION_ERROR_19c0031e~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-linearTilingFeatures-00399~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-linearTilingFeatures-00399)~^~ -VALIDATION_ERROR_19c00320~^~N~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-None-00400~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-None-00400)~^~ -VALIDATION_ERROR_19c00e68~^~N~^~None~^~vkCmdDispatch~^~VUID-vkCmdDispatch-commandBuffer-01844~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-01844)~^~ -VALIDATION_ERROR_19c00e6a~^~N~^~None~^~vkCmdDispatch~^~VUID-vkCmdDispatch-commandBuffer-01845~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-01845)~^~ -VALIDATION_ERROR_19c00e6c~^~N~^~None~^~vkCmdDispatch~^~VUID-vkCmdDispatch-commandBuffer-01846~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-01846)~^~ -VALIDATION_ERROR_19c02401~^~Y~^~None~^~vkCmdDispatch~^~VUID-vkCmdDispatch-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19c02413~^~Y~^~None~^~vkCmdDispatch~^~VUID-vkCmdDispatch-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19c02415~^~Y~^~Unknown~^~vkCmdDispatch~^~VUID-vkCmdDispatch-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_19e00017~^~N~^~Unknown~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-renderpass~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-renderpass)~^~implicit -VALIDATION_ERROR_19e00348~^~N~^~Unknown~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-None-00420~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'All valid usage rules from vkCmdDispatch apply' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-None-00420)~^~ -VALIDATION_ERROR_19e0034a~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-baseGroupX-00421~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupX-00421)~^~ -VALIDATION_ERROR_19e0034c~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-baseGroupX-00422~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupX-00422)~^~ -VALIDATION_ERROR_19e0034e~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-baseGroupZ-00423~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'baseGroupZ must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupZ-00423)~^~ -VALIDATION_ERROR_19e00350~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-groupCountX-00424~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] minus baseGroupX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-groupCountX-00424)~^~ -VALIDATION_ERROR_19e00352~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-groupCountY-00425~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] minus baseGroupY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-groupCountY-00425)~^~ -VALIDATION_ERROR_19e00354~^~Y~^~CmdDispatchExceedLimits~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-groupCountZ-00426~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] minus baseGroupZ' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-groupCountZ-00426)~^~ -VALIDATION_ERROR_19e00356~^~N~^~Unknown~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-baseGroupX-00427~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If any of baseGroupX, baseGroupY, or baseGroupZ are not zero, then the bound compute pipeline must have been created with the VK_PIPELINE_CREATE_DISPATCH_BASE flag.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupX-00427)~^~ -VALIDATION_ERROR_19e02401~^~Y~^~Unknown~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-commandBuffer-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_19e02413~^~N~^~Unknown~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-commandBuffer-recording~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_19e02415~^~N~^~Unknown~^~vkCmdDispatchBase~^~VUID-vkCmdDispatchBase-commandBuffer-cmdpool~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1a000009~^~Y~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-commonparent~^~core~^~The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commonparent)~^~implicit -VALIDATION_ERROR_1a000017~^~Y~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-renderpass)~^~implicit -VALIDATION_ERROR_1a000322~^~Y~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-buffer-00401~^~core~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-buffer-00401)~^~ -VALIDATION_ERROR_1a000324~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00402~^~core~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00402)~^~ -VALIDATION_ERROR_1a000326~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00403~^~core~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00403)~^~ -VALIDATION_ERROR_1a000328~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00404~^~core~^~The spec valid usage text states 'A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00404)~^~ -VALIDATION_ERROR_1a00032a~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-buffer-00405~^~core~^~The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-buffer-00405)~^~ -VALIDATION_ERROR_1a00032c~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-offset-00406~^~core~^~The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-offset-00406)~^~ -VALIDATION_ERROR_1a00032e~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-offset-00407~^~core~^~The spec valid usage text states 'The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-offset-00407)~^~ -VALIDATION_ERROR_1a000330~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00408~^~core~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00408)~^~ -VALIDATION_ERROR_1a000332~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00409~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00409)~^~ -VALIDATION_ERROR_1a000334~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00410~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00410)~^~ -VALIDATION_ERROR_1a000336~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00411~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00411)~^~ -VALIDATION_ERROR_1a000338~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00412~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00412)~^~ -VALIDATION_ERROR_1a00033a~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00413~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00413)~^~ -VALIDATION_ERROR_1a00033c~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-linearTilingFeatures-00414~^~core~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-linearTilingFeatures-00414)~^~ -VALIDATION_ERROR_1a00033e~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-linearTilingFeatures-00415~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-linearTilingFeatures-00415)~^~ -VALIDATION_ERROR_1a000340~^~N~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-None-00416~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00416)~^~ -VALIDATION_ERROR_1a000e6e~^~N~^~None~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-commandBuffer-01847~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-01847)~^~ -VALIDATION_ERROR_1a000e70~^~N~^~None~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-commandBuffer-01848~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-01848)~^~ -VALIDATION_ERROR_1a000e72~^~N~^~None~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-commandBuffer-01849~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-01849)~^~ -VALIDATION_ERROR_1a001a01~^~Y~^~None~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-buffer-parameter)~^~implicit -VALIDATION_ERROR_1a002401~^~Y~^~None~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1a002413~^~Y~^~None~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1a002415~^~Y~^~Unknown~^~vkCmdDispatchIndirect~^~VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1a200017~^~Y~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-renderpass~^~core~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-renderpass)~^~implicit -VALIDATION_ERROR_1a200366~^~Y~^~RenderPassIncompatible~^~vkCmdDraw~^~VUID-vkCmdDraw-renderPass-00435~^~core~^~The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-renderPass-00435)~^~ -VALIDATION_ERROR_1a200368~^~Y~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-subpass-00436~^~core~^~The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-subpass-00436)~^~ -VALIDATION_ERROR_1a20036a~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00437~^~core~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00437)~^~ -VALIDATION_ERROR_1a20036c~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00438~^~core~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00438)~^~ -VALIDATION_ERROR_1a20036e~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00439~^~core~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00439)~^~ -VALIDATION_ERROR_1a200370~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00440~^~core~^~The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00440)~^~ -VALIDATION_ERROR_1a200372~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00441~^~core~^~The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00441)~^~ -VALIDATION_ERROR_1a200374~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00442~^~core~^~The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00442)~^~ -VALIDATION_ERROR_1a200376~^~Y~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00443~^~core~^~The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00443)~^~ -VALIDATION_ERROR_1a200378~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00444~^~core~^~The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00444)~^~ -VALIDATION_ERROR_1a20037a~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00445~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00445)~^~ -VALIDATION_ERROR_1a20037c~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00446~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00446)~^~ -VALIDATION_ERROR_1a20037e~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00447~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00447)~^~ -VALIDATION_ERROR_1a200380~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00448~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00448)~^~ -VALIDATION_ERROR_1a200382~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00449~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00449)~^~ -VALIDATION_ERROR_1a200384~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-linearTilingFeatures-00450~^~core~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-linearTilingFeatures-00450)~^~ -VALIDATION_ERROR_1a200386~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-linearTilingFeatures-00451~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-linearTilingFeatures-00451)~^~ -VALIDATION_ERROR_1a200388~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-None-00452~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-None-00452)~^~ -VALIDATION_ERROR_1a20038a~^~N~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-maxMultiviewInstanceIndex-00453~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-maxMultiviewInstanceIndex-00453)~^~ -VALIDATION_ERROR_1a200bb6~^~N~^~None~^~vkCmdDraw~^~VUID-vkCmdDraw-None-01499~^~core~^~The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-01499)~^~ -VALIDATION_ERROR_1a200bd0~^~N~^~None~^~vkCmdDraw~^~VUID-vkCmdDraw-sampleLocationsEnable-01512~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-sampleLocationsEnable-01512)~^~ -VALIDATION_ERROR_1a200e74~^~N~^~None~^~vkCmdDraw~^~VUID-vkCmdDraw-commandBuffer-01850~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-01850)~^~ -VALIDATION_ERROR_1a200e76~^~N~^~None~^~vkCmdDraw~^~VUID-vkCmdDraw-commandBuffer-01851~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-01851)~^~ -VALIDATION_ERROR_1a200e78~^~N~^~None~^~vkCmdDraw~^~VUID-vkCmdDraw-commandBuffer-01852~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-01852)~^~ -VALIDATION_ERROR_1a202401~^~Y~^~None~^~vkCmdDraw~^~VUID-vkCmdDraw-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1a202413~^~Y~^~None~^~vkCmdDraw~^~VUID-vkCmdDraw-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1a202415~^~Y~^~Unknown~^~vkCmdDraw~^~VUID-vkCmdDraw-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1a400017~^~Y~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-renderpass~^~core~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-renderpass)~^~implicit -VALIDATION_ERROR_1a40038c~^~Y~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-renderPass-00454~^~core~^~The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-renderPass-00454)~^~ -VALIDATION_ERROR_1a40038e~^~Y~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-subpass-00455~^~core~^~The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-subpass-00455)~^~ -VALIDATION_ERROR_1a400390~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00456~^~core~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00456)~^~ -VALIDATION_ERROR_1a400392~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00457~^~core~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00457)~^~ -VALIDATION_ERROR_1a400394~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00458~^~core~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00458)~^~ -VALIDATION_ERROR_1a400396~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00459~^~core~^~The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00459)~^~ -VALIDATION_ERROR_1a400398~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00460~^~core~^~The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00460)~^~ -VALIDATION_ERROR_1a40039a~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00461~^~core~^~The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00461)~^~ -VALIDATION_ERROR_1a40039c~^~Y~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00462~^~core~^~The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00462)~^~ -VALIDATION_ERROR_1a40039e~^~Y~^~IndexBufferBadSizeOffset~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-indexSize-00463~^~core~^~The spec valid usage text states '(indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-indexSize-00463)~^~ -VALIDATION_ERROR_1a4003a0~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00464~^~core~^~The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00464)~^~ -VALIDATION_ERROR_1a4003a2~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00465~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00465)~^~ -VALIDATION_ERROR_1a4003a4~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00466~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00466)~^~ -VALIDATION_ERROR_1a4003a6~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00467~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00467)~^~ -VALIDATION_ERROR_1a4003a8~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00468~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00468)~^~ -VALIDATION_ERROR_1a4003aa~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00469~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00469)~^~ -VALIDATION_ERROR_1a4003ac~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-linearTilingFeatures-00470~^~core~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-linearTilingFeatures-00470)~^~ -VALIDATION_ERROR_1a4003ae~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-linearTilingFeatures-00471~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-linearTilingFeatures-00471)~^~ -VALIDATION_ERROR_1a4003b0~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-00472~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00472)~^~ -VALIDATION_ERROR_1a4003b2~^~N~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-00473~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-00473)~^~ -VALIDATION_ERROR_1a400bb8~^~N~^~None~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-None-01500~^~core~^~The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-01500)~^~ -VALIDATION_ERROR_1a400bd2~^~N~^~None~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-sampleLocationsEnable-01513~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-sampleLocationsEnable-01513)~^~ -VALIDATION_ERROR_1a400e7a~^~N~^~None~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-commandBuffer-01853~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-01853)~^~ -VALIDATION_ERROR_1a400e7c~^~N~^~None~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-commandBuffer-01854~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-01854)~^~ -VALIDATION_ERROR_1a400e7e~^~N~^~None~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-commandBuffer-01855~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-01855)~^~ -VALIDATION_ERROR_1a402401~^~Y~^~None~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1a402413~^~Y~^~None~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1a402415~^~Y~^~Unknown~^~vkCmdDrawIndexed~^~VUID-vkCmdDrawIndexed-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1a600009~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-commonparent~^~core~^~The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commonparent)~^~implicit -VALIDATION_ERROR_1a600017~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-renderpass~^~core~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-renderpass)~^~implicit -VALIDATION_ERROR_1a60041c~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-buffer-00526~^~core~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-buffer-00526)~^~ -VALIDATION_ERROR_1a60041e~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-offset-00527~^~core~^~The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-offset-00527)~^~ -VALIDATION_ERROR_1a600420~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-drawCount-00528~^~core~^~The spec valid usage text states 'If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00528)~^~ -VALIDATION_ERROR_1a600422~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-drawCount-00529~^~core~^~The spec valid usage text states 'If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00529)~^~ -VALIDATION_ERROR_1a600424~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-firstInstance-00530~^~core~^~The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-firstInstance-00530)~^~ -VALIDATION_ERROR_1a600426~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-renderPass-00531~^~core~^~The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-renderPass-00531)~^~ -VALIDATION_ERROR_1a600428~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-subpass-00532~^~core~^~The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-subpass-00532)~^~ -VALIDATION_ERROR_1a60042a~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00533~^~core~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00533)~^~ -VALIDATION_ERROR_1a60042c~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00534~^~core~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00534)~^~ -VALIDATION_ERROR_1a60042e~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00535~^~core~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00535)~^~ -VALIDATION_ERROR_1a600430~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00536~^~core~^~The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00536)~^~ -VALIDATION_ERROR_1a600432~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00537~^~core~^~The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00537)~^~ -VALIDATION_ERROR_1a600434~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00538~^~core~^~The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00538)~^~ -VALIDATION_ERROR_1a600436~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-drawCount-00539~^~core~^~The spec valid usage text states 'If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00539)~^~ -VALIDATION_ERROR_1a600438~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-drawCount-00540~^~core~^~The spec valid usage text states 'If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00540)~^~ -VALIDATION_ERROR_1a60043a~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-drawCount-00541~^~core~^~The spec valid usage text states 'drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00541)~^~ -VALIDATION_ERROR_1a60043c~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00542~^~core~^~The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00542)~^~ -VALIDATION_ERROR_1a60043e~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00543~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00543)~^~ -VALIDATION_ERROR_1a600440~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00544~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00544)~^~ -VALIDATION_ERROR_1a600442~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00545~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00545)~^~ -VALIDATION_ERROR_1a600444~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00546~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00546)~^~ -VALIDATION_ERROR_1a600446~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00547~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00547)~^~ -VALIDATION_ERROR_1a600448~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00548~^~core~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00548)~^~ -VALIDATION_ERROR_1a60044a~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00549~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00549)~^~ -VALIDATION_ERROR_1a60044c~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-00550~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00550)~^~ -VALIDATION_ERROR_1a60044e~^~N~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-00551~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-00551)~^~ -VALIDATION_ERROR_1a600bbe~^~N~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-None-01503~^~core~^~The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-01503)~^~ -VALIDATION_ERROR_1a600bd8~^~N~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-01516~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-01516)~^~ -VALIDATION_ERROR_1a600d02~^~N~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-buffer-01665~^~core~^~The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-buffer-01665)~^~ -VALIDATION_ERROR_1a600e8c~^~N~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-commandBuffer-01862~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-01862)~^~ -VALIDATION_ERROR_1a600e8e~^~N~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-commandBuffer-01863~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-01863)~^~ -VALIDATION_ERROR_1a600e90~^~N~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-commandBuffer-01864~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-01864)~^~ -VALIDATION_ERROR_1a601a01~^~Y~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-buffer-parameter)~^~implicit -VALIDATION_ERROR_1a602401~^~Y~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1a602413~^~Y~^~None~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1a602415~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirect~^~VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1a800009~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-commonparent~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commonparent)~^~implicit -VALIDATION_ERROR_1a800017~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-renderpass~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-renderpass)~^~implicit -VALIDATION_ERROR_1a800456~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-offset-00555~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-offset-00555)~^~ -VALIDATION_ERROR_1a800458~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-countBufferOffset-00556~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'countBufferOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBufferOffset-00556)~^~ -VALIDATION_ERROR_1a80045a~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-stride-00557~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-stride-00557)~^~ -VALIDATION_ERROR_1a80045c~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-maxDrawCount-00558~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-maxDrawCount-00558)~^~ -VALIDATION_ERROR_1a80045e~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-firstInstance-00559~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-firstInstance-00559)~^~ -VALIDATION_ERROR_1a800460~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-renderPass-00560~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-renderPass-00560)~^~ -VALIDATION_ERROR_1a800462~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-subpass-00561~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-subpass-00561)~^~ -VALIDATION_ERROR_1a800464~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00562~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00562)~^~ -VALIDATION_ERROR_1a800466~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00563~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00563)~^~ -VALIDATION_ERROR_1a800468~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00564~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00564)~^~ -VALIDATION_ERROR_1a80046a~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00565~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00565)~^~ -VALIDATION_ERROR_1a80046c~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00566~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00566)~^~ -VALIDATION_ERROR_1a80046e~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00567~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00567)~^~ -VALIDATION_ERROR_1a800470~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00568~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00568)~^~ -VALIDATION_ERROR_1a800472~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00569~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00569)~^~ -VALIDATION_ERROR_1a800474~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-drawCount-00570~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-drawCount-00570)~^~ -VALIDATION_ERROR_1a800476~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00571~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00571)~^~ -VALIDATION_ERROR_1a800478~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00572~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00572)~^~ -VALIDATION_ERROR_1a80047a~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00573~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00573)~^~ -VALIDATION_ERROR_1a80047c~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00574~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00574)~^~ -VALIDATION_ERROR_1a80047e~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00575~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00575)~^~ -VALIDATION_ERROR_1a800480~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-00576~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00576)~^~ -VALIDATION_ERROR_1a800482~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-linearTilingFeatures-00577~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-linearTilingFeatures-00577)~^~ -VALIDATION_ERROR_1a800484~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-maxMultiviewInstanceIndex-00578~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-maxMultiviewInstanceIndex-00578)~^~ -VALIDATION_ERROR_1a800bc0~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-None-01504~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-01504)~^~ -VALIDATION_ERROR_1a800bda~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-sampleLocationsEnable-01517~^~(VK_AMD_draw_indirect_count)+(VK_EXT_sample_locations)~^~The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-sampleLocationsEnable-01517)~^~ -VALIDATION_ERROR_1a800d04~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01666~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01666)~^~ -VALIDATION_ERROR_1a800d06~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01667~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01667)~^~ -VALIDATION_ERROR_1a800d08~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01668~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01668)~^~ -VALIDATION_ERROR_1a800d0a~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01669~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01669)~^~ -VALIDATION_ERROR_1a800e92~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01865~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01865)~^~ -VALIDATION_ERROR_1a800e94~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01866~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01866)~^~ -VALIDATION_ERROR_1a800e96~^~N~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01867~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01867)~^~ -VALIDATION_ERROR_1a801a01~^~Y~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-parameter~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-parameter)~^~implicit -VALIDATION_ERROR_1a802401~^~Y~^~None~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-parameter~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1a802413~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-recording~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1a802415~^~N~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-cmdpool~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1a803401~^~Y~^~Unknown~^~vkCmdDrawIndexedIndirectCountAMD~^~VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-parameter~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'countBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-parameter)~^~implicit -VALIDATION_ERROR_1aa00009~^~Y~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-commonparent~^~core~^~The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commonparent)~^~implicit -VALIDATION_ERROR_1aa00017~^~Y~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-renderpass~^~core~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-renderpass)~^~implicit -VALIDATION_ERROR_1aa003b4~^~Y~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-buffer-00474~^~core~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-buffer-00474)~^~ -VALIDATION_ERROR_1aa003b6~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-offset-00475~^~core~^~The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-offset-00475)~^~ -VALIDATION_ERROR_1aa003b8~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-drawCount-00476~^~core~^~The spec valid usage text states 'If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00476)~^~ -VALIDATION_ERROR_1aa003ba~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-drawCount-00477~^~core~^~The spec valid usage text states 'If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00477)~^~ -VALIDATION_ERROR_1aa003bc~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-firstInstance-00478~^~core~^~The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-firstInstance-00478)~^~ -VALIDATION_ERROR_1aa003be~^~Y~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-renderPass-00479~^~core~^~The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-renderPass-00479)~^~ -VALIDATION_ERROR_1aa003c0~^~Y~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-subpass-00480~^~core~^~The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-subpass-00480)~^~ -VALIDATION_ERROR_1aa003c2~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00481~^~core~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00481)~^~ -VALIDATION_ERROR_1aa003c4~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00482~^~core~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00482)~^~ -VALIDATION_ERROR_1aa003c6~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00483~^~core~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00483)~^~ -VALIDATION_ERROR_1aa003c8~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00484~^~core~^~The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00484)~^~ -VALIDATION_ERROR_1aa003ca~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00485~^~core~^~The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00485)~^~ -VALIDATION_ERROR_1aa003cc~^~Y~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00486~^~core~^~The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00486)~^~ -VALIDATION_ERROR_1aa003ce~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-drawCount-00487~^~core~^~The spec valid usage text states 'If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00487)~^~ -VALIDATION_ERROR_1aa003d0~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-drawCount-00488~^~core~^~The spec valid usage text states 'If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00488)~^~ -VALIDATION_ERROR_1aa003d2~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-drawCount-00489~^~core~^~The spec valid usage text states 'drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00489)~^~ -VALIDATION_ERROR_1aa003d4~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00490~^~core~^~The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00490)~^~ -VALIDATION_ERROR_1aa003d6~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00491~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00491)~^~ -VALIDATION_ERROR_1aa003d8~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00492~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00492)~^~ -VALIDATION_ERROR_1aa003da~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00493~^~core~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00493)~^~ -VALIDATION_ERROR_1aa003dc~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00494~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00494)~^~ -VALIDATION_ERROR_1aa003de~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00495~^~core~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00495)~^~ -VALIDATION_ERROR_1aa003e0~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-linearTilingFeatures-00496~^~core~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-linearTilingFeatures-00496)~^~ -VALIDATION_ERROR_1aa003e2~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-linearTilingFeatures-00497~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-linearTilingFeatures-00497)~^~ -VALIDATION_ERROR_1aa003e4~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-00498~^~(VK_IMG_filter_cubic)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00498)~^~ -VALIDATION_ERROR_1aa003e6~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-00499~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-00499)~^~ -VALIDATION_ERROR_1aa00bba~^~N~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-None-01501~^~core~^~The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-01501)~^~ -VALIDATION_ERROR_1aa00bd4~^~N~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-sampleLocationsEnable-01514~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-sampleLocationsEnable-01514)~^~ -VALIDATION_ERROR_1aa00cf8~^~N~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-buffer-01660~^~core~^~The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-buffer-01660)~^~ -VALIDATION_ERROR_1aa00e80~^~N~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-commandBuffer-01856~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-01856)~^~ -VALIDATION_ERROR_1aa00e82~^~N~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-commandBuffer-01857~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-01857)~^~ -VALIDATION_ERROR_1aa00e84~^~N~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-commandBuffer-01858~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-01858)~^~ -VALIDATION_ERROR_1aa01a01~^~Y~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-buffer-parameter)~^~implicit -VALIDATION_ERROR_1aa02401~^~Y~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1aa02413~^~Y~^~None~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1aa02415~^~Y~^~Unknown~^~vkCmdDrawIndirect~^~VUID-vkCmdDrawIndirect-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1ac00009~^~Y~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-commonparent~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commonparent)~^~implicit -VALIDATION_ERROR_1ac00017~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-renderpass~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-renderpass)~^~implicit -VALIDATION_ERROR_1ac003ec~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-offset-00502~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-offset-00502)~^~ -VALIDATION_ERROR_1ac003ee~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-countBufferOffset-00503~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'countBufferOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBufferOffset-00503)~^~ -VALIDATION_ERROR_1ac003f0~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-stride-00504~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-stride-00504)~^~ -VALIDATION_ERROR_1ac003f2~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-maxDrawCount-00505~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-maxDrawCount-00505)~^~ -VALIDATION_ERROR_1ac003f4~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-firstInstance-00506~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-firstInstance-00506)~^~ -VALIDATION_ERROR_1ac003f6~^~Y~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-renderPass-00507~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-renderPass-00507)~^~ -VALIDATION_ERROR_1ac003f8~^~Y~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-subpass-00508~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-subpass-00508)~^~ -VALIDATION_ERROR_1ac003fa~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00509~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00509)~^~ -VALIDATION_ERROR_1ac003fc~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00510~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00510)~^~ -VALIDATION_ERROR_1ac003fe~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00511~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00511)~^~ -VALIDATION_ERROR_1ac00400~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00512~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00512)~^~ -VALIDATION_ERROR_1ac00402~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00513~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00513)~^~ -VALIDATION_ERROR_1ac00404~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00514~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00514)~^~ -VALIDATION_ERROR_1ac00406~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-countBuffer-00515~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-00515)~^~ -VALIDATION_ERROR_1ac00408~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-countBuffer-00516~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-00516)~^~ -VALIDATION_ERROR_1ac0040a~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-countBuffer-00517~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-00517)~^~ -VALIDATION_ERROR_1ac0040c~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00518~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00518)~^~ -VALIDATION_ERROR_1ac0040e~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00519~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00519)~^~ -VALIDATION_ERROR_1ac00410~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00520~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00520)~^~ -VALIDATION_ERROR_1ac00412~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00521~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00521)~^~ -VALIDATION_ERROR_1ac00414~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00522~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00522)~^~ -VALIDATION_ERROR_1ac00416~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-00523~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00523)~^~ -VALIDATION_ERROR_1ac00418~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-linearTilingFeatures-00524~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-linearTilingFeatures-00524)~^~ -VALIDATION_ERROR_1ac0041a~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-maxMultiviewInstanceIndex-00525~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-maxMultiviewInstanceIndex-00525)~^~ -VALIDATION_ERROR_1ac00bbc~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-None-01502~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-01502)~^~ -VALIDATION_ERROR_1ac00bd6~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-sampleLocationsEnable-01515~^~(VK_AMD_draw_indirect_count)+(VK_EXT_sample_locations)~^~The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-sampleLocationsEnable-01515)~^~ -VALIDATION_ERROR_1ac00cfa~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-buffer-01661~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-buffer-01661)~^~ -VALIDATION_ERROR_1ac00cfc~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-buffer-01662~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-buffer-01662)~^~ -VALIDATION_ERROR_1ac00cfe~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-countBuffer-01663~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-01663)~^~ -VALIDATION_ERROR_1ac00d00~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-countBuffer-01664~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-01664)~^~ -VALIDATION_ERROR_1ac00e86~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01859~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01859)~^~ -VALIDATION_ERROR_1ac00e88~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01860~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01860)~^~ -VALIDATION_ERROR_1ac00e8a~^~N~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01861~^~(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01861)~^~ -VALIDATION_ERROR_1ac01a01~^~Y~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-buffer-parameter~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-buffer-parameter)~^~implicit -VALIDATION_ERROR_1ac02401~^~Y~^~None~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-commandBuffer-parameter~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1ac02413~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-commandBuffer-recording~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1ac02415~^~N~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-commandBuffer-cmdpool~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1ac03401~^~Y~^~Unknown~^~vkCmdDrawIndirectCountAMD~^~VUID-vkCmdDrawIndirectCountAMD-countBuffer-parameter~^~(VK_AMD_draw_indirect_count)~^~The spec valid usage text states 'countBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-parameter)~^~implicit -VALIDATION_ERROR_1ae00009~^~Y~^~Unknown~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commonparent)~^~implicit -VALIDATION_ERROR_1ae00654~^~N~^~Unknown~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-query-00810~^~core~^~The spec valid usage text states 'query must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-query-00810)~^~ -VALIDATION_ERROR_1ae00658~^~N~^~Unknown~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-query-00812~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass's view mask must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndQuery-query-00812)~^~ -VALIDATION_ERROR_1ae00ebc~^~N~^~None~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-commandBuffer-01886~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'commandBuffer must not be a protected command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-01886)~^~ -VALIDATION_ERROR_1ae00f06~^~Y~^~None~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-None-01923~^~core~^~The spec valid usage text states 'All queries used by the command must be active' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-None-01923)~^~ -VALIDATION_ERROR_1ae02401~^~Y~^~None~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1ae02413~^~Y~^~None~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1ae02415~^~Y~^~Unknown~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1ae29801~^~Y~^~None~^~vkCmdEndQuery~^~VUID-vkCmdEndQuery-queryPool-parameter~^~core~^~The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-queryPool-parameter)~^~implicit -VALIDATION_ERROR_1b000017~^~Y~^~Unknown~^~vkCmdEndRenderPass~^~VUID-vkCmdEndRenderPass-renderpass~^~core~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-renderpass)~^~implicit -VALIDATION_ERROR_1b000019~^~Y~^~Unknown~^~vkCmdEndRenderPass~^~VUID-vkCmdEndRenderPass-bufferlevel~^~core~^~The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-bufferlevel)~^~implicit -VALIDATION_ERROR_1b00071c~^~Y~^~Unknown~^~vkCmdEndRenderPass~^~VUID-vkCmdEndRenderPass-None-00910~^~core~^~The spec valid usage text states 'The current subpass index must be equal to the number of subpasses in the render pass minus one' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-None-00910)~^~ -VALIDATION_ERROR_1b002401~^~Y~^~None~^~vkCmdEndRenderPass~^~VUID-vkCmdEndRenderPass-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1b002413~^~Y~^~None~^~vkCmdEndRenderPass~^~VUID-vkCmdEndRenderPass-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1b002415~^~Y~^~Unknown~^~vkCmdEndRenderPass~^~VUID-vkCmdEndRenderPass-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1b200009~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and the elements of pCommandBuffers must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commonparent)~^~implicit -VALIDATION_ERROR_1b200019~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-bufferlevel~^~core~^~The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-bufferlevel)~^~implicit -VALIDATION_ERROR_1b2000ae~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-00087~^~core~^~The spec valid usage text states 'commandBuffer must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_PRIMARY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00087)~^~ -VALIDATION_ERROR_1b2000b0~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00088~^~core~^~The spec valid usage text states 'Each element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00088)~^~ -VALIDATION_ERROR_1b2000b2~^~Y~^~ExecuteUnrecordedPrimaryCB~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00089~^~core~^~The spec valid usage text states 'Each element of pCommandBuffers must be in the pending or executable state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00089)~^~ -VALIDATION_ERROR_1b2000b4~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00090~^~core~^~The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, and it was recorded into any other primary command buffer, that primary command buffer must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00090)~^~ -VALIDATION_ERROR_1b2000b6~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00091~^~core~^~The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00091)~^~ -VALIDATION_ERROR_1b2000b8~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00092~^~core~^~The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not have already been recorded to commandBuffer.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00092)~^~ -VALIDATION_ERROR_1b2000ba~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00093~^~core~^~The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not appear more than once in pCommandBuffers.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00093)~^~ -VALIDATION_ERROR_1b2000bc~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00094~^~core~^~The spec valid usage text states 'Each element of pCommandBuffers must have been allocated from a VkCommandPool that was created for the same queue family as the VkCommandPool from which commandBuffer was allocated' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00094)~^~ -VALIDATION_ERROR_1b2000be~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-contents-00095~^~core~^~The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of vkCmdBeginRenderPass set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-contents-00095)~^~ -VALIDATION_ERROR_1b2000c0~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00096~^~core~^~The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00096)~^~ -VALIDATION_ERROR_1b2000c2~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00097~^~core~^~The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00097)~^~ -VALIDATION_ERROR_1b2000c4~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pInheritanceInfo-00098~^~core~^~The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, the render passes specified in the pname::pBeginInfo::pInheritanceInfo::renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be compatible with the current render pass.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pInheritanceInfo-00098)~^~ -VALIDATION_ERROR_1b2000c6~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00099~^~core~^~The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00099)~^~ -VALIDATION_ERROR_1b2000c8~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00100~^~core~^~The spec valid usage text states 'If vkCmdExecuteCommands is not being called within a render pass instance, each element of pCommandBuffers must not have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00100)~^~ -VALIDATION_ERROR_1b2000ca~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-00101~^~core~^~The spec valid usage text states 'If the inherited queries feature is not enabled, commandBuffer must not have any queries active' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00101)~^~ -VALIDATION_ERROR_1b2000cc~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-00102~^~core~^~The spec valid usage text states 'If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00102)~^~ -VALIDATION_ERROR_1b2000ce~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-00103~^~core~^~The spec valid usage text states 'If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00103)~^~ -VALIDATION_ERROR_1b2000d0~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-00104~^~core~^~The spec valid usage text states 'If commandBuffer has a VK_QUERY_TYPE_PIPELINE_STATISTICS query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00104)~^~ -VALIDATION_ERROR_1b2000d2~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-00105~^~core~^~The spec valid usage text states 'Each element of pCommandBuffers must not begin any query types that are active in commandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00105)~^~ -VALIDATION_ERROR_1b200e38~^~N~^~None~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-01820~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then each element of pCommandBuffers must be a protected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-01820)~^~ -VALIDATION_ERROR_1b200e3a~^~N~^~None~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-01821~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then each element of pCommandBuffers must be an unprotected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-01821)~^~ -VALIDATION_ERROR_1b202401~^~Y~^~None~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1b202413~^~Y~^~None~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1b202415~^~Y~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1b20261b~^~N~^~Unknown~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-commandBufferCount-arraylength~^~core~^~The spec valid usage text states 'commandBufferCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBufferCount-arraylength)~^~implicit -VALIDATION_ERROR_1b211401~^~Y~^~None~^~vkCmdExecuteCommands~^~VUID-vkCmdExecuteCommands-pCommandBuffers-parameter~^~core~^~The spec valid usage text states 'pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-parameter)~^~implicit -VALIDATION_ERROR_1b400009~^~Y~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commonparent)~^~implicit -VALIDATION_ERROR_1b400017~^~Y~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-renderpass)~^~implicit -VALIDATION_ERROR_1b400030~^~N~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-dstOffset-00024~^~core~^~The spec valid usage text states 'dstOffset must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstOffset-00024)~^~ -VALIDATION_ERROR_1b400032~^~Y~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-dstOffset-00025~^~core~^~The spec valid usage text states 'dstOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstOffset-00025)~^~ -VALIDATION_ERROR_1b400034~^~Y~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-size-00026~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-size-00026)~^~ -VALIDATION_ERROR_1b400036~^~N~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-size-00027~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-size-00027)~^~ -VALIDATION_ERROR_1b400038~^~Y~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-size-00028~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-size-00028)~^~ -VALIDATION_ERROR_1b40003a~^~Y~^~None~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-dstBuffer-00029~^~core~^~The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstBuffer-00029)~^~ -VALIDATION_ERROR_1b40003c~^~N~^~None~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-commandBuffer-00030~^~!(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-00030)~^~ -VALIDATION_ERROR_1b40003e~^~Y~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-dstBuffer-00031~^~core~^~The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstBuffer-00031)~^~ -VALIDATION_ERROR_1b400e26~^~N~^~None~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-commandBuffer-01811~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-01811)~^~ -VALIDATION_ERROR_1b400e28~^~N~^~None~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-commandBuffer-01812~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-01812)~^~ -VALIDATION_ERROR_1b402401~^~Y~^~None~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1b402413~^~Y~^~None~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1b402415~^~Y~^~Unknown~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1b406c01~^~Y~^~None~^~vkCmdFillBuffer~^~VUID-vkCmdFillBuffer-dstBuffer-parameter~^~core~^~The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstBuffer-parameter)~^~implicit -VALIDATION_ERROR_1b600017~^~Y~^~Unknown~^~vkCmdNextSubpass~^~VUID-vkCmdNextSubpass-renderpass~^~core~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-renderpass)~^~implicit -VALIDATION_ERROR_1b600019~^~Y~^~Unknown~^~vkCmdNextSubpass~^~VUID-vkCmdNextSubpass-bufferlevel~^~core~^~The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-bufferlevel)~^~implicit -VALIDATION_ERROR_1b60071a~^~Y~^~Unknown~^~vkCmdNextSubpass~^~VUID-vkCmdNextSubpass-None-00909~^~core~^~The spec valid usage text states 'The current subpass index must be less than the number of subpasses in the render pass minus one' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-None-00909)~^~ -VALIDATION_ERROR_1b602401~^~Y~^~None~^~vkCmdNextSubpass~^~VUID-vkCmdNextSubpass-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1b602413~^~Y~^~None~^~vkCmdNextSubpass~^~VUID-vkCmdNextSubpass-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1b602415~^~Y~^~Unknown~^~vkCmdNextSubpass~^~VUID-vkCmdNextSubpass-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1b603201~^~Y~^~Unknown~^~vkCmdNextSubpass~^~VUID-vkCmdNextSubpass-contents-parameter~^~core~^~The spec valid usage text states 'contents must be a valid VkSubpassContents value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-contents-parameter)~^~implicit -VALIDATION_ERROR_1b800920~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcStageMask-01168~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01168)~^~ -VALIDATION_ERROR_1b800922~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dstStageMask-01169~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-01169)~^~ -VALIDATION_ERROR_1b800924~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcStageMask-01170~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01170)~^~ -VALIDATION_ERROR_1b800926~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dstStageMask-01171~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-01171)~^~ -VALIDATION_ERROR_1b800928~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-pDependencies-01172~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with a VkSubpassDependency instance in pDependencies that expresses a dependency from the current subpass to itself.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pDependencies-01172)~^~ -VALIDATION_ERROR_1b80092a~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcStageMask-01173~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, srcStageMask must contain a subset of the bit values in the srcStageMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01173)~^~ -VALIDATION_ERROR_1b80092c~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dstStageMask-01174~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, dstStageMask must contain a subset of the bit values in the dstStageMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-01174)~^~ -VALIDATION_ERROR_1b80092e~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcAccessMask-01175~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the srcAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the srcAccessMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcAccessMask-01175)~^~ -VALIDATION_ERROR_1b800930~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dstAccessMask-01176~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the dstAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the dstAccessMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstAccessMask-01176)~^~ -VALIDATION_ERROR_1b800932~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dependencyFlags-01177~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, dependencyFlags must be equal to the dependencyFlags member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dependencyFlags-01177)~^~ -VALIDATION_ERROR_1b800934~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, bufferMemoryBarrierCount must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178)~^~ -VALIDATION_ERROR_1b800936~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-image-01179~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the image member of any element of pImageMemoryBarriers must be equal to one of the elements of pAttachments that the current framebuffer was created with, that is also referred to by one of the elements of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-image-01179)~^~ -VALIDATION_ERROR_1b800938~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-oldLayout-01180~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any element of pImageMemoryBarriers must be equal to the layout member of an element of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with, that refers to the same image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-oldLayout-01180)~^~ -VALIDATION_ERROR_1b80093a~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-oldLayout-01181~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of an element of pImageMemoryBarriers must be equal' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-oldLayout-01181)~^~ -VALIDATION_ERROR_1b80093c~^~Y~^~RenderPassBarrierConflicts~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182~^~core~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pImageMemoryBarriers must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182)~^~ -VALIDATION_ERROR_1b80093e~^~Y~^~InvalidBarriers~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcStageMask-01183~^~core~^~The spec valid usage text states 'Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01183)~^~ -VALIDATION_ERROR_1b800940~^~Y~^~InvalidBarriers~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184~^~core~^~The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184)~^~ -VALIDATION_ERROR_1b800942~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185~^~core~^~The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185)~^~ -VALIDATION_ERROR_1b800944~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dependencyFlags-01186~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If vkCmdPipelineBarrier is called outside of a render pass instance, dependencyFlags must not include VK_DEPENDENCY_VIEW_LOCAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPipelineBarrier-dependencyFlags-01186)~^~ -VALIDATION_ERROR_1b802401~^~Y~^~None~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1b802413~^~Y~^~None~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1b802415~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1b803e01~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dependencyFlags-parameter~^~core~^~The spec valid usage text states 'dependencyFlags must be a valid combination of VkDependencyFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dependencyFlags-parameter)~^~implicit -VALIDATION_ERROR_1b807801~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dstStageMask-parameter~^~core~^~The spec valid usage text states 'dstStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-parameter)~^~implicit -VALIDATION_ERROR_1b807803~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask~^~core~^~The spec valid usage text states 'dstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1b810401~^~Y~^~None~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter~^~core~^~The spec valid usage text states 'If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter)~^~implicit -VALIDATION_ERROR_1b818a01~^~Y~^~None~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter~^~core~^~The spec valid usage text states 'If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter)~^~implicit -VALIDATION_ERROR_1b81ac01~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter~^~core~^~The spec valid usage text states 'If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter)~^~implicit -VALIDATION_ERROR_1b82d401~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcStageMask-parameter~^~core~^~The spec valid usage text states 'srcStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-parameter)~^~implicit -VALIDATION_ERROR_1b82d403~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask~^~core~^~The spec valid usage text states 'srcStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1ba00017~^~N~^~Unknown~^~vkCmdProcessCommandsNVX~^~VUID-vkCmdProcessCommandsNVX-renderpass~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-renderpass)~^~implicit -VALIDATION_ERROR_1ba02401~^~Y~^~Unknown~^~vkCmdProcessCommandsNVX~^~VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1ba02413~^~N~^~Unknown~^~vkCmdProcessCommandsNVX~^~VUID-vkCmdProcessCommandsNVX-commandBuffer-recording~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1ba02415~^~N~^~Unknown~^~vkCmdProcessCommandsNVX~^~VUID-vkCmdProcessCommandsNVX-commandBuffer-cmdpool~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1ba1f201~^~N~^~Unknown~^~vkCmdProcessCommandsNVX~^~VUID-vkCmdProcessCommandsNVX-pProcessCommandsInfo-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pProcessCommandsInfo must be a valid pointer to a valid VkCmdProcessCommandsInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-pProcessCommandsInfo-parameter)~^~implicit -VALIDATION_ERROR_1bc00009~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commonparent)~^~implicit -VALIDATION_ERROR_1bc002e0~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-offset-00368~^~core~^~The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-00368)~^~ -VALIDATION_ERROR_1bc002e2~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-size-00369~^~core~^~The spec valid usage text states 'size must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-size-00369)~^~ -VALIDATION_ERROR_1bc002e4~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-offset-00370~^~core~^~The spec valid usage text states 'offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-00370)~^~ -VALIDATION_ERROR_1bc002e6~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-size-00371~^~core~^~The spec valid usage text states 'size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-size-00371)~^~ -VALIDATION_ERROR_1bc00e06~^~Y~^~InvalidPushConstants~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-offset-01795~^~core~^~The spec valid usage text states 'For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-01795)~^~ -VALIDATION_ERROR_1bc00e08~^~Y~^~InvalidPushConstants~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-offset-01796~^~core~^~The spec valid usage text states 'For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range's VkPushConstantRange::stageFlags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-01796)~^~ -VALIDATION_ERROR_1bc02401~^~Y~^~None~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1bc02413~^~Y~^~None~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1bc02415~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1bc0be01~^~Y~^~None~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-layout-parameter~^~core~^~The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-layout-parameter)~^~implicit -VALIDATION_ERROR_1bc26201~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-pValues-parameter~^~core~^~The spec valid usage text states 'pValues must be a valid pointer to an array of size bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-pValues-parameter)~^~implicit -VALIDATION_ERROR_1bc2c21b~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-size-arraylength~^~core~^~The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-size-arraylength)~^~implicit -VALIDATION_ERROR_1bc2dc01~^~N~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-stageFlags-parameter~^~core~^~The spec valid usage text states 'stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-stageFlags-parameter)~^~implicit -VALIDATION_ERROR_1bc2dc03~^~Y~^~Unknown~^~vkCmdPushConstants~^~VUID-vkCmdPushConstants-stageFlags-requiredbitmask~^~core~^~The spec valid usage text states 'stageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-stageFlags-requiredbitmask)~^~implicit -VALIDATION_ERROR_1be00009~^~Y~^~Unknown~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-commonparent~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commonparent)~^~implicit -VALIDATION_ERROR_1be002d6~^~Y~^~PushDescriptorSetCmdPushBadArgs~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363)~^~ -VALIDATION_ERROR_1be002d8~^~Y~^~PushDescriptorSetCmdPushBadArgs~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-set-00364~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-set-00364)~^~ -VALIDATION_ERROR_1be002da~^~Y~^~PushDescriptorSetCmdPushBadArgs~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-set-00365~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-set-00365)~^~ -VALIDATION_ERROR_1be02401~^~Y~^~Unknown~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1be02413~^~Y~^~None~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1be02415~^~Y~^~PushDescriptorSetCmdPushBadArgs~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1be0541b~^~N~^~Unknown~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'descriptorWriteCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength)~^~implicit -VALIDATION_ERROR_1be0be01~^~Y~^~Unknown~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-layout-parameter~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-layout-parameter)~^~implicit -VALIDATION_ERROR_1be13601~^~Y~^~Unknown~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter)~^~implicit -VALIDATION_ERROR_1be27e01~^~Y~^~Unknown~^~vkCmdPushDescriptorSetKHR~^~VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter~^~(VK_KHR_push_descriptor)~^~The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter)~^~implicit -VALIDATION_ERROR_1c000009~^~Y~^~Unknown~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'Each of commandBuffer, descriptorUpdateTemplate, and layout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent)~^~implicit -VALIDATION_ERROR_1c0002dc~^~N~^~Unknown~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer's parent VkCommandPool's queue family' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366)~^~ -VALIDATION_ERROR_1c000d2c~^~N~^~None~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplateKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686)~^~ -VALIDATION_ERROR_1c002401~^~Y~^~Unknown~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1c002413~^~Y~^~None~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-recording~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1c002415~^~N~^~Unknown~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1c005201~^~Y~^~Unknown~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter)~^~implicit -VALIDATION_ERROR_1c00be01~^~Y~^~Unknown~^~vkCmdPushDescriptorSetWithTemplateKHR~^~VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter~^~(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter)~^~implicit -VALIDATION_ERROR_1c200017~^~N~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-renderpass~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-renderpass)~^~implicit -VALIDATION_ERROR_1c200019~^~N~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-bufferlevel~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'commandBuffer must be a secondary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-bufferlevel)~^~implicit -VALIDATION_ERROR_1c200a62~^~N~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01329~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The provided commandBuffer must not have had a prior space reservation since its creation or the last reset.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01329)~^~ -VALIDATION_ERROR_1c200a64~^~N~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01330~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The state of the commandBuffer must be legal to execute all commands within the sequence provided by the indirectCommandsLayout member of pProcessCommandsInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01330)~^~ -VALIDATION_ERROR_1c202401~^~Y~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1c202413~^~N~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-recording~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1c202415~^~N~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-cmdpool~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1c221a01~^~N~^~Unknown~^~vkCmdReserveSpaceForCommandsNVX~^~VUID-vkCmdReserveSpaceForCommandsNVX-pReserveSpaceInfo-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pReserveSpaceInfo must be a valid pointer to a valid VkCmdReserveSpaceForCommandsInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-pReserveSpaceInfo-parameter)~^~implicit -VALIDATION_ERROR_1c400009~^~Y~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commonparent)~^~implicit -VALIDATION_ERROR_1c400017~^~Y~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-renderpass)~^~implicit -VALIDATION_ERROR_1c400902~^~N~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-stageMask-01153~^~core~^~The spec valid usage text states 'stageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-01153)~^~ -VALIDATION_ERROR_1c400904~^~Y~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-stageMask-01154~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-01154)~^~ -VALIDATION_ERROR_1c400906~^~Y~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-stageMask-01155~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-01155)~^~ -VALIDATION_ERROR_1c400908~^~N~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-event-01156~^~core~^~The spec valid usage text states 'When this command executes, event must not be waited on by a vkCmdWaitEvents command that is currently executing' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-event-01156)~^~ -VALIDATION_ERROR_1c40090a~^~N~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-commandBuffer-01157~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBuffer's current device mask must include exactly one physical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-01157)~^~ -VALIDATION_ERROR_1c402401~^~Y~^~None~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1c402413~^~Y~^~None~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1c402415~^~Y~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1c407e01~^~Y~^~None~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-event-parameter~^~core~^~The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-event-parameter)~^~implicit -VALIDATION_ERROR_1c42de01~^~N~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-stageMask-parameter~^~core~^~The spec valid usage text states 'stageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-parameter)~^~implicit -VALIDATION_ERROR_1c42de03~^~Y~^~Unknown~^~vkCmdResetEvent~^~VUID-vkCmdResetEvent-stageMask-requiredbitmask~^~core~^~The spec valid usage text states 'stageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1c600009~^~Y~^~Unknown~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commonparent)~^~implicit -VALIDATION_ERROR_1c600017~^~Y~^~Unknown~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-renderpass)~^~implicit -VALIDATION_ERROR_1c600638~^~N~^~Unknown~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-firstQuery-00796~^~core~^~The spec valid usage text states 'firstQuery must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-firstQuery-00796)~^~ -VALIDATION_ERROR_1c60063a~^~N~^~Unknown~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-firstQuery-00797~^~core~^~The spec valid usage text states 'The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-firstQuery-00797)~^~ -VALIDATION_ERROR_1c602401~^~Y~^~None~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1c602413~^~Y~^~None~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1c602415~^~Y~^~Unknown~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1c629801~^~Y~^~None~^~vkCmdResetQueryPool~^~VUID-vkCmdResetQueryPool-queryPool-parameter~^~core~^~The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-queryPool-parameter)~^~implicit -VALIDATION_ERROR_1c800009~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-commonparent~^~core~^~The spec valid usage text states 'Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commonparent)~^~implicit -VALIDATION_ERROR_1c800017~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-renderpass)~^~implicit -VALIDATION_ERROR_1c8001fa~^~N~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-pRegions-00253~^~core~^~The spec valid usage text states 'The source region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-00253)~^~ -VALIDATION_ERROR_1c8001fc~^~N~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-pRegions-00254~^~core~^~The spec valid usage text states 'The destination region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-00254)~^~ -VALIDATION_ERROR_1c8001fe~^~N~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-pRegions-00255~^~core~^~The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-00255)~^~ -VALIDATION_ERROR_1c800200~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImage-00256~^~core~^~The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-00256)~^~ -VALIDATION_ERROR_1c800202~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImage-00257~^~core~^~The spec valid usage text states 'srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-00257)~^~ -VALIDATION_ERROR_1c800204~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImage-00258~^~core~^~The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00258)~^~ -VALIDATION_ERROR_1c800206~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImage-00259~^~core~^~The spec valid usage text states 'dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00259)~^~ -VALIDATION_ERROR_1c800208~^~N~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImageLayout-00260~^~core~^~The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-00260)~^~ -VALIDATION_ERROR_1c80020a~^~N~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImageLayout-00261~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-00261)~^~ -VALIDATION_ERROR_1c80020c~^~N~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImageLayout-00262~^~core~^~The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-00262)~^~ -VALIDATION_ERROR_1c80020e~^~N~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImageLayout-00263~^~!(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-00263)~^~ -VALIDATION_ERROR_1c800210~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImage-00264~^~core~^~The spec valid usage text states 'If dstImage was created with tiling equal to VK_IMAGE_TILING_LINEAR, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00264)~^~ -VALIDATION_ERROR_1c800212~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImage-00265~^~core~^~The spec valid usage text states 'If dstImage was created with tiling equal to VK_IMAGE_TILING_OPTIMAL, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00265)~^~ -VALIDATION_ERROR_1c800ad4~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImage-01386~^~core~^~The spec valid usage text states 'srcImage and dstImage must have been created with the same image format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-01386)~^~ -VALIDATION_ERROR_1c800af0~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImageLayout-01400~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-01400)~^~ -VALIDATION_ERROR_1c800af2~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImageLayout-01401~^~(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-01401)~^~ -VALIDATION_ERROR_1c800d5a~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcSubresource-01709~^~core~^~The spec valid usage text states 'The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcSubresource-01709)~^~ -VALIDATION_ERROR_1c800d5c~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstSubresource-01710~^~core~^~The spec valid usage text states 'The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstSubresource-01710)~^~ -VALIDATION_ERROR_1c800d5e~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcSubresource-01711~^~core~^~The spec valid usage text states 'The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcSubresource-01711)~^~ -VALIDATION_ERROR_1c800d60~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstSubresource-01712~^~core~^~The spec valid usage text states 'The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstSubresource-01712)~^~ -VALIDATION_ERROR_1c800e5a~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-commandBuffer-01837~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-01837)~^~ -VALIDATION_ERROR_1c800e5c~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-commandBuffer-01838~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-01838)~^~ -VALIDATION_ERROR_1c800e5e~^~N~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-commandBuffer-01839~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-01839)~^~ -VALIDATION_ERROR_1c802401~^~Y~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1c802413~^~Y~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1c802415~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1c807201~^~Y~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImage-parameter~^~core~^~The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-parameter)~^~implicit -VALIDATION_ERROR_1c807401~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-dstImageLayout-parameter~^~core~^~The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-parameter)~^~implicit -VALIDATION_ERROR_1c821001~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-pRegions-parameter~^~core~^~The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkImageResolve structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-parameter)~^~implicit -VALIDATION_ERROR_1c82ac1b~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-regionCount-arraylength~^~core~^~The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-regionCount-arraylength)~^~implicit -VALIDATION_ERROR_1c82ce01~^~Y~^~None~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImage-parameter~^~core~^~The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-parameter)~^~implicit -VALIDATION_ERROR_1c82d001~^~Y~^~Unknown~^~vkCmdResolveImage~^~VUID-vkCmdResolveImage-srcImageLayout-parameter~^~core~^~The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-parameter)~^~implicit -VALIDATION_ERROR_1ca004c8~^~Y~^~Unknown~^~vkCmdSetBlendConstants~^~VUID-vkCmdSetBlendConstants-None-00612~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_BLEND_CONSTANTS dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-None-00612)~^~ -VALIDATION_ERROR_1ca02401~^~Y~^~None~^~vkCmdSetBlendConstants~^~VUID-vkCmdSetBlendConstants-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1ca02413~^~Y~^~None~^~vkCmdSetBlendConstants~^~VUID-vkCmdSetBlendConstants-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1ca02415~^~Y~^~Unknown~^~vkCmdSetBlendConstants~^~VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1cc0062a~^~Y~^~Unknown~^~vkCmdSetDepthBias~^~VUID-vkCmdSetDepthBias-None-00789~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-None-00789)~^~ -VALIDATION_ERROR_1cc0062c~^~Y~^~None~^~vkCmdSetDepthBias~^~VUID-vkCmdSetDepthBias-depthBiasClamp-00790~^~core~^~The spec valid usage text states 'If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-depthBiasClamp-00790)~^~ -VALIDATION_ERROR_1cc02401~^~Y~^~None~^~vkCmdSetDepthBias~^~VUID-vkCmdSetDepthBias-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1cc02413~^~Y~^~None~^~vkCmdSetDepthBias~^~VUID-vkCmdSetDepthBias-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1cc02415~^~Y~^~Unknown~^~vkCmdSetDepthBias~^~VUID-vkCmdSetDepthBias-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1ce004ae~^~Y~^~Unknown~^~vkCmdSetDepthBounds~^~VUID-vkCmdSetDepthBounds-None-00599~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-None-00599)~^~ -VALIDATION_ERROR_1ce004b0~^~N~^~Unknown~^~vkCmdSetDepthBounds~^~VUID-vkCmdSetDepthBounds-minDepthBounds-00600~^~(VK_EXT_depth_range_unrestricted)~^~The spec valid usage text states 'Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDepthBounds-minDepthBounds-00600)~^~ -VALIDATION_ERROR_1ce004b2~^~N~^~Unknown~^~vkCmdSetDepthBounds~^~VUID-vkCmdSetDepthBounds-maxDepthBounds-00601~^~(VK_EXT_depth_range_unrestricted)~^~The spec valid usage text states 'Unless the VK_EXT_depth_range_unrestricted extension is enabled maxDepthBounds must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDepthBounds-maxDepthBounds-00601)~^~ -VALIDATION_ERROR_1ce02401~^~Y~^~None~^~vkCmdSetDepthBounds~^~VUID-vkCmdSetDepthBounds-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1ce02413~^~Y~^~None~^~vkCmdSetDepthBounds~^~VUID-vkCmdSetDepthBounds-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1ce02415~^~Y~^~Unknown~^~vkCmdSetDepthBounds~^~VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1d0000d8~^~N~^~Unknown~^~vkCmdSetDeviceMask~^~VUID-vkCmdSetDeviceMask-deviceMask-00108~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must be a valid device mask value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00108)~^~ -VALIDATION_ERROR_1d0000da~^~N~^~Unknown~^~vkCmdSetDeviceMask~^~VUID-vkCmdSetDeviceMask-deviceMask-00109~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00109)~^~ -VALIDATION_ERROR_1d0000dc~^~N~^~Unknown~^~vkCmdSetDeviceMask~^~VUID-vkCmdSetDeviceMask-deviceMask-00110~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceMask must not include any set bits that were not in the VkDeviceGroupCommandBufferBeginInfo::deviceMask value when the command buffer began recording.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00110)~^~ -VALIDATION_ERROR_1d0000de~^~N~^~Unknown~^~vkCmdSetDeviceMask~^~VUID-vkCmdSetDeviceMask-deviceMask-00111~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If vkCmdSetDeviceMask is called inside a render pass instance, deviceMask must not include any set bits that were not in the VkDeviceGroupRenderPassBeginInfo::deviceMask value when the render pass instance began recording.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00111)~^~ -VALIDATION_ERROR_1d002401~^~Y~^~Unknown~^~vkCmdSetDeviceMask~^~VUID-vkCmdSetDeviceMask-commandBuffer-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1d002413~^~N~^~Unknown~^~vkCmdSetDeviceMask~^~VUID-vkCmdSetDeviceMask-commandBuffer-recording~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1d002415~^~N~^~Unknown~^~vkCmdSetDeviceMask~^~VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1d20048e~^~N~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-None-00583~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-None-00583)~^~ -VALIDATION_ERROR_1d200492~^~N~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'The sum of firstDiscardRectangle and discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585)~^~ -VALIDATION_ERROR_1d200496~^~N~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-x-00587~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'The x and y member of offset in each VkRect2D element of pDiscardRectangles must be greater than or equal to 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-x-00587)~^~ -VALIDATION_ERROR_1d200498~^~N~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-offset-00588~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'Evaluation of (offset.x + extent.width) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-offset-00588)~^~ -VALIDATION_ERROR_1d20049a~^~N~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-offset-00589~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'Evaluation of (offset.y + extent.height) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-offset-00589)~^~ -VALIDATION_ERROR_1d202401~^~Y~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1d202413~^~Y~^~None~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1d202415~^~N~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1d205c1b~^~Y~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'discardRectangleCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength)~^~implicit -VALIDATION_ERROR_1d214601~^~Y~^~Unknown~^~vkCmdSetDiscardRectangleEXT~^~VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter~^~(VK_EXT_discard_rectangles)~^~The spec valid usage text states 'pDiscardRectangles must be a valid pointer to an array of discardRectangleCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter)~^~implicit -VALIDATION_ERROR_1d400009~^~Y~^~Unknown~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commonparent)~^~implicit -VALIDATION_ERROR_1d400017~^~Y~^~Unknown~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-renderpass)~^~implicit -VALIDATION_ERROR_1d4008fa~^~N~^~Unknown~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-stageMask-01149~^~core~^~The spec valid usage text states 'stageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-01149)~^~ -VALIDATION_ERROR_1d4008fc~^~Y~^~StageMaskGsTsEnabled~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-stageMask-01150~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-01150)~^~ -VALIDATION_ERROR_1d4008fe~^~Y~^~StageMaskGsTsEnabled~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-stageMask-01151~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-01151)~^~ -VALIDATION_ERROR_1d400900~^~N~^~Unknown~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-commandBuffer-01152~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBuffer's current device mask must include exactly one physical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-01152)~^~ -VALIDATION_ERROR_1d402401~^~Y~^~None~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1d402413~^~Y~^~None~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1d402415~^~Y~^~Unknown~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1d407e01~^~Y~^~None~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-event-parameter~^~core~^~The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-event-parameter)~^~implicit -VALIDATION_ERROR_1d42de01~^~N~^~Unknown~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-stageMask-parameter~^~core~^~The spec valid usage text states 'stageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-parameter)~^~implicit -VALIDATION_ERROR_1d42de03~^~Y~^~Unknown~^~vkCmdSetEvent~^~VUID-vkCmdSetEvent-stageMask-requiredbitmask~^~core~^~The spec valid usage text states 'stageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1d600626~^~Y~^~Unknown~^~vkCmdSetLineWidth~^~VUID-vkCmdSetLineWidth-None-00787~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-None-00787)~^~ -VALIDATION_ERROR_1d600628~^~Y~^~PSOLineWidthInvalid~^~vkCmdSetLineWidth~^~VUID-vkCmdSetLineWidth-lineWidth-00788~^~core~^~The spec valid usage text states 'If the wide lines feature is not enabled, lineWidth must be 1.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-lineWidth-00788)~^~ -VALIDATION_ERROR_1d602401~^~Y~^~None~^~vkCmdSetLineWidth~^~VUID-vkCmdSetLineWidth-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1d602413~^~Y~^~None~^~vkCmdSetLineWidth~^~VUID-vkCmdSetLineWidth-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1d602415~^~Y~^~Unknown~^~vkCmdSetLineWidth~^~VUID-vkCmdSetLineWidth-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1d80049c~^~Y~^~Unknown~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-None-00590~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-None-00590)~^~ -VALIDATION_ERROR_1d80049e~^~N~^~Unknown~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-firstScissor-00591~^~core~^~The spec valid usage text states 'firstScissor must be less than VkPhysicalDeviceLimits::maxViewports' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-firstScissor-00591)~^~ -VALIDATION_ERROR_1d8004a0~^~Y~^~SetDynScissorParamMultiviewportTests~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-firstScissor-00592~^~core~^~The spec valid usage text states 'The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-firstScissor-00592)~^~ -VALIDATION_ERROR_1d8004a2~^~Y~^~SetDynScissorParamTests~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-firstScissor-00593~^~core~^~The spec valid usage text states 'If the multiple viewports feature is not enabled, firstScissor must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-firstScissor-00593)~^~ -VALIDATION_ERROR_1d8004a4~^~Y~^~SetDynScissorParamTests~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-scissorCount-00594~^~core~^~The spec valid usage text states 'If the multiple viewports feature is not enabled, scissorCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-scissorCount-00594)~^~ -VALIDATION_ERROR_1d8004a6~^~Y~^~SetDynScissorParamTests~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-x-00595~^~core~^~The spec valid usage text states 'The x and y members of offset must be greater than or equal to 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-x-00595)~^~ -VALIDATION_ERROR_1d8004a8~^~Y~^~SetDynScissorParamTests~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-offset-00596~^~core~^~The spec valid usage text states 'Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-offset-00596)~^~ -VALIDATION_ERROR_1d8004aa~^~Y~^~SetDynScissorParamTests~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-offset-00597~^~core~^~The spec valid usage text states 'Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-offset-00597)~^~ -VALIDATION_ERROR_1d802401~^~Y~^~None~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1d802413~^~Y~^~None~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1d802415~^~Y~^~Unknown~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1d822601~^~Y~^~Unknown~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-pScissors-parameter~^~core~^~The spec valid usage text states 'pScissors must be a valid pointer to an array of scissorCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-pScissors-parameter)~^~implicit -VALIDATION_ERROR_1d82b61b~^~Y~^~Unknown~^~vkCmdSetScissor~^~VUID-vkCmdSetScissor-scissorCount-arraylength~^~core~^~The spec valid usage text states 'scissorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-scissorCount-arraylength)~^~implicit -VALIDATION_ERROR_1da004b4~^~Y~^~Unknown~^~vkCmdSetStencilCompareMask~^~VUID-vkCmdSetStencilCompareMask-None-00602~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-None-00602)~^~ -VALIDATION_ERROR_1da02401~^~Y~^~None~^~vkCmdSetStencilCompareMask~^~VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1da02413~^~Y~^~None~^~vkCmdSetStencilCompareMask~^~VUID-vkCmdSetStencilCompareMask-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1da02415~^~Y~^~Unknown~^~vkCmdSetStencilCompareMask~^~VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1da08401~^~N~^~Unknown~^~vkCmdSetStencilCompareMask~^~VUID-vkCmdSetStencilCompareMask-faceMask-parameter~^~core~^~The spec valid usage text states 'faceMask must be a valid combination of VkStencilFaceFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-faceMask-parameter)~^~implicit -VALIDATION_ERROR_1da08403~^~Y~^~Unknown~^~vkCmdSetStencilCompareMask~^~VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask~^~core~^~The spec valid usage text states 'faceMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1dc004b8~^~Y~^~Unknown~^~vkCmdSetStencilReference~^~VUID-vkCmdSetStencilReference-None-00604~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-None-00604)~^~ -VALIDATION_ERROR_1dc02401~^~Y~^~None~^~vkCmdSetStencilReference~^~VUID-vkCmdSetStencilReference-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1dc02413~^~Y~^~None~^~vkCmdSetStencilReference~^~VUID-vkCmdSetStencilReference-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1dc02415~^~Y~^~Unknown~^~vkCmdSetStencilReference~^~VUID-vkCmdSetStencilReference-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1dc08401~^~N~^~Unknown~^~vkCmdSetStencilReference~^~VUID-vkCmdSetStencilReference-faceMask-parameter~^~core~^~The spec valid usage text states 'faceMask must be a valid combination of VkStencilFaceFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-faceMask-parameter)~^~implicit -VALIDATION_ERROR_1dc08403~^~Y~^~Unknown~^~vkCmdSetStencilReference~^~VUID-vkCmdSetStencilReference-faceMask-requiredbitmask~^~core~^~The spec valid usage text states 'faceMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-faceMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1de004b6~^~Y~^~Unknown~^~vkCmdSetStencilWriteMask~^~VUID-vkCmdSetStencilWriteMask-None-00603~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-None-00603)~^~ -VALIDATION_ERROR_1de02401~^~Y~^~None~^~vkCmdSetStencilWriteMask~^~VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1de02413~^~Y~^~None~^~vkCmdSetStencilWriteMask~^~VUID-vkCmdSetStencilWriteMask-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1de02415~^~Y~^~Unknown~^~vkCmdSetStencilWriteMask~^~VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1de08401~^~N~^~Unknown~^~vkCmdSetStencilWriteMask~^~VUID-vkCmdSetStencilWriteMask-faceMask-parameter~^~core~^~The spec valid usage text states 'faceMask must be a valid combination of VkStencilFaceFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-faceMask-parameter)~^~implicit -VALIDATION_ERROR_1de08403~^~Y~^~Unknown~^~vkCmdSetStencilWriteMask~^~VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask~^~core~^~The spec valid usage text states 'faceMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1e00098a~^~Y~^~Unknown~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-None-01221~^~core~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-None-01221)~^~ -VALIDATION_ERROR_1e00098c~^~N~^~Unknown~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-firstViewport-01222~^~core~^~The spec valid usage text states 'firstViewport must be less than VkPhysicalDeviceLimits::maxViewports' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-firstViewport-01222)~^~redundant VU -VALIDATION_ERROR_1e00098e~^~Y~^~SetDynViewportParamMultiviewportTests~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-firstViewport-01223~^~core~^~The spec valid usage text states 'The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-firstViewport-01223)~^~ -VALIDATION_ERROR_1e000990~^~Y~^~SetDynViewportParamTests~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-firstViewport-01224~^~core~^~The spec valid usage text states 'If the multiple viewports feature is not enabled, firstViewport must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-firstViewport-01224)~^~ -VALIDATION_ERROR_1e000992~^~Y~^~SetDynViewportParamTests~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-viewportCount-01225~^~core~^~The spec valid usage text states 'If the multiple viewports feature is not enabled, viewportCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-viewportCount-01225)~^~ -VALIDATION_ERROR_1e002401~^~Y~^~None~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1e002413~^~Y~^~None~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1e002415~^~Y~^~CommandQueueFlags~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1e030a1b~^~Y~^~SetDynViewportParamTests~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-viewportCount-arraylength~^~core~^~The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-viewportCount-arraylength)~^~implicit -VALIDATION_ERROR_1e03fa01~^~Y~^~SetDynViewportParamTests~^~vkCmdSetViewport~^~VUID-vkCmdSetViewport-pViewports-parameter~^~core~^~The spec valid usage text states 'pViewports must be a valid pointer to an array of viewportCount VkViewport structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-pViewports-parameter)~^~implicit -VALIDATION_ERROR_1e200a54~^~N~^~Unknown~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-None-01322~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-None-01322)~^~ -VALIDATION_ERROR_1e200a56~^~N~^~Unknown~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-firstViewport-01323~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'firstViewport must be less than VkPhysicalDeviceLimits::maxViewports' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-firstViewport-01323)~^~ -VALIDATION_ERROR_1e200a58~^~N~^~Unknown~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-firstViewport-01324~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-firstViewport-01324)~^~ -VALIDATION_ERROR_1e202401~^~Y~^~Unknown~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1e202413~^~N~^~Unknown~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-commandBuffer-recording~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1e202415~^~N~^~Unknown~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-commandBuffer-cmdpool~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1e230a1b~^~Y~^~Unknown~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-viewportCount-arraylength~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-viewportCount-arraylength)~^~implicit -VALIDATION_ERROR_1e23fc01~^~Y~^~None~^~vkCmdSetViewportWScalingNV~^~VUID-vkCmdSetViewportWScalingNV-pViewportWScalings-parameter~^~(VK_NV_clip_space_w_scaling)~^~The spec valid usage text states 'pViewportWScalings must be a valid pointer to an array of viewportCount VkViewportWScalingNV structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-pViewportWScalings-parameter)~^~implicit -VALIDATION_ERROR_1e400009~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commonparent)~^~implicit -VALIDATION_ERROR_1e400017~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-renderpass~^~core~^~The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-renderpass)~^~implicit -VALIDATION_ERROR_1e400040~^~N~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dstOffset-00032~^~core~^~The spec valid usage text states 'dstOffset must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstOffset-00032)~^~ -VALIDATION_ERROR_1e400042~^~N~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dataSize-00033~^~core~^~The spec valid usage text states 'dataSize must be less than or equal to the size of dstBuffer minus dstOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-00033)~^~ -VALIDATION_ERROR_1e400044~^~Y~^~None~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dstBuffer-00034~^~core~^~The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstBuffer-00034)~^~ -VALIDATION_ERROR_1e400046~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dstBuffer-00035~^~core~^~The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstBuffer-00035)~^~ -VALIDATION_ERROR_1e400048~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dstOffset-00036~^~core~^~The spec valid usage text states 'dstOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstOffset-00036)~^~ -VALIDATION_ERROR_1e40004a~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dataSize-00037~^~core~^~The spec valid usage text states 'dataSize must be less than or equal to 65536' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-00037)~^~ -VALIDATION_ERROR_1e40004c~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dataSize-00038~^~core~^~The spec valid usage text states 'dataSize must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-00038)~^~ -VALIDATION_ERROR_1e400e2a~^~N~^~None~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-commandBuffer-01813~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-01813)~^~ -VALIDATION_ERROR_1e400e2c~^~N~^~None~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-commandBuffer-01814~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-01814)~^~ -VALIDATION_ERROR_1e402401~^~Y~^~None~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1e402413~^~Y~^~None~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1e402415~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1e403c1b~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dataSize-arraylength~^~core~^~The spec valid usage text states 'dataSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-arraylength)~^~implicit -VALIDATION_ERROR_1e406c01~^~Y~^~None~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-dstBuffer-parameter~^~core~^~The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstBuffer-parameter)~^~implicit -VALIDATION_ERROR_1e412201~^~Y~^~Unknown~^~vkCmdUpdateBuffer~^~VUID-vkCmdUpdateBuffer-pData-parameter~^~core~^~The spec valid usage text states 'pData must be a valid pointer to an array of dataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-pData-parameter)~^~implicit -VALIDATION_ERROR_1e600009~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commonparent)~^~implicit -VALIDATION_ERROR_1e60090c~^~N~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-srcStageMask-01158~^~core~^~The spec valid usage text states 'srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the members of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the members of pEvents was set using vkSetEvent' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01158)~^~ -VALIDATION_ERROR_1e60090e~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-srcStageMask-01159~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01159)~^~ -VALIDATION_ERROR_1e600910~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-dstStageMask-01160~^~core~^~The spec valid usage text states 'If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-01160)~^~ -VALIDATION_ERROR_1e600912~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-srcStageMask-01161~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01161)~^~ -VALIDATION_ERROR_1e600914~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-dstStageMask-01162~^~core~^~The spec valid usage text states 'If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-01162)~^~ -VALIDATION_ERROR_1e600916~^~N~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-pEvents-01163~^~core~^~The spec valid usage text states 'If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents must not be called inside a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pEvents-01163)~^~ -VALIDATION_ERROR_1e600918~^~Y~^~InvalidBarriers~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-srcStageMask-01164~^~core~^~The spec valid usage text states 'Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01164)~^~ -VALIDATION_ERROR_1e60091a~^~N~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-pMemoryBarriers-01165~^~core~^~The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pMemoryBarriers-01165)~^~ -VALIDATION_ERROR_1e60091c~^~N~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-pMemoryBarriers-01166~^~core~^~The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pMemoryBarriers-01166)~^~ -VALIDATION_ERROR_1e60091e~^~N~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-commandBuffer-01167~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'commandBuffer's current device mask must include exactly one physical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-01167)~^~ -VALIDATION_ERROR_1e602401~^~Y~^~None~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1e602413~^~Y~^~None~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1e602415~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1e607801~^~N~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-dstStageMask-parameter~^~core~^~The spec valid usage text states 'dstStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-parameter)~^~implicit -VALIDATION_ERROR_1e607803~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask~^~core~^~The spec valid usage text states 'dstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1e60801b~^~N~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-eventCount-arraylength~^~core~^~The spec valid usage text states 'eventCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-eventCount-arraylength)~^~implicit -VALIDATION_ERROR_1e610401~^~Y~^~None~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter~^~core~^~The spec valid usage text states 'If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter)~^~implicit -VALIDATION_ERROR_1e616001~^~Y~^~None~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-pEvents-parameter~^~core~^~The spec valid usage text states 'pEvents must be a valid pointer to an array of eventCount valid VkEvent handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pEvents-parameter)~^~implicit -VALIDATION_ERROR_1e618a01~^~Y~^~None~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter~^~core~^~The spec valid usage text states 'If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter)~^~implicit -VALIDATION_ERROR_1e61ac01~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-pMemoryBarriers-parameter~^~core~^~The spec valid usage text states 'If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pMemoryBarriers-parameter)~^~implicit -VALIDATION_ERROR_1e62d401~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-srcStageMask-parameter~^~core~^~The spec valid usage text states 'srcStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-parameter)~^~implicit -VALIDATION_ERROR_1e62d403~^~Y~^~Unknown~^~vkCmdWaitEvents~^~VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask~^~core~^~The spec valid usage text states 'srcStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_1e800009~^~Y~^~Unknown~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-commonparent~^~core~^~The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commonparent)~^~implicit -VALIDATION_ERROR_1e800678~^~N~^~Unknown~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-queryPool-00828~^~core~^~The spec valid usage text states 'The query identified by queryPool and query must be unavailable' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-queryPool-00828)~^~ -VALIDATION_ERROR_1e80067a~^~N~^~Unknown~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-timestampValidBits-00829~^~core~^~The spec valid usage text states 'The command pool's queue family must support a non-zero timestampValidBits' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-timestampValidBits-00829)~^~ -VALIDATION_ERROR_1e80067c~^~N~^~Unknown~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-None-00830~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'All queries used by the command must be unavailable' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteTimestamp-None-00830)~^~ -VALIDATION_ERROR_1e80067e~^~N~^~Unknown~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-query-00831~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass's view mask must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteTimestamp-query-00831)~^~ -VALIDATION_ERROR_1e800b10~^~N~^~None~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-queryPool-01416~^~core~^~The spec valid usage text states 'queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-queryPool-01416)~^~ -VALIDATION_ERROR_1e802401~^~Y~^~None~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_1e802413~^~Y~^~None~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-commandBuffer-recording~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_1e802415~^~Y~^~Unknown~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool~^~core~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_1e828401~^~Y~^~Unknown~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-pipelineStage-parameter~^~core~^~The spec valid usage text states 'pipelineStage must be a valid VkPipelineStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-pipelineStage-parameter)~^~implicit -VALIDATION_ERROR_1e829801~^~Y~^~None~^~vkCmdWriteTimestamp~^~VUID-vkCmdWriteTimestamp-queryPool-parameter~^~core~^~The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-queryPool-parameter)~^~implicit -VALIDATION_ERROR_1ea0bc01~^~Y~^~None~^~vkCreateAndroidSurfaceKHR~^~VUID-vkCreateAndroidSurfaceKHR-instance-parameter~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_1ea0ec01~^~N~^~Unknown~^~vkCreateAndroidSurfaceKHR~^~VUID-vkCreateAndroidSurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1ea11e01~^~N~^~Unknown~^~vkCreateAndroidSurfaceKHR~^~VUID-vkCreateAndroidSurfaceKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkAndroidSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1ea24801~^~Y~^~Unknown~^~vkCreateAndroidSurfaceKHR~^~VUID-vkCreateAndroidSurfaceKHR-pSurface-parameter~^~(VK_KHR_surface)+(VK_KHR_android_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-pSurface-parameter)~^~implicit -VALIDATION_ERROR_1ec0071e~^~N~^~None~^~vkCreateBuffer~^~VUID-vkCreateBuffer-flags-00911~^~core~^~The spec valid usage text states 'If the flags member of pCreateInfo includes VK_BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-flags-00911)~^~ -VALIDATION_ERROR_1ec05601~^~Y~^~None~^~vkCreateBuffer~^~VUID-vkCreateBuffer-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-device-parameter)~^~implicit -VALIDATION_ERROR_1ec0ec01~^~N~^~None~^~vkCreateBuffer~^~VUID-vkCreateBuffer-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1ec10001~^~Y~^~None~^~vkCreateBuffer~^~VUID-vkCreateBuffer-pBuffer-parameter~^~core~^~The spec valid usage text states 'pBuffer must be a valid pointer to a VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-pBuffer-parameter)~^~implicit -VALIDATION_ERROR_1ec11e01~^~N~^~None~^~vkCreateBuffer~^~VUID-vkCreateBuffer-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkBufferCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1ee05601~^~Y~^~None~^~vkCreateBufferView~^~VUID-vkCreateBufferView-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-device-parameter)~^~implicit -VALIDATION_ERROR_1ee0ec01~^~N~^~Unknown~^~vkCreateBufferView~^~VUID-vkCreateBufferView-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1ee11e01~^~N~^~Unknown~^~vkCreateBufferView~^~VUID-vkCreateBufferView-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkBufferViewCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1ee26a01~^~Y~^~Unknown~^~vkCreateBufferView~^~VUID-vkCreateBufferView-pView-parameter~^~core~^~The spec valid usage text states 'pView must be a valid pointer to a VkBufferView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-pView-parameter)~^~implicit -VALIDATION_ERROR_1f005601~^~Y~^~None~^~vkCreateCommandPool~^~VUID-vkCreateCommandPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-device-parameter)~^~implicit -VALIDATION_ERROR_1f00ec01~^~N~^~Unknown~^~vkCreateCommandPool~^~VUID-vkCreateCommandPool-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1f011601~^~Y~^~Unknown~^~vkCreateCommandPool~^~VUID-vkCreateCommandPool-pCommandPool-parameter~^~core~^~The spec valid usage text states 'pCommandPool must be a valid pointer to a VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-pCommandPool-parameter)~^~implicit -VALIDATION_ERROR_1f011e01~^~N~^~Unknown~^~vkCreateCommandPool~^~VUID-vkCreateCommandPool-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkCommandPoolCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1f20056e~^~N~^~Unknown~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-flags-00695~^~core~^~The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-flags-00695)~^~ -VALIDATION_ERROR_1f200570~^~N~^~Unknown~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-flags-00696~^~core~^~The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-flags-00696)~^~ -VALIDATION_ERROR_1f20381b~^~Y~^~Unknown~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-createInfoCount-arraylength~^~core~^~The spec valid usage text states 'createInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-createInfoCount-arraylength)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1f205601~^~Y~^~None~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-device-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_1f20ec01~^~N~^~Unknown~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1f212001~^~Y~^~Unknown~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-pCreateInfos-parameter~^~core~^~The spec valid usage text states 'pCreateInfos must be a valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pCreateInfos-parameter)~^~implicit -VALIDATION_ERROR_1f21e201~^~Y~^~Unknown~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-pPipelines-parameter~^~core~^~The spec valid usage text states 'pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pPipelines-parameter)~^~implicit -VALIDATION_ERROR_1f228001~^~Y~^~None~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-pipelineCache-parameter~^~core~^~The spec valid usage text states 'If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pipelineCache-parameter)~^~implicit -VALIDATION_ERROR_1f228007~^~Y~^~Unknown~^~vkCreateComputePipelines~^~VUID-vkCreateComputePipelines-pipelineCache-parent~^~core~^~The spec valid usage text states 'If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pipelineCache-parent)~^~implicit -VALIDATION_ERROR_1f40bc01~^~N~^~Unknown~^~vkCreateDebugReportCallbackEXT~^~VUID-vkCreateDebugReportCallbackEXT-instance-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-instance-parameter)~^~implicit -VALIDATION_ERROR_1f40ec01~^~N~^~Unknown~^~vkCreateDebugReportCallbackEXT~^~VUID-vkCreateDebugReportCallbackEXT-pAllocator-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1f410801~^~Y~^~Unknown~^~vkCreateDebugReportCallbackEXT~^~VUID-vkCreateDebugReportCallbackEXT-pCallback-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'pCallback must be a valid pointer to a VkDebugReportCallbackEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-pCallback-parameter)~^~implicit -VALIDATION_ERROR_1f411e01~^~N~^~Unknown~^~vkCreateDebugReportCallbackEXT~^~VUID-vkCreateDebugReportCallbackEXT-pCreateInfo-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDebugReportCallbackCreateInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1f605601~^~Y~^~None~^~vkCreateDescriptorPool~^~VUID-vkCreateDescriptorPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-device-parameter)~^~implicit -VALIDATION_ERROR_1f60ec01~^~N~^~Unknown~^~vkCreateDescriptorPool~^~VUID-vkCreateDescriptorPool-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1f611e01~^~N~^~Unknown~^~vkCreateDescriptorPool~^~VUID-vkCreateDescriptorPool-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorPoolCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1f612e01~^~Y~^~Unknown~^~vkCreateDescriptorPool~^~VUID-vkCreateDescriptorPool-pDescriptorPool-parameter~^~core~^~The spec valid usage text states 'pDescriptorPool must be a valid pointer to a VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-pDescriptorPool-parameter)~^~implicit -VALIDATION_ERROR_1f805601~^~Y~^~None~^~vkCreateDescriptorSetLayout~^~VUID-vkCreateDescriptorSetLayout-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-device-parameter)~^~implicit -VALIDATION_ERROR_1f80ec01~^~N~^~Unknown~^~vkCreateDescriptorSetLayout~^~VUID-vkCreateDescriptorSetLayout-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1f811e01~^~N~^~Unknown~^~vkCreateDescriptorSetLayout~^~VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1f822a01~^~Y~^~Unknown~^~vkCreateDescriptorSetLayout~^~VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter~^~core~^~The spec valid usage text states 'pSetLayout must be a valid pointer to a VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter)~^~implicit -VALIDATION_ERROR_1fa05601~^~Y~^~Unknown~^~vkCreateDescriptorUpdateTemplate~^~VUID-vkCreateDescriptorUpdateTemplate-device-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-device-parameter)~^~implicit -VALIDATION_ERROR_1fa0ec01~^~N~^~Unknown~^~vkCreateDescriptorUpdateTemplate~^~VUID-vkCreateDescriptorUpdateTemplate-pAllocator-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1fa11e01~^~N~^~Unknown~^~vkCreateDescriptorUpdateTemplate~^~VUID-vkCreateDescriptorUpdateTemplate-pCreateInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorUpdateTemplateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1fa13401~^~Y~^~Unknown~^~vkCreateDescriptorUpdateTemplate~^~VUID-vkCreateDescriptorUpdateTemplate-pDescriptorUpdateTemplate-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'pDescriptorUpdateTemplate must be a valid pointer to a VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-pDescriptorUpdateTemplate-parameter)~^~implicit -VALIDATION_ERROR_1fc00ad6~^~Y~^~None~^~vkCreateDevice~^~VUID-vkCreateDevice-ppEnabledExtensionNames-01387~^~core~^~The spec valid usage text states 'All required extensions for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-ppEnabledExtensionNames-01387)~^~ -VALIDATION_ERROR_1fc0ec01~^~N~^~Unknown~^~vkCreateDevice~^~VUID-vkCreateDevice-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1fc11e01~^~N~^~Unknown~^~vkCreateDevice~^~VUID-vkCreateDevice-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1fc13801~^~Y~^~Unknown~^~vkCreateDevice~^~VUID-vkCreateDevice-pDevice-parameter~^~core~^~The spec valid usage text states 'pDevice must be a valid pointer to a VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-pDevice-parameter)~^~implicit -VALIDATION_ERROR_1fc27a01~^~Y~^~Unknown~^~vkCreateDevice~^~VUID-vkCreateDevice-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_1fe06001~^~Y~^~Unknown~^~vkCreateDisplayModeKHR~^~VUID-vkCreateDisplayModeKHR-display-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-display-parameter)~^~implicit -VALIDATION_ERROR_1fe0ec01~^~N~^~Unknown~^~vkCreateDisplayModeKHR~^~VUID-vkCreateDisplayModeKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_1fe11e01~^~N~^~Unknown~^~vkCreateDisplayModeKHR~^~VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDisplayModeCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_1fe1bc01~^~Y~^~Unknown~^~vkCreateDisplayModeKHR~^~VUID-vkCreateDisplayModeKHR-pMode-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pMode must be a valid pointer to a VkDisplayModeKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-pMode-parameter)~^~implicit -VALIDATION_ERROR_1fe27a01~^~Y~^~Unknown~^~vkCreateDisplayModeKHR~^~VUID-vkCreateDisplayModeKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2000bc01~^~Y~^~None~^~vkCreateDisplayPlaneSurfaceKHR~^~VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_2000ec01~^~N~^~Unknown~^~vkCreateDisplayPlaneSurfaceKHR~^~VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20011e01~^~N~^~Unknown~^~vkCreateDisplayPlaneSurfaceKHR~^~VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDisplaySurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_20024801~^~Y~^~Unknown~^~vkCreateDisplayPlaneSurfaceKHR~^~VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter)~^~implicit -VALIDATION_ERROR_20205601~^~Y~^~None~^~vkCreateEvent~^~VUID-vkCreateEvent-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-device-parameter)~^~implicit -VALIDATION_ERROR_2020ec01~^~N~^~Unknown~^~vkCreateEvent~^~VUID-vkCreateEvent-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20211e01~^~N~^~Unknown~^~vkCreateEvent~^~VUID-vkCreateEvent-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkEventCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_20215e01~^~Y~^~Unknown~^~vkCreateEvent~^~VUID-vkCreateEvent-pEvent-parameter~^~core~^~The spec valid usage text states 'pEvent must be a valid pointer to a VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-pEvent-parameter)~^~implicit -VALIDATION_ERROR_20405601~^~Y~^~None~^~vkCreateFence~^~VUID-vkCreateFence-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-device-parameter)~^~implicit -VALIDATION_ERROR_2040ec01~^~N~^~Unknown~^~vkCreateFence~^~VUID-vkCreateFence-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20411e01~^~N~^~Unknown~^~vkCreateFence~^~VUID-vkCreateFence-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkFenceCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_20417001~^~Y~^~Unknown~^~vkCreateFence~^~VUID-vkCreateFence-pFence-parameter~^~core~^~The spec valid usage text states 'pFence must be a valid pointer to a VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-pFence-parameter)~^~implicit -VALIDATION_ERROR_20605601~^~Y~^~None~^~vkCreateFramebuffer~^~VUID-vkCreateFramebuffer-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-device-parameter)~^~implicit -VALIDATION_ERROR_2060ec01~^~N~^~Unknown~^~vkCreateFramebuffer~^~VUID-vkCreateFramebuffer-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20611e01~^~N~^~Unknown~^~vkCreateFramebuffer~^~VUID-vkCreateFramebuffer-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_20617801~^~Y~^~Unknown~^~vkCreateFramebuffer~^~VUID-vkCreateFramebuffer-pFramebuffer-parameter~^~core~^~The spec valid usage text states 'pFramebuffer must be a valid pointer to a VkFramebuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-pFramebuffer-parameter)~^~implicit -VALIDATION_ERROR_208005a0~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-flags-00720~^~core~^~The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-flags-00720)~^~ -VALIDATION_ERROR_208005a2~^~N~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-flags-00721~^~core~^~The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-flags-00721)~^~ -VALIDATION_ERROR_2080381b~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength~^~core~^~The spec valid usage text states 'createInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength)~^~implicit -VALIDATION_ERROR_20805601~^~Y~^~None~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-device-parameter)~^~implicit -VALIDATION_ERROR_2080ec01~^~N~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20812001~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter~^~core~^~The spec valid usage text states 'pCreateInfos must be a valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter)~^~implicit -VALIDATION_ERROR_2081e201~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-pPipelines-parameter~^~core~^~The spec valid usage text states 'pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pPipelines-parameter)~^~implicit -VALIDATION_ERROR_20828001~^~Y~^~None~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-pipelineCache-parameter~^~core~^~The spec valid usage text states 'If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pipelineCache-parameter)~^~implicit -VALIDATION_ERROR_20828007~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-vkCreateGraphicsPipelines-pipelineCache-parent~^~core~^~The spec valid usage text states 'If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pipelineCache-parent)~^~implicit -VALIDATION_ERROR_20a0bc01~^~Y~^~Unknown~^~vkCreateIOSSurfaceMVK~^~VUID-vkCreateIOSSurfaceMVK-instance-parameter~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-instance-parameter)~^~implicit -VALIDATION_ERROR_20a0ec01~^~N~^~Unknown~^~vkCreateIOSSurfaceMVK~^~VUID-vkCreateIOSSurfaceMVK-pAllocator-parameter~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20a11e01~^~N~^~Unknown~^~vkCreateIOSSurfaceMVK~^~VUID-vkCreateIOSSurfaceMVK-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkIOSSurfaceCreateInfoMVK structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_20a24801~^~Y~^~Unknown~^~vkCreateIOSSurfaceMVK~^~VUID-vkCreateIOSSurfaceMVK-pSurface-parameter~^~(VK_KHR_surface)+(VK_MVK_ios_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-pSurface-parameter)~^~implicit -VALIDATION_ERROR_20c00756~^~N~^~Unknown~^~vkCreateImage~^~VUID-vkCreateImage-flags-00939~^~core~^~The spec valid usage text states 'If the flags member of pCreateInfo includes VK_IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-flags-00939)~^~ -VALIDATION_ERROR_20c05601~^~Y~^~None~^~vkCreateImage~^~VUID-vkCreateImage-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-device-parameter)~^~implicit -VALIDATION_ERROR_20c0ec01~^~N~^~Unknown~^~vkCreateImage~^~VUID-vkCreateImage-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20c11e01~^~N~^~Unknown~^~vkCreateImage~^~VUID-vkCreateImage-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkImageCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_20c17e01~^~Y~^~Unknown~^~vkCreateImage~^~VUID-vkCreateImage-pImage-parameter~^~core~^~The spec valid usage text states 'pImage must be a valid pointer to a VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-pImage-parameter)~^~implicit -VALIDATION_ERROR_20e05601~^~Y~^~None~^~vkCreateImageView~^~VUID-vkCreateImageView-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-device-parameter)~^~implicit -VALIDATION_ERROR_20e0ec01~^~N~^~Unknown~^~vkCreateImageView~^~VUID-vkCreateImageView-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_20e11e01~^~N~^~Unknown~^~vkCreateImageView~^~VUID-vkCreateImageView-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkImageViewCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_20e26a01~^~Y~^~Unknown~^~vkCreateImageView~^~VUID-vkCreateImageView-pView-parameter~^~core~^~The spec valid usage text states 'pView must be a valid pointer to a VkImageView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-pView-parameter)~^~implicit -VALIDATION_ERROR_21005601~^~Y~^~Unknown~^~vkCreateIndirectCommandsLayoutNVX~^~VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter)~^~implicit -VALIDATION_ERROR_2100ec01~^~N~^~Unknown~^~vkCreateIndirectCommandsLayoutNVX~^~VUID-vkCreateIndirectCommandsLayoutNVX-pAllocator-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_21011e01~^~N~^~Unknown~^~vkCreateIndirectCommandsLayoutNVX~^~VUID-vkCreateIndirectCommandsLayoutNVX-pCreateInfo-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkIndirectCommandsLayoutCreateInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_21019201~^~Y~^~Unknown~^~vkCreateIndirectCommandsLayoutNVX~^~VUID-vkCreateIndirectCommandsLayoutNVX-pIndirectCommandsLayout-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pIndirectCommandsLayout must be a valid pointer to a VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-pIndirectCommandsLayout-parameter)~^~implicit -VALIDATION_ERROR_21200ad8~^~Y~^~None~^~vkCreateInstance~^~VUID-vkCreateInstance-ppEnabledExtensionNames-01388~^~core~^~The spec valid usage text states 'All required extensions for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-ppEnabledExtensionNames-01388)~^~ -VALIDATION_ERROR_2120ec01~^~N~^~Unknown~^~vkCreateInstance~^~VUID-vkCreateInstance-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-pAllocator-parameter)~^~implicit, A bad pointer can cause the loader to seg fault. Unfortunately, the validity of the allocator is hard to determine. The structure does not contain an sType and is not created by the Vulkan API. We could try to catch an access violation exception but the loader is written in C, which does not support exceptions. It's not clear if this could be validated in a layer before loader consumption. We could also try to install a signal handler in the loader. -VALIDATION_ERROR_21211e01~^~N~^~Unknown~^~vkCreateInstance~^~VUID-vkCreateInstance-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-pCreateInfo-parameter)~^~implicit, We check the sType correctly, but this can cause the loader to seg fault when pCreateInfo is a nullptr. -VALIDATION_ERROR_21219c01~^~Y~^~Unknown~^~vkCreateInstance~^~VUID-vkCreateInstance-pInstance-parameter~^~core~^~The spec valid usage text states 'pInstance must be a valid pointer to a VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-pInstance-parameter)~^~implicit, How should this be validated? Aside from insidious type-casting, the type will be validated by the compiler. The instance has not been created yet and will likely have no presence in the layers. -VALIDATION_ERROR_2140bc01~^~Y~^~Unknown~^~vkCreateMacOSSurfaceMVK~^~VUID-vkCreateMacOSSurfaceMVK-instance-parameter~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-instance-parameter)~^~implicit -VALIDATION_ERROR_2140ec01~^~N~^~Unknown~^~vkCreateMacOSSurfaceMVK~^~VUID-vkCreateMacOSSurfaceMVK-pAllocator-parameter~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_21411e01~^~N~^~Unknown~^~vkCreateMacOSSurfaceMVK~^~VUID-vkCreateMacOSSurfaceMVK-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkMacOSSurfaceCreateInfoMVK structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_21424801~^~Y~^~Unknown~^~vkCreateMacOSSurfaceMVK~^~VUID-vkCreateMacOSSurfaceMVK-pSurface-parameter~^~(VK_KHR_surface)+(VK_MVK_macos_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-pSurface-parameter)~^~implicit -VALIDATION_ERROR_2160bc01~^~Y~^~None~^~vkCreateMirSurfaceKHR~^~VUID-vkCreateMirSurfaceKHR-instance-parameter~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_2160ec01~^~N~^~Unknown~^~vkCreateMirSurfaceKHR~^~VUID-vkCreateMirSurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_21611e01~^~N~^~Unknown~^~vkCreateMirSurfaceKHR~^~VUID-vkCreateMirSurfaceKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkMirSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_21624801~^~Y~^~Unknown~^~vkCreateMirSurfaceKHR~^~VUID-vkCreateMirSurfaceKHR-pSurface-parameter~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-pSurface-parameter)~^~implicit -VALIDATION_ERROR_21805601~^~Y~^~Unknown~^~vkCreateObjectTableNVX~^~VUID-vkCreateObjectTableNVX-device-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-device-parameter)~^~implicit -VALIDATION_ERROR_2180ec01~^~N~^~Unknown~^~vkCreateObjectTableNVX~^~VUID-vkCreateObjectTableNVX-pAllocator-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_21811e01~^~N~^~Unknown~^~vkCreateObjectTableNVX~^~VUID-vkCreateObjectTableNVX-pCreateInfo-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkObjectTableCreateInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_2181d001~^~Y~^~Unknown~^~vkCreateObjectTableNVX~^~VUID-vkCreateObjectTableNVX-pObjectTable-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pObjectTable must be a valid pointer to a VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-pObjectTable-parameter)~^~implicit -VALIDATION_ERROR_21a05601~^~Y~^~None~^~vkCreatePipelineCache~^~VUID-vkCreatePipelineCache-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-device-parameter)~^~implicit -VALIDATION_ERROR_21a0ec01~^~N~^~Unknown~^~vkCreatePipelineCache~^~VUID-vkCreatePipelineCache-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_21a11e01~^~N~^~Unknown~^~vkCreatePipelineCache~^~VUID-vkCreatePipelineCache-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkPipelineCacheCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_21a1de01~^~Y~^~Unknown~^~vkCreatePipelineCache~^~VUID-vkCreatePipelineCache-pPipelineCache-parameter~^~core~^~The spec valid usage text states 'pPipelineCache must be a valid pointer to a VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-pPipelineCache-parameter)~^~implicit -VALIDATION_ERROR_21c05601~^~Y~^~None~^~vkCreatePipelineLayout~^~VUID-vkCreatePipelineLayout-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-device-parameter)~^~implicit -VALIDATION_ERROR_21c0ec01~^~N~^~Unknown~^~vkCreatePipelineLayout~^~VUID-vkCreatePipelineLayout-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_21c11e01~^~N~^~Unknown~^~vkCreatePipelineLayout~^~VUID-vkCreatePipelineLayout-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkPipelineLayoutCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_21c1e001~^~Y~^~Unknown~^~vkCreatePipelineLayout~^~VUID-vkCreatePipelineLayout-pPipelineLayout-parameter~^~core~^~The spec valid usage text states 'pPipelineLayout must be a valid pointer to a VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-pPipelineLayout-parameter)~^~implicit -VALIDATION_ERROR_21e05601~^~Y~^~None~^~vkCreateQueryPool~^~VUID-vkCreateQueryPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-device-parameter)~^~implicit -VALIDATION_ERROR_21e0ec01~^~N~^~Unknown~^~vkCreateQueryPool~^~VUID-vkCreateQueryPool-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_21e11e01~^~N~^~Unknown~^~vkCreateQueryPool~^~VUID-vkCreateQueryPool-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkQueryPoolCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_21e1fa01~^~Y~^~Unknown~^~vkCreateQueryPool~^~VUID-vkCreateQueryPool-pQueryPool-parameter~^~core~^~The spec valid usage text states 'pQueryPool must be a valid pointer to a VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-pQueryPool-parameter)~^~implicit -VALIDATION_ERROR_22005601~^~Y~^~None~^~vkCreateRenderPass~^~VUID-vkCreateRenderPass-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-device-parameter)~^~implicit -VALIDATION_ERROR_2200ec01~^~N~^~Unknown~^~vkCreateRenderPass~^~VUID-vkCreateRenderPass-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22011e01~^~N~^~Unknown~^~vkCreateRenderPass~^~VUID-vkCreateRenderPass-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_22021601~^~Y~^~Unknown~^~vkCreateRenderPass~^~VUID-vkCreateRenderPass-pRenderPass-parameter~^~core~^~The spec valid usage text states 'pRenderPass must be a valid pointer to a VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-pRenderPass-parameter)~^~implicit -VALIDATION_ERROR_22205601~^~Y~^~None~^~vkCreateSampler~^~VUID-vkCreateSampler-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-device-parameter)~^~implicit -VALIDATION_ERROR_2220ec01~^~N~^~Unknown~^~vkCreateSampler~^~VUID-vkCreateSampler-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22211e01~^~N~^~Unknown~^~vkCreateSampler~^~VUID-vkCreateSampler-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSamplerCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_22222401~^~Y~^~Unknown~^~vkCreateSampler~^~VUID-vkCreateSampler-pSampler-parameter~^~core~^~The spec valid usage text states 'pSampler must be a valid pointer to a VkSampler handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-pSampler-parameter)~^~implicit -VALIDATION_ERROR_22405601~^~Y~^~None~^~vkCreateSemaphore~^~VUID-vkCreateSemaphore-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-device-parameter)~^~implicit -VALIDATION_ERROR_2240ec01~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-vkCreateSemaphore-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22411e01~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-vkCreateSemaphore-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSemaphoreCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_22422801~^~Y~^~Unknown~^~vkCreateSemaphore~^~VUID-vkCreateSemaphore-pSemaphore-parameter~^~core~^~The spec valid usage text states 'pSemaphore must be a valid pointer to a VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-pSemaphore-parameter)~^~implicit -VALIDATION_ERROR_22605601~^~Y~^~None~^~vkCreateShaderModule~^~VUID-vkCreateShaderModule-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-device-parameter)~^~implicit -VALIDATION_ERROR_2260ec01~^~N~^~Unknown~^~vkCreateShaderModule~^~VUID-vkCreateShaderModule-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22611e01~^~N~^~Unknown~^~vkCreateShaderModule~^~VUID-vkCreateShaderModule-pCreateInfo-parameter~^~core~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkShaderModuleCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_22622e01~^~Y~^~Unknown~^~vkCreateShaderModule~^~VUID-vkCreateShaderModule-pShaderModule-parameter~^~core~^~The spec valid usage text states 'pShaderModule must be a valid pointer to a VkShaderModule handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-pShaderModule-parameter)~^~implicit -VALIDATION_ERROR_22805601~^~Y~^~None~^~vkCreateSharedSwapchainsKHR~^~VUID-vkCreateSharedSwapchainsKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-device-parameter)~^~implicit -VALIDATION_ERROR_2280ec01~^~N~^~Unknown~^~vkCreateSharedSwapchainsKHR~^~VUID-vkCreateSharedSwapchainsKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22812001~^~Y~^~Unknown~^~vkCreateSharedSwapchainsKHR~^~VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'pCreateInfos must be a valid pointer to an array of swapchainCount valid VkSwapchainCreateInfoKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter)~^~implicit -VALIDATION_ERROR_22825801~^~Y~^~Unknown~^~vkCreateSharedSwapchainsKHR~^~VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'pSwapchains must be a valid pointer to an array of swapchainCount VkSwapchainKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter)~^~implicit -VALIDATION_ERROR_2282f21b~^~Y~^~Unknown~^~vkCreateSharedSwapchainsKHR~^~VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength)~^~implicit -VALIDATION_ERROR_22a05601~^~Y~^~None~^~vkCreateSwapchainKHR~^~VUID-vkCreateSwapchainKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-device-parameter)~^~implicit -VALIDATION_ERROR_22a0ec01~^~N~^~Unknown~^~vkCreateSwapchainKHR~^~VUID-vkCreateSwapchainKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22a11e01~^~N~^~Unknown~^~vkCreateSwapchainKHR~^~VUID-vkCreateSwapchainKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_22a25201~^~Y~^~Unknown~^~vkCreateSwapchainKHR~^~VUID-vkCreateSwapchainKHR-pSwapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'pSwapchain must be a valid pointer to a VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-pSwapchain-parameter)~^~implicit -VALIDATION_ERROR_22c0bc01~^~Y~^~Unknown~^~vkCreateViSurfaceNN~^~VUID-vkCreateViSurfaceNN-instance-parameter~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-instance-parameter)~^~implicit -VALIDATION_ERROR_22c0ec01~^~N~^~Unknown~^~vkCreateViSurfaceNN~^~VUID-vkCreateViSurfaceNN-pAllocator-parameter~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22c11e01~^~N~^~Unknown~^~vkCreateViSurfaceNN~^~VUID-vkCreateViSurfaceNN-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkViSurfaceCreateInfoNN structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_22c24801~^~Y~^~Unknown~^~vkCreateViSurfaceNN~^~VUID-vkCreateViSurfaceNN-pSurface-parameter~^~(VK_KHR_surface)+(VK_NN_vi_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-pSurface-parameter)~^~implicit -VALIDATION_ERROR_22e0bc01~^~Y~^~None~^~vkCreateWaylandSurfaceKHR~^~VUID-vkCreateWaylandSurfaceKHR-instance-parameter~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_22e0ec01~^~N~^~Unknown~^~vkCreateWaylandSurfaceKHR~^~VUID-vkCreateWaylandSurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_22e11e01~^~N~^~Unknown~^~vkCreateWaylandSurfaceKHR~^~VUID-vkCreateWaylandSurfaceKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkWaylandSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_22e24801~^~Y~^~Unknown~^~vkCreateWaylandSurfaceKHR~^~VUID-vkCreateWaylandSurfaceKHR-pSurface-parameter~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-pSurface-parameter)~^~implicit -VALIDATION_ERROR_2300bc01~^~Y~^~None~^~vkCreateWin32SurfaceKHR~^~VUID-vkCreateWin32SurfaceKHR-instance-parameter~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_2300ec01~^~N~^~Unknown~^~vkCreateWin32SurfaceKHR~^~VUID-vkCreateWin32SurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_23011e01~^~N~^~Unknown~^~vkCreateWin32SurfaceKHR~^~VUID-vkCreateWin32SurfaceKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkWin32SurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_23024801~^~Y~^~Unknown~^~vkCreateWin32SurfaceKHR~^~VUID-vkCreateWin32SurfaceKHR-pSurface-parameter~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-pSurface-parameter)~^~implicit -VALIDATION_ERROR_2320bc01~^~Y~^~None~^~vkCreateXcbSurfaceKHR~^~VUID-vkCreateXcbSurfaceKHR-instance-parameter~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_2320ec01~^~N~^~Unknown~^~vkCreateXcbSurfaceKHR~^~VUID-vkCreateXcbSurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_23211e01~^~N~^~Unknown~^~vkCreateXcbSurfaceKHR~^~VUID-vkCreateXcbSurfaceKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkXcbSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_23224801~^~Y~^~Unknown~^~vkCreateXcbSurfaceKHR~^~VUID-vkCreateXcbSurfaceKHR-pSurface-parameter~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-pSurface-parameter)~^~implicit -VALIDATION_ERROR_2340bc01~^~Y~^~None~^~vkCreateXlibSurfaceKHR~^~VUID-vkCreateXlibSurfaceKHR-instance-parameter~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_2340ec01~^~N~^~Unknown~^~vkCreateXlibSurfaceKHR~^~VUID-vkCreateXlibSurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_23411e01~^~N~^~Unknown~^~vkCreateXlibSurfaceKHR~^~VUID-vkCreateXlibSurfaceKHR-pCreateInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkXlibSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_23424801~^~Y~^~Unknown~^~vkCreateXlibSurfaceKHR~^~VUID-vkCreateXlibSurfaceKHR-pSurface-parameter~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-pSurface-parameter)~^~implicit -VALIDATION_ERROR_23605601~^~Y~^~None~^~vkDebugMarkerSetObjectNameEXT~^~VUID-vkDebugMarkerSetObjectNameEXT-device-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectNameEXT-device-parameter)~^~implicit -VALIDATION_ERROR_2361c201~^~N~^~Unknown~^~vkDebugMarkerSetObjectNameEXT~^~VUID-vkDebugMarkerSetObjectNameEXT-pNameInfo-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pNameInfo must be a valid pointer to a valid VkDebugMarkerObjectNameInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectNameEXT-pNameInfo-parameter)~^~implicit -VALIDATION_ERROR_23805601~^~Y~^~None~^~vkDebugMarkerSetObjectTagEXT~^~VUID-vkDebugMarkerSetObjectTagEXT-device-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectTagEXT-device-parameter)~^~implicit -VALIDATION_ERROR_23825c01~^~N~^~Unknown~^~vkDebugMarkerSetObjectTagEXT~^~VUID-vkDebugMarkerSetObjectTagEXT-pTagInfo-parameter~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'pTagInfo must be a valid pointer to a valid VkDebugMarkerObjectTagInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectTagEXT-pTagInfo-parameter)~^~implicit -VALIDATION_ERROR_23a009b2~^~N~^~Unknown~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-object-01241~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'object must be a Vulkan object or VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-object-01241)~^~ -VALIDATION_ERROR_23a00bb4~^~N~^~None~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-objectType-01498~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in debug-report-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-objectType-01498)~^~ -VALIDATION_ERROR_23a09001~^~N~^~Unknown~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-flags-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'flags must be a valid combination of VkDebugReportFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_23a09003~^~Y~^~Unknown~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-flags-requiredbitmask~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_23a0bc01~^~N~^~Unknown~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-instance-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-instance-parameter)~^~implicit -VALIDATION_ERROR_23a0da01~^~Y~^~Unknown~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-objectType-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'objectType must be a valid VkDebugReportObjectTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-objectType-parameter)~^~implicit -VALIDATION_ERROR_23a1a001~^~Y~^~Unknown~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'pLayerPrefix must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter)~^~implicit -VALIDATION_ERROR_23a1b801~^~Y~^~Unknown~^~vkDebugReportMessageEXT~^~VUID-vkDebugReportMessageEXT-pMessage-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'pMessage must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-pMessage-parameter)~^~implicit -VALIDATION_ERROR_23c00734~^~Y~^~Unknown~^~vkDestroyBuffer~^~VUID-vkDestroyBuffer-buffer-00922~^~core~^~The spec valid usage text states 'All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-00922)~^~ -VALIDATION_ERROR_23c00736~^~Y~^~Unknown~^~vkDestroyBuffer~^~VUID-vkDestroyBuffer-buffer-00923~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-00923)~^~ -VALIDATION_ERROR_23c00738~^~Y~^~Unknown~^~vkDestroyBuffer~^~VUID-vkDestroyBuffer-buffer-00924~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-00924)~^~ -VALIDATION_ERROR_23c01a01~^~Y~^~VertexBufferInvalid~^~vkDestroyBuffer~^~VUID-vkDestroyBuffer-buffer-parameter~^~core~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-parameter)~^~implicit -VALIDATION_ERROR_23c01a07~^~Y~^~Unknown~^~vkDestroyBuffer~^~VUID-vkDestroyBuffer-buffer-parent~^~core~^~The spec valid usage text states 'If buffer is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-parent)~^~implicit -VALIDATION_ERROR_23c05601~^~Y~^~None~^~vkDestroyBuffer~^~VUID-vkDestroyBuffer-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-device-parameter)~^~implicit -VALIDATION_ERROR_23c0ec01~^~N~^~Unknown~^~vkDestroyBuffer~^~VUID-vkDestroyBuffer-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_23e00750~^~Y~^~BufferViewInUseDestroyedSignaled~^~vkDestroyBufferView~^~VUID-vkDestroyBufferView-bufferView-00936~^~core~^~The spec valid usage text states 'All submitted commands that refer to bufferView must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-00936)~^~ -VALIDATION_ERROR_23e00752~^~Y~^~Unknown~^~vkDestroyBufferView~^~VUID-vkDestroyBufferView-bufferView-00937~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-00937)~^~ -VALIDATION_ERROR_23e00754~^~Y~^~Unknown~^~vkDestroyBufferView~^~VUID-vkDestroyBufferView-bufferView-00938~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-00938)~^~ -VALIDATION_ERROR_23e01c01~^~Y~^~None~^~vkDestroyBufferView~^~VUID-vkDestroyBufferView-bufferView-parameter~^~core~^~The spec valid usage text states 'If bufferView is not VK_NULL_HANDLE, bufferView must be a valid VkBufferView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-parameter)~^~implicit -VALIDATION_ERROR_23e01c07~^~Y~^~Unknown~^~vkDestroyBufferView~^~VUID-vkDestroyBufferView-bufferView-parent~^~core~^~The spec valid usage text states 'If bufferView is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-parent)~^~implicit -VALIDATION_ERROR_23e05601~^~Y~^~None~^~vkDestroyBufferView~^~VUID-vkDestroyBufferView-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-device-parameter)~^~implicit -VALIDATION_ERROR_23e0ec01~^~N~^~Unknown~^~vkDestroyBufferView~^~VUID-vkDestroyBufferView-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_24000052~^~Y~^~None~^~vkDestroyCommandPool~^~VUID-vkDestroyCommandPool-commandPool-00041~^~core~^~The spec valid usage text states 'All VkCommandBuffer objects allocated from commandPool must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-00041)~^~ -VALIDATION_ERROR_24000054~^~Y~^~Unknown~^~vkDestroyCommandPool~^~VUID-vkDestroyCommandPool-commandPool-00042~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-00042)~^~ -VALIDATION_ERROR_24000056~^~Y~^~Unknown~^~vkDestroyCommandPool~^~VUID-vkDestroyCommandPool-commandPool-00043~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-00043)~^~ -VALIDATION_ERROR_24002801~^~Y~^~None~^~vkDestroyCommandPool~^~VUID-vkDestroyCommandPool-commandPool-parameter~^~core~^~The spec valid usage text states 'If commandPool is not VK_NULL_HANDLE, commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-parameter)~^~implicit -VALIDATION_ERROR_24002807~^~Y~^~Unknown~^~vkDestroyCommandPool~^~VUID-vkDestroyCommandPool-commandPool-parent~^~core~^~The spec valid usage text states 'If commandPool is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-parent)~^~implicit -VALIDATION_ERROR_24005601~^~Y~^~None~^~vkDestroyCommandPool~^~VUID-vkDestroyCommandPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-device-parameter)~^~implicit -VALIDATION_ERROR_2400ec01~^~N~^~Unknown~^~vkDestroyCommandPool~^~VUID-vkDestroyCommandPool-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_242009b4~^~Y~^~Unknown~^~vkDestroyDebugReportCallbackEXT~^~VUID-vkDestroyDebugReportCallbackEXT-instance-01242~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when callback was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-instance-01242)~^~ -VALIDATION_ERROR_242009b6~^~Y~^~Unknown~^~vkDestroyDebugReportCallbackEXT~^~VUID-vkDestroyDebugReportCallbackEXT-instance-01243~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when callback was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-instance-01243)~^~ -VALIDATION_ERROR_24201e01~^~N~^~Unknown~^~vkDestroyDebugReportCallbackEXT~^~VUID-vkDestroyDebugReportCallbackEXT-callback-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'callback must be a valid VkDebugReportCallbackEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-callback-parameter)~^~implicit -VALIDATION_ERROR_24201e07~^~N~^~Unknown~^~vkDestroyDebugReportCallbackEXT~^~VUID-vkDestroyDebugReportCallbackEXT-callback-parent~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'callback must have been created, allocated, or retrieved from instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-callback-parent)~^~implicit -VALIDATION_ERROR_2420bc01~^~N~^~Unknown~^~vkDestroyDebugReportCallbackEXT~^~VUID-vkDestroyDebugReportCallbackEXT-instance-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-instance-parameter)~^~implicit -VALIDATION_ERROR_2420ec01~^~N~^~Unknown~^~vkDestroyDebugReportCallbackEXT~^~VUID-vkDestroyDebugReportCallbackEXT-pAllocator-parameter~^~(VK_EXT_debug_report)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_2440025e~^~Y~^~None~^~vkDestroyDescriptorPool~^~VUID-vkDestroyDescriptorPool-descriptorPool-00303~^~core~^~The spec valid usage text states 'All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-00303)~^~ -VALIDATION_ERROR_24400260~^~Y~^~Unknown~^~vkDestroyDescriptorPool~^~VUID-vkDestroyDescriptorPool-descriptorPool-00304~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-00304)~^~ -VALIDATION_ERROR_24400262~^~Y~^~Unknown~^~vkDestroyDescriptorPool~^~VUID-vkDestroyDescriptorPool-descriptorPool-00305~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-00305)~^~ -VALIDATION_ERROR_24404601~^~Y~^~None~^~vkDestroyDescriptorPool~^~VUID-vkDestroyDescriptorPool-descriptorPool-parameter~^~core~^~The spec valid usage text states 'If descriptorPool is not VK_NULL_HANDLE, descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-parameter)~^~implicit -VALIDATION_ERROR_24404607~^~Y~^~Unknown~^~vkDestroyDescriptorPool~^~VUID-vkDestroyDescriptorPool-descriptorPool-parent~^~core~^~The spec valid usage text states 'If descriptorPool is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-parent)~^~implicit -VALIDATION_ERROR_24405601~^~Y~^~None~^~vkDestroyDescriptorPool~^~VUID-vkDestroyDescriptorPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-device-parameter)~^~implicit -VALIDATION_ERROR_2440ec01~^~N~^~Unknown~^~vkDestroyDescriptorPool~^~VUID-vkDestroyDescriptorPool-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_24600238~^~Y~^~Unknown~^~vkDestroyDescriptorSetLayout~^~VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284)~^~ -VALIDATION_ERROR_2460023a~^~Y~^~Unknown~^~vkDestroyDescriptorSetLayout~^~VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285)~^~ -VALIDATION_ERROR_24604c01~^~Y~^~None~^~vkDestroyDescriptorSetLayout~^~VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter~^~core~^~The spec valid usage text states 'If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter)~^~implicit -VALIDATION_ERROR_24604c07~^~Y~^~Unknown~^~vkDestroyDescriptorSetLayout~^~VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent~^~core~^~The spec valid usage text states 'If descriptorSetLayout is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent)~^~implicit -VALIDATION_ERROR_24605601~^~Y~^~None~^~vkDestroyDescriptorSetLayout~^~VUID-vkDestroyDescriptorSetLayout-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-device-parameter)~^~implicit -VALIDATION_ERROR_2460ec01~^~N~^~Unknown~^~vkDestroyDescriptorSetLayout~^~VUID-vkDestroyDescriptorSetLayout-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_248002c8~^~Y~^~Unknown~^~vkDestroyDescriptorUpdateTemplate~^~VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356)~^~ -VALIDATION_ERROR_248002ca~^~Y~^~Unknown~^~vkDestroyDescriptorUpdateTemplate~^~VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357)~^~ -VALIDATION_ERROR_24805201~^~Y~^~Unknown~^~vkDestroyDescriptorUpdateTemplate~^~VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If descriptorUpdateTemplate is not VK_NULL_HANDLE, descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter)~^~implicit -VALIDATION_ERROR_24805207~^~Y~^~Unknown~^~vkDestroyDescriptorUpdateTemplate~^~VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If descriptorUpdateTemplate is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent)~^~implicit -VALIDATION_ERROR_24805601~^~Y~^~Unknown~^~vkDestroyDescriptorUpdateTemplate~^~VUID-vkDestroyDescriptorUpdateTemplate-device-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-device-parameter)~^~implicit -VALIDATION_ERROR_2480ec01~^~N~^~Unknown~^~vkDestroyDescriptorUpdateTemplate~^~VUID-vkDestroyDescriptorUpdateTemplate-pAllocator-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_24a002f4~^~Y~^~Unknown~^~vkDestroyDevice~^~VUID-vkDestroyDevice-device-00378~^~core~^~The spec valid usage text states 'All child objects created on device must have been destroyed prior to destroying device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-00378)~^~ -VALIDATION_ERROR_24a002f6~^~Y~^~Unknown~^~vkDestroyDevice~^~VUID-vkDestroyDevice-device-00379~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-00379)~^~ -VALIDATION_ERROR_24a002f8~^~Y~^~Unknown~^~vkDestroyDevice~^~VUID-vkDestroyDevice-device-00380~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-00380)~^~ -VALIDATION_ERROR_24a05601~^~Y~^~None~^~vkDestroyDevice~^~VUID-vkDestroyDevice-device-parameter~^~core~^~The spec valid usage text states 'If device is not NULL, device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-parameter)~^~implicit -VALIDATION_ERROR_24a0ec01~^~N~^~Unknown~^~vkDestroyDevice~^~VUID-vkDestroyDevice-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_24c008f2~^~Y~^~InUseDestroyedSignaled~^~vkDestroyEvent~^~VUID-vkDestroyEvent-event-01145~^~core~^~The spec valid usage text states 'All submitted commands that refer to event must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-01145)~^~ -VALIDATION_ERROR_24c008f4~^~Y~^~Unknown~^~vkDestroyEvent~^~VUID-vkDestroyEvent-event-01146~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-01146)~^~ -VALIDATION_ERROR_24c008f6~^~Y~^~Unknown~^~vkDestroyEvent~^~VUID-vkDestroyEvent-event-01147~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-01147)~^~ -VALIDATION_ERROR_24c05601~^~Y~^~None~^~vkDestroyEvent~^~VUID-vkDestroyEvent-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-device-parameter)~^~implicit -VALIDATION_ERROR_24c07e01~^~Y~^~None~^~vkDestroyEvent~^~VUID-vkDestroyEvent-event-parameter~^~core~^~The spec valid usage text states 'If event is not VK_NULL_HANDLE, event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-parameter)~^~implicit -VALIDATION_ERROR_24c07e07~^~Y~^~Unknown~^~vkDestroyEvent~^~VUID-vkDestroyEvent-event-parent~^~core~^~The spec valid usage text states 'If event is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-parent)~^~implicit -VALIDATION_ERROR_24c0ec01~^~N~^~Unknown~^~vkDestroyEvent~^~VUID-vkDestroyEvent-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_24e008c0~^~Y~^~Unknown~^~vkDestroyFence~^~VUID-vkDestroyFence-fence-01120~^~core~^~The spec valid usage text states 'All queue submission commands that refer to fence must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-01120)~^~ -VALIDATION_ERROR_24e008c2~^~Y~^~Unknown~^~vkDestroyFence~^~VUID-vkDestroyFence-fence-01121~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-01121)~^~ -VALIDATION_ERROR_24e008c4~^~Y~^~Unknown~^~vkDestroyFence~^~VUID-vkDestroyFence-fence-01122~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-01122)~^~ -VALIDATION_ERROR_24e05601~^~Y~^~None~^~vkDestroyFence~^~VUID-vkDestroyFence-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-device-parameter)~^~implicit -VALIDATION_ERROR_24e08801~^~Y~^~None~^~vkDestroyFence~^~VUID-vkDestroyFence-fence-parameter~^~core~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-parameter)~^~implicit -VALIDATION_ERROR_24e08807~^~Y~^~Unknown~^~vkDestroyFence~^~VUID-vkDestroyFence-fence-parent~^~core~^~The spec valid usage text states 'If fence is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-parent)~^~implicit -VALIDATION_ERROR_24e0ec01~^~N~^~Unknown~^~vkDestroyFence~^~VUID-vkDestroyFence-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_250006f8~^~Y~^~FramebufferInUseDestroyedSignaled~^~vkDestroyFramebuffer~^~VUID-vkDestroyFramebuffer-framebuffer-00892~^~core~^~The spec valid usage text states 'All submitted commands that refer to framebuffer must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-00892)~^~ -VALIDATION_ERROR_250006fa~^~Y~^~Unknown~^~vkDestroyFramebuffer~^~VUID-vkDestroyFramebuffer-framebuffer-00893~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-00893)~^~ -VALIDATION_ERROR_250006fc~^~Y~^~Unknown~^~vkDestroyFramebuffer~^~VUID-vkDestroyFramebuffer-framebuffer-00894~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-00894)~^~ -VALIDATION_ERROR_25005601~^~Y~^~None~^~vkDestroyFramebuffer~^~VUID-vkDestroyFramebuffer-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-device-parameter)~^~implicit -VALIDATION_ERROR_25009401~^~Y~^~None~^~vkDestroyFramebuffer~^~VUID-vkDestroyFramebuffer-framebuffer-parameter~^~core~^~The spec valid usage text states 'If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-parameter)~^~implicit -VALIDATION_ERROR_25009407~^~Y~^~Unknown~^~vkDestroyFramebuffer~^~VUID-vkDestroyFramebuffer-framebuffer-parent~^~core~^~The spec valid usage text states 'If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-parent)~^~implicit -VALIDATION_ERROR_2500ec01~^~N~^~Unknown~^~vkDestroyFramebuffer~^~VUID-vkDestroyFramebuffer-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_252007d0~^~Y~^~FramebufferImageInUseDestroyedSignaled~^~vkDestroyImage~^~VUID-vkDestroyImage-image-01000~^~core~^~The spec valid usage text states 'All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-01000)~^~ -VALIDATION_ERROR_252007d2~^~Y~^~Unknown~^~vkDestroyImage~^~VUID-vkDestroyImage-image-01001~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-01001)~^~ -VALIDATION_ERROR_252007d4~^~Y~^~Unknown~^~vkDestroyImage~^~VUID-vkDestroyImage-image-01002~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-01002)~^~ -VALIDATION_ERROR_25205601~^~Y~^~None~^~vkDestroyImage~^~VUID-vkDestroyImage-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-device-parameter)~^~implicit -VALIDATION_ERROR_2520a001~^~Y~^~None~^~vkDestroyImage~^~VUID-vkDestroyImage-image-parameter~^~core~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-parameter)~^~implicit -VALIDATION_ERROR_2520a007~^~Y~^~Unknown~^~vkDestroyImage~^~VUID-vkDestroyImage-image-parent~^~core~^~The spec valid usage text states 'If image is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-parent)~^~implicit -VALIDATION_ERROR_2520ec01~^~N~^~Unknown~^~vkDestroyImage~^~VUID-vkDestroyImage-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_25400804~^~Y~^~ImageViewInUseDestroyedSignaled~^~vkDestroyImageView~^~VUID-vkDestroyImageView-imageView-01026~^~core~^~The spec valid usage text states 'All submitted commands that refer to imageView must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-01026)~^~ -VALIDATION_ERROR_25400806~^~Y~^~Unknown~^~vkDestroyImageView~^~VUID-vkDestroyImageView-imageView-01027~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-01027)~^~ -VALIDATION_ERROR_25400808~^~Y~^~Unknown~^~vkDestroyImageView~^~VUID-vkDestroyImageView-imageView-01028~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-01028)~^~ -VALIDATION_ERROR_25405601~^~Y~^~None~^~vkDestroyImageView~^~VUID-vkDestroyImageView-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-device-parameter)~^~implicit -VALIDATION_ERROR_2540b001~^~Y~^~None~^~vkDestroyImageView~^~VUID-vkDestroyImageView-imageView-parameter~^~core~^~The spec valid usage text states 'If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-parameter)~^~implicit -VALIDATION_ERROR_2540b007~^~Y~^~Unknown~^~vkDestroyImageView~^~VUID-vkDestroyImageView-imageView-parent~^~core~^~The spec valid usage text states 'If imageView is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-parent)~^~implicit -VALIDATION_ERROR_2540ec01~^~N~^~Unknown~^~vkDestroyImageView~^~VUID-vkDestroyImageView-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_25600a90~^~N~^~Unknown~^~vkDestroyIndirectCommandsLayoutNVX~^~VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-01352~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'All submitted commands that refer to indirectCommandsLayout must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-01352)~^~ -VALIDATION_ERROR_25600a92~^~N~^~Unknown~^~vkDestroyIndirectCommandsLayoutNVX~^~VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01353~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01353)~^~ -VALIDATION_ERROR_25600a94~^~N~^~Unknown~^~vkDestroyIndirectCommandsLayoutNVX~^~VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01354~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01354)~^~ -VALIDATION_ERROR_25605601~^~Y~^~Unknown~^~vkDestroyIndirectCommandsLayoutNVX~^~VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter)~^~implicit -VALIDATION_ERROR_2560b401~^~Y~^~Unknown~^~vkDestroyIndirectCommandsLayoutNVX~^~VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter)~^~implicit -VALIDATION_ERROR_2560b407~^~Y~^~Unknown~^~vkDestroyIndirectCommandsLayoutNVX~^~VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'indirectCommandsLayout must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent)~^~implicit -VALIDATION_ERROR_2560ec01~^~N~^~Unknown~^~vkDestroyIndirectCommandsLayoutNVX~^~VUID-vkDestroyIndirectCommandsLayoutNVX-pAllocator-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_258004ea~^~Y~^~Unknown~^~vkDestroyInstance~^~VUID-vkDestroyInstance-instance-00629~^~core~^~The spec valid usage text states 'All child objects created using instance must have been destroyed prior to destroying instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-00629)~^~ -VALIDATION_ERROR_258004ec~^~Y~^~Unknown~^~vkDestroyInstance~^~VUID-vkDestroyInstance-instance-00630~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-00630)~^~ -VALIDATION_ERROR_258004ee~^~Y~^~Unknown~^~vkDestroyInstance~^~VUID-vkDestroyInstance-instance-00631~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-00631)~^~ -VALIDATION_ERROR_2580bc01~^~Y~^~None~^~vkDestroyInstance~^~VUID-vkDestroyInstance-instance-parameter~^~core~^~The spec valid usage text states 'If instance is not NULL, instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-parameter)~^~implicit, We have a check for this in object tracker but I believe it's bogus. This can't be validated in a layer. Validataion would have to occur in a loader. -VALIDATION_ERROR_2580ec01~^~N~^~Unknown~^~vkDestroyInstance~^~VUID-vkDestroyInstance-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_25a00aa2~^~N~^~Unknown~^~vkDestroyObjectTableNVX~^~VUID-vkDestroyObjectTableNVX-objectTable-01361~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'All submitted commands that refer to objectTable must have completed execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-01361)~^~ -VALIDATION_ERROR_25a00aa4~^~N~^~Unknown~^~vkDestroyObjectTableNVX~^~VUID-vkDestroyObjectTableNVX-objectTable-01362~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-01362)~^~ -VALIDATION_ERROR_25a00aa6~^~N~^~Unknown~^~vkDestroyObjectTableNVX~^~VUID-vkDestroyObjectTableNVX-objectTable-01363~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-01363)~^~ -VALIDATION_ERROR_25a05601~^~Y~^~Unknown~^~vkDestroyObjectTableNVX~^~VUID-vkDestroyObjectTableNVX-device-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-device-parameter)~^~implicit -VALIDATION_ERROR_25a0d801~^~Y~^~Unknown~^~vkDestroyObjectTableNVX~^~VUID-vkDestroyObjectTableNVX-objectTable-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-parameter)~^~implicit -VALIDATION_ERROR_25a0d807~^~Y~^~Unknown~^~vkDestroyObjectTableNVX~^~VUID-vkDestroyObjectTableNVX-objectTable-parent~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-parent)~^~implicit -VALIDATION_ERROR_25a0ec01~^~N~^~Unknown~^~vkDestroyObjectTableNVX~^~VUID-vkDestroyObjectTableNVX-pAllocator-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_25c005fa~^~Y~^~PipelineInUseDestroyedSignaled~^~vkDestroyPipeline~^~VUID-vkDestroyPipeline-pipeline-00765~^~core~^~The spec valid usage text states 'All submitted commands that refer to pipeline must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-00765)~^~ -VALIDATION_ERROR_25c005fc~^~Y~^~Unknown~^~vkDestroyPipeline~^~VUID-vkDestroyPipeline-pipeline-00766~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-00766)~^~ -VALIDATION_ERROR_25c005fe~^~Y~^~Unknown~^~vkDestroyPipeline~^~VUID-vkDestroyPipeline-pipeline-00767~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-00767)~^~ -VALIDATION_ERROR_25c05601~^~Y~^~None~^~vkDestroyPipeline~^~VUID-vkDestroyPipeline-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-device-parameter)~^~implicit -VALIDATION_ERROR_25c0ec01~^~N~^~Unknown~^~vkDestroyPipeline~^~VUID-vkDestroyPipeline-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_25c27c01~^~Y~^~None~^~vkDestroyPipeline~^~VUID-vkDestroyPipeline-pipeline-parameter~^~core~^~The spec valid usage text states 'If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-parameter)~^~implicit -VALIDATION_ERROR_25c27c07~^~Y~^~Unknown~^~vkDestroyPipeline~^~VUID-vkDestroyPipeline-pipeline-parent~^~core~^~The spec valid usage text states 'If pipeline is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-parent)~^~implicit -VALIDATION_ERROR_25e00606~^~Y~^~Unknown~^~vkDestroyPipelineCache~^~VUID-vkDestroyPipelineCache-pipelineCache-00771~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-00771)~^~ -VALIDATION_ERROR_25e00608~^~Y~^~Unknown~^~vkDestroyPipelineCache~^~VUID-vkDestroyPipelineCache-pipelineCache-00772~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-00772)~^~ -VALIDATION_ERROR_25e05601~^~Y~^~None~^~vkDestroyPipelineCache~^~VUID-vkDestroyPipelineCache-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-device-parameter)~^~implicit -VALIDATION_ERROR_25e0ec01~^~N~^~Unknown~^~vkDestroyPipelineCache~^~VUID-vkDestroyPipelineCache-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_25e28001~^~Y~^~None~^~vkDestroyPipelineCache~^~VUID-vkDestroyPipelineCache-pipelineCache-parameter~^~core~^~The spec valid usage text states 'If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-parameter)~^~implicit -VALIDATION_ERROR_25e28007~^~Y~^~Unknown~^~vkDestroyPipelineCache~^~VUID-vkDestroyPipelineCache-pipelineCache-parent~^~core~^~The spec valid usage text states 'If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-parent)~^~implicit -VALIDATION_ERROR_26000256~^~Y~^~Unknown~^~vkDestroyPipelineLayout~^~VUID-vkDestroyPipelineLayout-pipelineLayout-00299~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-00299)~^~ -VALIDATION_ERROR_26000258~^~Y~^~Unknown~^~vkDestroyPipelineLayout~^~VUID-vkDestroyPipelineLayout-pipelineLayout-00300~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-00300)~^~ -VALIDATION_ERROR_26005601~^~Y~^~None~^~vkDestroyPipelineLayout~^~VUID-vkDestroyPipelineLayout-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-device-parameter)~^~implicit -VALIDATION_ERROR_2600ec01~^~N~^~Unknown~^~vkDestroyPipelineLayout~^~VUID-vkDestroyPipelineLayout-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_26028201~^~Y~^~None~^~vkDestroyPipelineLayout~^~VUID-vkDestroyPipelineLayout-pipelineLayout-parameter~^~core~^~The spec valid usage text states 'If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-parameter)~^~implicit -VALIDATION_ERROR_26028207~^~Y~^~Unknown~^~vkDestroyPipelineLayout~^~VUID-vkDestroyPipelineLayout-pipelineLayout-parent~^~core~^~The spec valid usage text states 'If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-parent)~^~implicit -VALIDATION_ERROR_26200632~^~Y~^~QueryPoolInUseDestroyedSignaled~^~vkDestroyQueryPool~^~VUID-vkDestroyQueryPool-queryPool-00793~^~core~^~The spec valid usage text states 'All submitted commands that refer to queryPool must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-00793)~^~ -VALIDATION_ERROR_26200634~^~Y~^~Unknown~^~vkDestroyQueryPool~^~VUID-vkDestroyQueryPool-queryPool-00794~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-00794)~^~ -VALIDATION_ERROR_26200636~^~Y~^~Unknown~^~vkDestroyQueryPool~^~VUID-vkDestroyQueryPool-queryPool-00795~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-00795)~^~ -VALIDATION_ERROR_26205601~^~Y~^~None~^~vkDestroyQueryPool~^~VUID-vkDestroyQueryPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-device-parameter)~^~implicit -VALIDATION_ERROR_2620ec01~^~N~^~Unknown~^~vkDestroyQueryPool~^~VUID-vkDestroyQueryPool-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_26229801~^~Y~^~None~^~vkDestroyQueryPool~^~VUID-vkDestroyQueryPool-queryPool-parameter~^~core~^~The spec valid usage text states 'If queryPool is not VK_NULL_HANDLE, queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-parameter)~^~implicit -VALIDATION_ERROR_26229807~^~Y~^~Unknown~^~vkDestroyQueryPool~^~VUID-vkDestroyQueryPool-queryPool-parent~^~core~^~The spec valid usage text states 'If queryPool is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-parent)~^~implicit -VALIDATION_ERROR_264006d2~^~Y~^~RenderPassInUseDestroyedSignaled~^~vkDestroyRenderPass~^~VUID-vkDestroyRenderPass-renderPass-00873~^~core~^~The spec valid usage text states 'All submitted commands that refer to renderPass must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-00873)~^~ -VALIDATION_ERROR_264006d4~^~Y~^~Unknown~^~vkDestroyRenderPass~^~VUID-vkDestroyRenderPass-renderPass-00874~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-00874)~^~ -VALIDATION_ERROR_264006d6~^~Y~^~Unknown~^~vkDestroyRenderPass~^~VUID-vkDestroyRenderPass-renderPass-00875~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-00875)~^~ -VALIDATION_ERROR_26405601~^~Y~^~None~^~vkDestroyRenderPass~^~VUID-vkDestroyRenderPass-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-device-parameter)~^~implicit -VALIDATION_ERROR_2640ec01~^~N~^~Unknown~^~vkDestroyRenderPass~^~VUID-vkDestroyRenderPass-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_2642ae01~^~Y~^~None~^~vkDestroyRenderPass~^~VUID-vkDestroyRenderPass-renderPass-parameter~^~core~^~The spec valid usage text states 'If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-parameter)~^~implicit -VALIDATION_ERROR_2642ae07~^~Y~^~UseObjectWithWrongDevice~^~vkDestroyRenderPass~^~VUID-vkDestroyRenderPass-renderPass-parent~^~core~^~The spec valid usage text states 'If renderPass is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-parent)~^~implicit -VALIDATION_ERROR_26600874~^~Y~^~SamplerInUseDestroyedSignaled~^~vkDestroySampler~^~VUID-vkDestroySampler-sampler-01082~^~core~^~The spec valid usage text states 'All submitted commands that refer to sampler must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-01082)~^~ -VALIDATION_ERROR_26600876~^~Y~^~Unknown~^~vkDestroySampler~^~VUID-vkDestroySampler-sampler-01083~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-01083)~^~ -VALIDATION_ERROR_26600878~^~Y~^~Unknown~^~vkDestroySampler~^~VUID-vkDestroySampler-sampler-01084~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-01084)~^~ -VALIDATION_ERROR_26605601~^~Y~^~None~^~vkDestroySampler~^~VUID-vkDestroySampler-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-device-parameter)~^~implicit -VALIDATION_ERROR_2660ec01~^~N~^~Unknown~^~vkDestroySampler~^~VUID-vkDestroySampler-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_2662b201~^~Y~^~None~^~vkDestroySampler~^~VUID-vkDestroySampler-sampler-parameter~^~core~^~The spec valid usage text states 'If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-parameter)~^~implicit -VALIDATION_ERROR_2662b207~^~Y~^~Unknown~^~vkDestroySampler~^~VUID-vkDestroySampler-sampler-parent~^~core~^~The spec valid usage text states 'If sampler is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-parent)~^~implicit -VALIDATION_ERROR_268008e2~^~Y~^~InUseDestroyedSignaled~^~vkDestroySemaphore~^~VUID-vkDestroySemaphore-semaphore-01137~^~core~^~The spec valid usage text states 'All submitted batches that refer to semaphore must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-01137)~^~ -VALIDATION_ERROR_268008e4~^~Y~^~Unknown~^~vkDestroySemaphore~^~VUID-vkDestroySemaphore-semaphore-01138~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-01138)~^~ -VALIDATION_ERROR_268008e6~^~Y~^~Unknown~^~vkDestroySemaphore~^~VUID-vkDestroySemaphore-semaphore-01139~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-01139)~^~ -VALIDATION_ERROR_26805601~^~Y~^~None~^~vkDestroySemaphore~^~VUID-vkDestroySemaphore-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-device-parameter)~^~implicit -VALIDATION_ERROR_2680ec01~^~N~^~Unknown~^~vkDestroySemaphore~^~VUID-vkDestroySemaphore-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_2682b801~^~Y~^~None~^~vkDestroySemaphore~^~VUID-vkDestroySemaphore-semaphore-parameter~^~core~^~The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-parameter)~^~implicit -VALIDATION_ERROR_2682b807~^~Y~^~Unknown~^~vkDestroySemaphore~^~VUID-vkDestroySemaphore-semaphore-parent~^~core~^~The spec valid usage text states 'If semaphore is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-parent)~^~implicit -VALIDATION_ERROR_26a00888~^~Y~^~Unknown~^~vkDestroyShaderModule~^~VUID-vkDestroyShaderModule-shaderModule-01092~^~core~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-01092)~^~ -VALIDATION_ERROR_26a0088a~^~Y~^~Unknown~^~vkDestroyShaderModule~^~VUID-vkDestroyShaderModule-shaderModule-01093~^~core~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-01093)~^~ -VALIDATION_ERROR_26a05601~^~Y~^~None~^~vkDestroyShaderModule~^~VUID-vkDestroyShaderModule-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-device-parameter)~^~implicit -VALIDATION_ERROR_26a0ec01~^~N~^~Unknown~^~vkDestroyShaderModule~^~VUID-vkDestroyShaderModule-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_26a2be01~^~Y~^~None~^~vkDestroyShaderModule~^~VUID-vkDestroyShaderModule-shaderModule-parameter~^~core~^~The spec valid usage text states 'If shaderModule is not VK_NULL_HANDLE, shaderModule must be a valid VkShaderModule handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-parameter)~^~implicit -VALIDATION_ERROR_26a2be07~^~Y~^~Unknown~^~vkDestroyShaderModule~^~VUID-vkDestroyShaderModule-shaderModule-parent~^~core~^~The spec valid usage text states 'If shaderModule is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-parent)~^~implicit -VALIDATION_ERROR_26c009e4~^~Y~^~Unknown~^~vkDestroySurfaceKHR~^~VUID-vkDestroySurfaceKHR-surface-01266~^~(VK_KHR_surface)~^~The spec valid usage text states 'All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-01266)~^~ -VALIDATION_ERROR_26c009e6~^~Y~^~Unknown~^~vkDestroySurfaceKHR~^~VUID-vkDestroySurfaceKHR-surface-01267~^~(VK_KHR_surface)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-01267)~^~ -VALIDATION_ERROR_26c009e8~^~Y~^~Unknown~^~vkDestroySurfaceKHR~^~VUID-vkDestroySurfaceKHR-surface-01268~^~(VK_KHR_surface)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-01268)~^~ -VALIDATION_ERROR_26c0bc01~^~Y~^~None~^~vkDestroySurfaceKHR~^~VUID-vkDestroySurfaceKHR-instance-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-instance-parameter)~^~implicit -VALIDATION_ERROR_26c0ec01~^~N~^~Unknown~^~vkDestroySurfaceKHR~^~VUID-vkDestroySurfaceKHR-pAllocator-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_26c2ec01~^~Y~^~None~^~vkDestroySurfaceKHR~^~VUID-vkDestroySurfaceKHR-surface-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-parameter)~^~implicit -VALIDATION_ERROR_26c2ec07~^~Y~^~Unknown~^~vkDestroySurfaceKHR~^~VUID-vkDestroySurfaceKHR-surface-parent~^~(VK_KHR_surface)~^~The spec valid usage text states 'If surface is a valid handle, it must have been created, allocated, or retrieved from instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-parent)~^~implicit -VALIDATION_ERROR_26e00009~^~N~^~None~^~vkDestroySwapchainKHR~^~VUID-vkDestroySwapchainKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-commonparent)~^~implicit -VALIDATION_ERROR_26e00a04~^~N~^~Unknown~^~vkDestroySwapchainKHR~^~VUID-vkDestroySwapchainKHR-swapchain-01282~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'All uses of presentable images acquired from swapchain must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-01282)~^~ -VALIDATION_ERROR_26e00a06~^~Y~^~Unknown~^~vkDestroySwapchainKHR~^~VUID-vkDestroySwapchainKHR-swapchain-01283~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-01283)~^~ -VALIDATION_ERROR_26e00a08~^~Y~^~Unknown~^~vkDestroySwapchainKHR~^~VUID-vkDestroySwapchainKHR-swapchain-01284~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-01284)~^~ -VALIDATION_ERROR_26e05601~^~N~^~Unknown~^~vkDestroySwapchainKHR~^~VUID-vkDestroySwapchainKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-device-parameter)~^~implicit -VALIDATION_ERROR_26e0ec01~^~N~^~Unknown~^~vkDestroySwapchainKHR~^~VUID-vkDestroySwapchainKHR-pAllocator-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_26e2f001~^~N~^~Unknown~^~vkDestroySwapchainKHR~^~VUID-vkDestroySwapchainKHR-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-parameter)~^~implicit -VALIDATION_ERROR_27005601~^~Y~^~None~^~vkDeviceWaitIdle~^~VUID-vkDeviceWaitIdle-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDeviceWaitIdle-device-parameter)~^~implicit -VALIDATION_ERROR_27205601~^~Y~^~Unknown~^~vkDisplayPowerControlEXT~^~VUID-vkDisplayPowerControlEXT-device-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDisplayPowerControlEXT-device-parameter)~^~implicit -VALIDATION_ERROR_27206001~^~Y~^~Unknown~^~vkDisplayPowerControlEXT~^~VUID-vkDisplayPowerControlEXT-display-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)~^~The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDisplayPowerControlEXT-display-parameter)~^~implicit -VALIDATION_ERROR_27214e01~^~N~^~Unknown~^~vkDisplayPowerControlEXT~^~VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)~^~The spec valid usage text states 'pDisplayPowerInfo must be a valid pointer to a valid VkDisplayPowerInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter)~^~implicit -VALIDATION_ERROR_27400076~^~Y~^~None~^~vkEndCommandBuffer~^~VUID-vkEndCommandBuffer-commandBuffer-00059~^~core~^~The spec valid usage text states 'commandBuffer must be in the recording state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00059)~^~ -VALIDATION_ERROR_27400078~^~Y~^~Unknown~^~vkEndCommandBuffer~^~VUID-vkEndCommandBuffer-commandBuffer-00060~^~core~^~The spec valid usage text states 'If commandBuffer is a primary command buffer, there must not be an active render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00060)~^~ -VALIDATION_ERROR_2740007a~^~Y~^~Unknown~^~vkEndCommandBuffer~^~VUID-vkEndCommandBuffer-commandBuffer-00061~^~core~^~The spec valid usage text states 'All queries made active during the recording of commandBuffer must have been made inactive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00061)~^~ -VALIDATION_ERROR_2740007c~^~N~^~Unknown~^~vkEndCommandBuffer~^~VUID-vkEndCommandBuffer-commandBuffer-00062~^~(VK_EXT_debug_marker)~^~The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00062)~^~ -VALIDATION_ERROR_27400e2e~^~N~^~None~^~vkEndCommandBuffer~^~VUID-vkEndCommandBuffer-commandBuffer-01815~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-01815)~^~ -VALIDATION_ERROR_27402401~^~Y~^~None~^~vkEndCommandBuffer~^~VUID-vkEndCommandBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_27619e01~^~N~^~Unknown~^~vkEnumerateDeviceExtensionProperties~^~VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter~^~core~^~The spec valid usage text states 'If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter)~^~implicit -VALIDATION_ERROR_2761f401~^~Y~^~Unknown~^~vkEnumerateDeviceExtensionProperties~^~VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2761f601~^~N~^~Unknown~^~vkEnumerateDeviceExtensionProperties~^~VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter~^~core~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_27627a01~^~N~^~Unknown~^~vkEnumerateDeviceExtensionProperties~^~VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2781f401~^~N~^~Unknown~^~vkEnumerateDeviceLayerProperties~^~VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2781f601~^~N~^~Unknown~^~vkEnumerateDeviceLayerProperties~^~VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter~^~core~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_27827a01~^~N~^~Unknown~^~vkEnumerateDeviceLayerProperties~^~VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_27a19e01~^~N~^~Unknown~^~vkEnumerateInstanceExtensionProperties~^~VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter~^~core~^~The spec valid usage text states 'If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter)~^~implicit -VALIDATION_ERROR_27a1f401~^~N~^~Unknown~^~vkEnumerateInstanceExtensionProperties~^~VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter)~^~implicit -VALIDATION_ERROR_27a1f601~^~N~^~Unknown~^~vkEnumerateInstanceExtensionProperties~^~VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter~^~core~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_27c1f401~^~N~^~Unknown~^~vkEnumerateInstanceLayerProperties~^~VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter)~^~implicit -VALIDATION_ERROR_27c1f601~^~N~^~Unknown~^~vkEnumerateInstanceLayerProperties~^~VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter~^~core~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_27e0bc01~^~Y~^~Unknown~^~vkEnumeratePhysicalDeviceGroups~^~VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter)~^~implicit -VALIDATION_ERROR_27e1d801~^~N~^~Unknown~^~vkEnumeratePhysicalDeviceGroups~^~VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'pPhysicalDeviceGroupCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter)~^~implicit -VALIDATION_ERROR_27e1da01~^~Y~^~Unknown~^~vkEnumeratePhysicalDeviceGroups~^~VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group_creation)~^~The spec valid usage text states 'If the value referenced by pPhysicalDeviceGroupCount is not 0, and pPhysicalDeviceGroupProperties is not NULL, pPhysicalDeviceGroupProperties must be a valid pointer to an array of pPhysicalDeviceGroupCount VkPhysicalDeviceGroupProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter)~^~implicit -VALIDATION_ERROR_2800bc01~^~Y~^~None~^~vkEnumeratePhysicalDevices~^~VUID-vkEnumeratePhysicalDevices-instance-parameter~^~core~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumeratePhysicalDevices-instance-parameter)~^~implicit -VALIDATION_ERROR_2801d601~^~N~^~Unknown~^~vkEnumeratePhysicalDevices~^~VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter~^~core~^~The spec valid usage text states 'pPhysicalDeviceCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter)~^~implicit -VALIDATION_ERROR_2801dc01~^~Y~^~Unknown~^~vkEnumeratePhysicalDevices~^~VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter)~^~implicit -VALIDATION_ERROR_28205601~^~Y~^~None~^~vkFlushMappedMemoryRanges~^~VUID-vkFlushMappedMemoryRanges-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFlushMappedMemoryRanges-device-parameter)~^~implicit -VALIDATION_ERROR_2820c81b~^~N~^~Unknown~^~vkFlushMappedMemoryRanges~^~VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength~^~core~^~The spec valid usage text states 'memoryRangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength)~^~implicit -VALIDATION_ERROR_2821b201~^~Y~^~Unknown~^~vkFlushMappedMemoryRanges~^~VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter~^~core~^~The spec valid usage text states 'pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter)~^~implicit -VALIDATION_ERROR_2840005e~^~Y~^~None~^~vkFreeCommandBuffers~^~VUID-vkFreeCommandBuffers-pCommandBuffers-00047~^~core~^~The spec valid usage text states 'All elements of pCommandBuffers must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-pCommandBuffers-00047)~^~ -VALIDATION_ERROR_28400060~^~Y~^~Unknown~^~vkFreeCommandBuffers~^~VUID-vkFreeCommandBuffers-pCommandBuffers-00048~^~core~^~The spec valid usage text states 'pCommandBuffers must be a valid pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-pCommandBuffers-00048)~^~ -VALIDATION_ERROR_2840261b~^~N~^~Unknown~^~vkFreeCommandBuffers~^~VUID-vkFreeCommandBuffers-commandBufferCount-arraylength~^~core~^~The spec valid usage text states 'commandBufferCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-commandBufferCount-arraylength)~^~implicit -VALIDATION_ERROR_28402801~^~Y~^~None~^~vkFreeCommandBuffers~^~VUID-vkFreeCommandBuffers-commandPool-parameter~^~core~^~The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-commandPool-parameter)~^~implicit -VALIDATION_ERROR_28402807~^~Y~^~Unknown~^~vkFreeCommandBuffers~^~VUID-vkFreeCommandBuffers-commandPool-parent~^~core~^~The spec valid usage text states 'commandPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-commandPool-parent)~^~implicit -VALIDATION_ERROR_28405601~^~Y~^~None~^~vkFreeCommandBuffers~^~VUID-vkFreeCommandBuffers-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-device-parameter)~^~implicit -VALIDATION_ERROR_28411407~^~Y~^~Unknown~^~vkFreeCommandBuffers~^~VUID-vkFreeCommandBuffers-pCommandBuffers-parent~^~core~^~The spec valid usage text states 'Each element of pCommandBuffers that is a valid handle must have been created, allocated, or retrieved from commandPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-pCommandBuffers-parent)~^~implicit -VALIDATION_ERROR_2860026a~^~Y~^~Unknown~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-pDescriptorSets-00309~^~core~^~The spec valid usage text states 'All submitted commands that refer to any element of pDescriptorSets must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-00309)~^~ -VALIDATION_ERROR_2860026c~^~Y~^~Unknown~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-pDescriptorSets-00310~^~core~^~The spec valid usage text states 'pDescriptorSets must be a valid pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-00310)~^~ -VALIDATION_ERROR_2860026e~^~N~^~Unknown~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-pDescriptorSets-00311~^~core~^~The spec valid usage text states 'Each valid handle in pDescriptorSets must have been allocated from descriptorPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-00311)~^~ -VALIDATION_ERROR_28600270~^~Y~^~FreeDescriptorFromOneShotPool~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-descriptorPool-00312~^~core~^~The spec valid usage text states 'descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorPool-00312)~^~ -VALIDATION_ERROR_28604601~^~Y~^~None~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-descriptorPool-parameter~^~core~^~The spec valid usage text states 'descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorPool-parameter)~^~implicit -VALIDATION_ERROR_28604607~^~Y~^~Unknown~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-descriptorPool-parent~^~core~^~The spec valid usage text states 'descriptorPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorPool-parent)~^~implicit -VALIDATION_ERROR_28604a1b~^~N~^~Unknown~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength~^~core~^~The spec valid usage text states 'descriptorSetCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength)~^~implicit -VALIDATION_ERROR_28605601~^~Y~^~None~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-device-parameter)~^~implicit -VALIDATION_ERROR_28613007~^~Y~^~Unknown~^~vkFreeDescriptorSets~^~VUID-vkFreeDescriptorSets-pDescriptorSets-parent~^~core~^~The spec valid usage text states 'Each element of pDescriptorSets that is a valid handle must have been created, allocated, or retrieved from descriptorPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-parent)~^~implicit -VALIDATION_ERROR_2880054a~^~Y~^~None~^~vkFreeMemory~^~VUID-vkFreeMemory-memory-00677~^~core~^~The spec valid usage text states 'All submitted commands that refer to memory (via images or buffers) must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-memory-00677)~^~ -VALIDATION_ERROR_28805601~^~Y~^~None~^~vkFreeMemory~^~VUID-vkFreeMemory-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-device-parameter)~^~implicit -VALIDATION_ERROR_2880c601~^~Y~^~VertexBufferInvalid~^~vkFreeMemory~^~VUID-vkFreeMemory-memory-parameter~^~core~^~The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-memory-parameter)~^~implicit -VALIDATION_ERROR_2880c607~^~Y~^~Unknown~^~vkFreeMemory~^~VUID-vkFreeMemory-memory-parent~^~core~^~The spec valid usage text states 'If memory is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-memory-parent)~^~implicit -VALIDATION_ERROR_2880ec01~^~N~^~Unknown~^~vkFreeMemory~^~VUID-vkFreeMemory-pAllocator-parameter~^~core~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_28a01a01~^~Y~^~None~^~vkGetBufferMemoryRequirements~^~VUID-vkGetBufferMemoryRequirements-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-buffer-parameter)~^~implicit -VALIDATION_ERROR_28a01a07~^~Y~^~Unknown~^~vkGetBufferMemoryRequirements~^~VUID-vkGetBufferMemoryRequirements-buffer-parent~^~core~^~The spec valid usage text states 'buffer must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-buffer-parent)~^~implicit -VALIDATION_ERROR_28a05601~^~Y~^~None~^~vkGetBufferMemoryRequirements~^~VUID-vkGetBufferMemoryRequirements-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-device-parameter)~^~implicit -VALIDATION_ERROR_28a1b401~^~Y~^~Unknown~^~vkGetBufferMemoryRequirements~^~VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter~^~core~^~The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter)~^~implicit -VALIDATION_ERROR_28c00566~^~N~^~Unknown~^~vkGetDeviceGroupPeerMemoryFeatures~^~VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'heapIndex must be less than memoryHeapCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691)~^~ -VALIDATION_ERROR_28c00568~^~N~^~Unknown~^~vkGetDeviceGroupPeerMemoryFeatures~^~VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'localDeviceIndex must be a valid device index' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692)~^~ -VALIDATION_ERROR_28c0056a~^~N~^~Unknown~^~vkGetDeviceGroupPeerMemoryFeatures~^~VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'remoteDeviceIndex must be a valid device index' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693)~^~ -VALIDATION_ERROR_28c0056c~^~N~^~Unknown~^~vkGetDeviceGroupPeerMemoryFeatures~^~VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'localDeviceIndex must not equal remoteDeviceIndex' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694)~^~ -VALIDATION_ERROR_28c05601~^~Y~^~Unknown~^~vkGetDeviceGroupPeerMemoryFeatures~^~VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter)~^~implicit -VALIDATION_ERROR_28c1d401~^~Y~^~Unknown~^~vkGetDeviceGroupPeerMemoryFeatures~^~VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pPeerMemoryFeatures must be a valid pointer to a VkPeerMemoryFeatureFlags value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter)~^~implicit -VALIDATION_ERROR_28c1d403~^~N~^~Unknown~^~vkGetDeviceGroupPeerMemoryFeatures~^~VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-requiredbitmask~^~(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pPeerMemoryFeatures must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-requiredbitmask)~^~implicit -VALIDATION_ERROR_28e05601~^~Y~^~Unknown~^~vkGetDeviceGroupPresentCapabilitiesKHR~^~VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter)~^~implicit -VALIDATION_ERROR_28e13c01~^~N~^~Unknown~^~vkGetDeviceGroupPresentCapabilitiesKHR~^~VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pDeviceGroupPresentCapabilities must be a valid pointer to a VkDeviceGroupPresentCapabilitiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter)~^~implicit -VALIDATION_ERROR_29000009~^~Y~^~None~^~vkGetDeviceGroupSurfacePresentModesKHR~^~VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent)~^~implicit -VALIDATION_ERROR_29005601~^~Y~^~Unknown~^~vkGetDeviceGroupSurfacePresentModesKHR~^~VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter)~^~implicit -VALIDATION_ERROR_2901be01~^~N~^~Unknown~^~vkGetDeviceGroupSurfacePresentModesKHR~^~VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter)~^~implicit -VALIDATION_ERROR_2902ec01~^~Y~^~Unknown~^~vkGetDeviceGroupSurfacePresentModesKHR~^~VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter)~^~implicit -VALIDATION_ERROR_29200564~^~N~^~Unknown~^~vkGetDeviceMemoryCommitment~^~VUID-vkGetDeviceMemoryCommitment-memory-00690~^~core~^~The spec valid usage text states 'memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-memory-00690)~^~ -VALIDATION_ERROR_29205601~^~Y~^~None~^~vkGetDeviceMemoryCommitment~^~VUID-vkGetDeviceMemoryCommitment-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-device-parameter)~^~implicit -VALIDATION_ERROR_2920c601~^~Y~^~None~^~vkGetDeviceMemoryCommitment~^~VUID-vkGetDeviceMemoryCommitment-memory-parameter~^~core~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-memory-parameter)~^~implicit -VALIDATION_ERROR_2920c607~^~Y~^~Unknown~^~vkGetDeviceMemoryCommitment~^~VUID-vkGetDeviceMemoryCommitment-memory-parent~^~core~^~The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-memory-parent)~^~implicit -VALIDATION_ERROR_29211801~^~Y~^~Unknown~^~vkGetDeviceMemoryCommitment~^~VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter~^~core~^~The spec valid usage text states 'pCommittedMemoryInBytes must be a valid pointer to a VkDeviceSize value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter)~^~implicit -VALIDATION_ERROR_29405601~^~N~^~Unknown~^~vkGetDeviceProcAddr~^~VUID-vkGetDeviceProcAddr-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceProcAddr-device-parameter)~^~implicit -VALIDATION_ERROR_2941c001~^~N~^~Unknown~^~vkGetDeviceProcAddr~^~VUID-vkGetDeviceProcAddr-pName-parameter~^~core~^~The spec valid usage text states 'pName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceProcAddr-pName-parameter)~^~implicit, The loader uses strcmp to dispatch and can fail to dispatch when name is not null-terminated. i.e. Validation layers are never called. -VALIDATION_ERROR_29600300~^~Y~^~Unknown~^~vkGetDeviceQueue~^~VUID-vkGetDeviceQueue-queueFamilyIndex-00384~^~core~^~The spec valid usage text states 'queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-queueFamilyIndex-00384)~^~ -VALIDATION_ERROR_29600302~^~Y~^~Unknown~^~vkGetDeviceQueue~^~VUID-vkGetDeviceQueue-queueIndex-00385~^~core~^~The spec valid usage text states 'queueIndex must be less than the number of queues created for the specified queue family index when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-queueIndex-00385)~^~ -VALIDATION_ERROR_29600e62~^~N~^~None~^~vkGetDeviceQueue~^~VUID-vkGetDeviceQueue-flags-01841~^~core~^~The spec valid usage text states 'VkDeviceQueueCreateInfo::flags must have been set to zero when device was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-flags-01841)~^~ -VALIDATION_ERROR_29605601~^~Y~^~None~^~vkGetDeviceQueue~^~VUID-vkGetDeviceQueue-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-device-parameter)~^~implicit -VALIDATION_ERROR_2961fc01~^~Y~^~Unknown~^~vkGetDeviceQueue~^~VUID-vkGetDeviceQueue-pQueue-parameter~^~core~^~The spec valid usage text states 'pQueue must be a valid pointer to a VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-pQueue-parameter)~^~implicit -VALIDATION_ERROR_29806001~^~Y~^~Unknown~^~vkGetDisplayModePropertiesKHR~^~VUID-vkGetDisplayModePropertiesKHR-display-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-display-parameter)~^~implicit -VALIDATION_ERROR_2981f401~^~Y~^~Unknown~^~vkGetDisplayModePropertiesKHR~^~VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModePropertiesKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2981f601~^~N~^~Unknown~^~vkGetDisplayModePropertiesKHR~^~VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_29827a01~^~Y~^~Unknown~^~vkGetDisplayModePropertiesKHR~^~VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_29a0ce01~^~Y~^~Unknown~^~vkGetDisplayPlaneCapabilitiesKHR~^~VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'mode must be a valid VkDisplayModeKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter)~^~implicit -VALIDATION_ERROR_29a10a01~^~Y~^~Unknown~^~vkGetDisplayPlaneCapabilitiesKHR~^~VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilitiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter)~^~implicit -VALIDATION_ERROR_29a27a01~^~Y~^~Unknown~^~vkGetDisplayPlaneCapabilitiesKHR~^~VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_29c009c2~^~Y~^~Unknown~^~vkGetDisplayPlaneSupportedDisplaysKHR~^~VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249)~^~ -VALIDATION_ERROR_29c14a01~^~N~^~Unknown~^~vkGetDisplayPlaneSupportedDisplaysKHR~^~VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pDisplayCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter)~^~implicit -VALIDATION_ERROR_29c15201~^~Y~^~Unknown~^~vkGetDisplayPlaneSupportedDisplaysKHR~^~VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If the value referenced by pDisplayCount is not 0, and pDisplays is not NULL, pDisplays must be a valid pointer to an array of pDisplayCount VkDisplayKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter)~^~implicit -VALIDATION_ERROR_29c27a01~^~Y~^~Unknown~^~vkGetDisplayPlaneSupportedDisplaysKHR~^~VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_29e05601~^~Y~^~None~^~vkGetEventStatus~^~VUID-vkGetEventStatus-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetEventStatus-device-parameter)~^~implicit -VALIDATION_ERROR_29e07e01~^~Y~^~None~^~vkGetEventStatus~^~VUID-vkGetEventStatus-event-parameter~^~core~^~The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetEventStatus-event-parameter)~^~implicit -VALIDATION_ERROR_29e07e07~^~Y~^~Unknown~^~vkGetEventStatus~^~VUID-vkGetEventStatus-event-parent~^~core~^~The spec valid usage text states 'event must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetEventStatus-event-parent)~^~implicit -VALIDATION_ERROR_2a005601~^~Y~^~None~^~vkGetFenceStatus~^~VUID-vkGetFenceStatus-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceStatus-device-parameter)~^~implicit -VALIDATION_ERROR_2a008801~^~Y~^~None~^~vkGetFenceStatus~^~VUID-vkGetFenceStatus-fence-parameter~^~core~^~The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceStatus-fence-parameter)~^~implicit -VALIDATION_ERROR_2a008807~^~Y~^~Unknown~^~vkGetFenceStatus~^~VUID-vkGetFenceStatus-fence-parent~^~core~^~The spec valid usage text states 'fence must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceStatus-fence-parent)~^~implicit -VALIDATION_ERROR_2a200c68~^~N~^~None~^~vkGetImageMemoryRequirements~^~VUID-vkGetImageMemoryRequirements-image-01588~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements-image-01588)~^~ -VALIDATION_ERROR_2a205601~^~Y~^~None~^~vkGetImageMemoryRequirements~^~VUID-vkGetImageMemoryRequirements-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-device-parameter)~^~implicit -VALIDATION_ERROR_2a20a001~^~Y~^~CreateUnknownObject~^~vkGetImageMemoryRequirements~^~VUID-vkGetImageMemoryRequirements-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-image-parameter)~^~implicit -VALIDATION_ERROR_2a20a007~^~Y~^~Unknown~^~vkGetImageMemoryRequirements~^~VUID-vkGetImageMemoryRequirements-image-parent~^~core~^~The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-image-parent)~^~implicit -VALIDATION_ERROR_2a21b401~^~Y~^~Unknown~^~vkGetImageMemoryRequirements~^~VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter~^~core~^~The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter)~^~implicit -VALIDATION_ERROR_2a405601~^~Y~^~None~^~vkGetImageSparseMemoryRequirements~^~VUID-vkGetImageSparseMemoryRequirements-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-device-parameter)~^~implicit -VALIDATION_ERROR_2a40a001~^~Y~^~None~^~vkGetImageSparseMemoryRequirements~^~VUID-vkGetImageSparseMemoryRequirements-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-image-parameter)~^~implicit -VALIDATION_ERROR_2a40a007~^~Y~^~Unknown~^~vkGetImageSparseMemoryRequirements~^~VUID-vkGetImageSparseMemoryRequirements-image-parent~^~core~^~The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-image-parent)~^~implicit -VALIDATION_ERROR_2a423601~^~N~^~Unknown~^~vkGetImageSparseMemoryRequirements~^~VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirementCount-parameter~^~core~^~The spec valid usage text states 'pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirementCount-parameter)~^~implicit -VALIDATION_ERROR_2a423801~^~Y~^~Unknown~^~vkGetImageSparseMemoryRequirements~^~VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirements-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirements-parameter)~^~implicit -VALIDATION_ERROR_2a6007c8~^~Y~^~Unknown~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-image-00996~^~core~^~The spec valid usage text states 'image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-00996)~^~ -VALIDATION_ERROR_2a6007ca~^~Y~^~Unknown~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-aspectMask-00997~^~core~^~The spec valid usage text states 'The aspectMask member of pSubresource must only have a single bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-aspectMask-00997)~^~ -VALIDATION_ERROR_2a600c5a~^~Y~^~MultiplaneImageLayoutBadAspectFlags~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-format-01581~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the format of image is a multi-planar format with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSubresourceLayout-format-01581)~^~ -VALIDATION_ERROR_2a600c5c~^~Y~^~MultiplaneImageLayoutBadAspectFlags~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-format-01582~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the format of image is a multi-planar format with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSubresourceLayout-format-01582)~^~ -VALIDATION_ERROR_2a600d68~^~Y~^~ExerciseGetImageSubresourceLayout~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-mipLevel-01716~^~core~^~The spec valid usage text states 'The mipLevel member of pSubresource must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-mipLevel-01716)~^~ -VALIDATION_ERROR_2a600d6a~^~Y~^~ExerciseGetImageSubresourceLayout~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-arrayLayer-01717~^~core~^~The spec valid usage text states 'The arrayLayer member of pSubresource must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-arrayLayer-01717)~^~ -VALIDATION_ERROR_2a600ece~^~N~^~None~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-image-01895~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-01895)~^~ -VALIDATION_ERROR_2a605601~^~Y~^~None~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-device-parameter)~^~implicit -VALIDATION_ERROR_2a60a001~^~Y~^~None~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-parameter)~^~implicit -VALIDATION_ERROR_2a60a007~^~Y~^~Unknown~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-image-parent~^~core~^~The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-parent)~^~implicit -VALIDATION_ERROR_2a61a201~^~Y~^~Unknown~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-pLayout-parameter~^~core~^~The spec valid usage text states 'pLayout must be a valid pointer to a VkSubresourceLayout structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-pLayout-parameter)~^~implicit -VALIDATION_ERROR_2a624401~^~Y~^~Unknown~^~vkGetImageSubresourceLayout~^~VUID-vkGetImageSubresourceLayout-pSubresource-parameter~^~core~^~The spec valid usage text states 'pSubresource must be a valid pointer to a valid VkImageSubresource structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-pSubresource-parameter)~^~implicit -VALIDATION_ERROR_2a80bc01~^~N~^~Unknown~^~vkGetInstanceProcAddr~^~VUID-vkGetInstanceProcAddr-instance-parameter~^~core~^~The spec valid usage text states 'If instance is not NULL, instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetInstanceProcAddr-instance-parameter)~^~implicit, This can't be validated in a layer. Validation would have to occur in a loader. -VALIDATION_ERROR_2a81c001~^~N~^~Unknown~^~vkGetInstanceProcAddr~^~VUID-vkGetInstanceProcAddr-pName-parameter~^~core~^~The spec valid usage text states 'pName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetInstanceProcAddr-pName-parameter)~^~implicit, The loader uses strcmp to dispatch and can fail to dispatch when name is not null-terminated. i.e. Validation layers are never called. -VALIDATION_ERROR_2aa05601~^~Y~^~Unknown~^~vkGetMemoryFdKHR~^~VUID-vkGetMemoryFdKHR-device-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdKHR-device-parameter)~^~implicit -VALIDATION_ERROR_2aa16c01~^~Y~^~Unknown~^~vkGetMemoryFdKHR~^~VUID-vkGetMemoryFdKHR-pFd-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'pFd must be a valid pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdKHR-pFd-parameter)~^~implicit -VALIDATION_ERROR_2aa39e01~^~N~^~None~^~vkGetMemoryFdKHR~^~VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'pGetFdInfo must be a valid pointer to a valid VkMemoryGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter)~^~implicit -VALIDATION_ERROR_2ac00542~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-vkGetMemoryFdPropertiesKHR-fd-00673~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'fd must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-fd-00673)~^~ -VALIDATION_ERROR_2ac00544~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-vkGetMemoryFdPropertiesKHR-handleType-00674~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-handleType-00674)~^~ -VALIDATION_ERROR_2ac05601~^~Y~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-vkGetMemoryFdPropertiesKHR-device-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-device-parameter)~^~implicit -VALIDATION_ERROR_2ac09c01~^~Y~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_2ac1ae01~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'pMemoryFdProperties must be a valid pointer to a VkMemoryFdPropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter)~^~implicit -VALIDATION_ERROR_2ae05601~^~Y~^~Unknown~^~vkGetMemoryWin32HandleKHR~^~VUID-vkGetMemoryWin32HandleKHR-device-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-device-parameter)~^~implicit -VALIDATION_ERROR_2ae17c01~^~Y~^~Unknown~^~vkGetMemoryWin32HandleKHR~^~VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter)~^~implicit -VALIDATION_ERROR_2ae3a001~^~N~^~None~^~vkGetMemoryWin32HandleKHR~^~VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'pGetWin32HandleInfo must be a valid pointer to a valid VkMemoryGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter)~^~implicit -VALIDATION_ERROR_2b000a5c~^~N~^~Unknown~^~vkGetMemoryWin32HandleNV~^~VUID-vkGetMemoryWin32HandleNV-handleType-01326~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-01326)~^~ -VALIDATION_ERROR_2b005601~^~Y~^~None~^~vkGetMemoryWin32HandleNV~^~VUID-vkGetMemoryWin32HandleNV-device-parameter~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-device-parameter)~^~implicit -VALIDATION_ERROR_2b009c01~^~N~^~Unknown~^~vkGetMemoryWin32HandleNV~^~VUID-vkGetMemoryWin32HandleNV-handleType-parameter~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-parameter)~^~implicit -VALIDATION_ERROR_2b009c03~^~Y~^~Unknown~^~vkGetMemoryWin32HandleNV~^~VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'handleType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask)~^~implicit -VALIDATION_ERROR_2b00c601~^~Y~^~None~^~vkGetMemoryWin32HandleNV~^~VUID-vkGetMemoryWin32HandleNV-memory-parameter~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-memory-parameter)~^~implicit -VALIDATION_ERROR_2b00c607~^~Y~^~Unknown~^~vkGetMemoryWin32HandleNV~^~VUID-vkGetMemoryWin32HandleNV-memory-parent~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-memory-parent)~^~implicit -VALIDATION_ERROR_2b017c01~^~Y~^~Unknown~^~vkGetMemoryWin32HandleNV~^~VUID-vkGetMemoryWin32HandleNV-pHandle-parameter~^~(VK_NV_external_memory_win32)~^~The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-pHandle-parameter)~^~implicit -VALIDATION_ERROR_2b200532~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'handle must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665)~^~ -VALIDATION_ERROR_2b200534~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'handleType must not be one of the handle types defined as opaque.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666)~^~ -VALIDATION_ERROR_2b205601~^~Y~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter)~^~implicit -VALIDATION_ERROR_2b209c01~^~Y~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_2b21b601~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'pMemoryWin32HandleProperties must be a valid pointer to a VkMemoryWin32HandlePropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter)~^~implicit -VALIDATION_ERROR_2b400009~^~Y~^~None~^~vkGetPastPresentationTimingGOOGLE~^~VUID-vkGetPastPresentationTimingGOOGLE-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-commonparent)~^~implicit -VALIDATION_ERROR_2b405601~^~Y~^~Unknown~^~vkGetPastPresentationTimingGOOGLE~^~VUID-vkGetPastPresentationTimingGOOGLE-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-device-parameter)~^~implicit -VALIDATION_ERROR_2b41ec01~^~N~^~Unknown~^~vkGetPastPresentationTimingGOOGLE~^~VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'pPresentationTimingCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter)~^~implicit -VALIDATION_ERROR_2b41ee01~^~Y~^~Unknown~^~vkGetPastPresentationTimingGOOGLE~^~VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'If the value referenced by pPresentationTimingCount is not 0, and pPresentationTimings is not NULL, pPresentationTimings must be a valid pointer to an array of pPresentationTimingCount VkPastPresentationTimingGOOGLE structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter)~^~implicit -VALIDATION_ERROR_2b42f001~^~Y~^~Unknown~^~vkGetPastPresentationTimingGOOGLE~^~VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter)~^~implicit -VALIDATION_ERROR_2b61f401~^~Y~^~Unknown~^~vkGetPhysicalDeviceDisplayPlanePropertiesKHR~^~VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlanePropertiesKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2b61f601~^~N~^~Unknown~^~vkGetPhysicalDeviceDisplayPlanePropertiesKHR~^~VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_2b627a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceDisplayPlanePropertiesKHR~^~VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2b81f401~^~Y~^~Unknown~^~vkGetPhysicalDeviceDisplayPropertiesKHR~^~VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2b81f601~^~N~^~Unknown~^~vkGetPhysicalDeviceDisplayPropertiesKHR~^~VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_2b827a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceDisplayPropertiesKHR~^~VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ba16201~^~N~^~Unknown~^~vkGetPhysicalDeviceExternalBufferProperties~^~VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'pExternalBufferInfo must be a valid pointer to a valid VkPhysicalDeviceExternalBufferInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter)~^~implicit -VALIDATION_ERROR_2ba16401~^~N~^~Unknown~^~vkGetPhysicalDeviceExternalBufferProperties~^~VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'pExternalBufferProperties must be a valid pointer to a VkExternalBufferProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter)~^~implicit -VALIDATION_ERROR_2ba27a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalBufferProperties~^~VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2bc08201~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'externalHandleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter)~^~implicit -VALIDATION_ERROR_2bc09001~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_2bc09201~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter)~^~implicit -VALIDATION_ERROR_2bc16601~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'pExternalImageFormatProperties must be a valid pointer to a VkExternalImageFormatPropertiesNV structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter)~^~implicit -VALIDATION_ERROR_2bc27a01~^~Y~^~None~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2bc2fa01~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter)~^~implicit -VALIDATION_ERROR_2bc30401~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter)~^~implicit -VALIDATION_ERROR_2bc30601~^~N~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter)~^~implicit -VALIDATION_ERROR_2bc30603~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalImageFormatPropertiesNV~^~VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask~^~(VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_2be16801~^~N~^~Unknown~^~vkGetPhysicalDeviceExternalSemaphoreProperties~^~VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'pExternalSemaphoreInfo must be a valid pointer to a valid VkPhysicalDeviceExternalSemaphoreInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter)~^~implicit -VALIDATION_ERROR_2be16a01~^~N~^~Unknown~^~vkGetPhysicalDeviceExternalSemaphoreProperties~^~VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'pExternalSemaphoreProperties must be a valid pointer to a VkExternalSemaphoreProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter)~^~implicit -VALIDATION_ERROR_2be27a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceExternalSemaphoreProperties~^~VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2c016e01~^~Y~^~None~^~vkGetPhysicalDeviceFeatures~^~VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter~^~core~^~The spec valid usage text states 'pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter)~^~implicit -VALIDATION_ERROR_2c027a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceFeatures~^~VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2c216e01~^~N~^~Unknown~^~vkGetPhysicalDeviceFeatures2~^~VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter)~^~implicit -VALIDATION_ERROR_2c227a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceFeatures2~^~VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2c409201~^~Y~^~Unknown~^~vkGetPhysicalDeviceFormatProperties~^~VUID-vkGetPhysicalDeviceFormatProperties-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties-format-parameter)~^~implicit -VALIDATION_ERROR_2c417601~^~Y~^~Unknown~^~vkGetPhysicalDeviceFormatProperties~^~VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter~^~core~^~The spec valid usage text states 'pFormatProperties must be a valid pointer to a VkFormatProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter)~^~implicit -VALIDATION_ERROR_2c427a01~^~Y~^~None~^~vkGetPhysicalDeviceFormatProperties~^~VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2c609201~^~Y~^~Unknown~^~vkGetPhysicalDeviceFormatProperties2~^~VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter)~^~implicit -VALIDATION_ERROR_2c617601~^~N~^~Unknown~^~vkGetPhysicalDeviceFormatProperties2~^~VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pFormatProperties must be a valid pointer to a VkFormatProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter)~^~implicit -VALIDATION_ERROR_2c627a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceFormatProperties2~^~VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2c816e01~^~N~^~Unknown~^~vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX~^~VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pFeatures-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pFeatures must be a valid pointer to a VkDeviceGeneratedCommandsFeaturesNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pFeatures-parameter)~^~implicit -VALIDATION_ERROR_2c81a401~^~N~^~Unknown~^~vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX~^~VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pLimits-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pLimits must be a valid pointer to a VkDeviceGeneratedCommandsLimitsNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pLimits-parameter)~^~implicit -VALIDATION_ERROR_2c827a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX~^~VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ca09001~^~Y~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_2ca09201~^~Y~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter)~^~implicit -VALIDATION_ERROR_2ca18401~^~Y~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter~^~core~^~The spec valid usage text states 'pImageFormatProperties must be a valid pointer to a VkImageFormatProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter)~^~implicit -VALIDATION_ERROR_2ca27a01~^~Y~^~None~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ca2fa01~^~Y~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter~^~core~^~The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter)~^~implicit -VALIDATION_ERROR_2ca30401~^~Y~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter~^~core~^~The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter)~^~implicit -VALIDATION_ERROR_2ca30601~^~N~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter~^~core~^~The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter)~^~implicit -VALIDATION_ERROR_2ca30603~^~Y~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties~^~VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask~^~core~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_2cc00e98~^~N~^~None~^~vkGetPhysicalDeviceImageFormatProperties2~^~VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the pNext chain of pImageFormatProperties contains an instance of VkAndroidHardwareBufferUsageANDROID, the pNext chain of pImageFormatInfo must contain an instance of VkPhysicalDeviceExternalImageFormatInfo with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868)~^~ -VALIDATION_ERROR_2cc18201~^~N~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties2~^~VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pImageFormatInfo must be a valid pointer to a valid VkPhysicalDeviceImageFormatInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter)~^~implicit -VALIDATION_ERROR_2cc18401~^~N~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties2~^~VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pImageFormatProperties must be a valid pointer to a VkImageFormatProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter)~^~implicit -VALIDATION_ERROR_2cc27a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceImageFormatProperties2~^~VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ce1b001~^~Y~^~Unknown~^~vkGetPhysicalDeviceMemoryProperties~^~VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter~^~core~^~The spec valid usage text states 'pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter)~^~implicit -VALIDATION_ERROR_2ce27a01~^~Y~^~None~^~vkGetPhysicalDeviceMemoryProperties~^~VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2d01b001~^~N~^~Unknown~^~vkGetPhysicalDeviceMemoryProperties2~^~VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter)~^~implicit -VALIDATION_ERROR_2d027a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceMemoryProperties2~^~VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2d2009e2~^~Y~^~Unknown~^~vkGetPhysicalDeviceMirPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-queueFamilyIndex-01265~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-queueFamilyIndex-01265)~^~ -VALIDATION_ERROR_2d203001~^~Y~^~Unknown~^~vkGetPhysicalDeviceMirPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-connection-parameter~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'connection must be a valid pointer to a MirConnection value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-connection-parameter)~^~implicit -VALIDATION_ERROR_2d227a01~^~Y~^~None~^~vkGetPhysicalDeviceMirPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_mir_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2d400009~^~Y~^~None~^~vkGetPhysicalDevicePresentRectanglesKHR~^~VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent)~^~implicit -VALIDATION_ERROR_2d420a01~^~N~^~Unknown~^~vkGetPhysicalDevicePresentRectanglesKHR~^~VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pRectCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter)~^~implicit -VALIDATION_ERROR_2d420e01~^~Y~^~Unknown~^~vkGetPhysicalDevicePresentRectanglesKHR~^~VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter)~^~implicit -VALIDATION_ERROR_2d427a01~^~Y~^~Unknown~^~vkGetPhysicalDevicePresentRectanglesKHR~^~VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2d42ec01~^~Y~^~Unknown~^~vkGetPhysicalDevicePresentRectanglesKHR~^~VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter)~^~implicit -VALIDATION_ERROR_2d61f401~^~Y~^~Unknown~^~vkGetPhysicalDeviceProperties~^~VUID-vkGetPhysicalDeviceProperties-pProperties-parameter~^~core~^~The spec valid usage text states 'pProperties must be a valid pointer to a VkPhysicalDeviceProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2d627a01~^~Y~^~None~^~vkGetPhysicalDeviceProperties~^~VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2d81f401~^~N~^~Unknown~^~vkGetPhysicalDeviceProperties2~^~VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pProperties must be a valid pointer to a VkPhysicalDeviceProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2d827a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceProperties2~^~VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2da20001~^~Y~^~Unknown~^~vkGetPhysicalDeviceQueueFamilyProperties~^~VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter)~^~implicit -VALIDATION_ERROR_2da20201~^~N~^~Unknown~^~vkGetPhysicalDeviceQueueFamilyProperties~^~VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter~^~core~^~The spec valid usage text states 'pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_2da27a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceQueueFamilyProperties~^~VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2dc20001~^~Y~^~Unknown~^~vkGetPhysicalDeviceQueueFamilyProperties2~^~VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties2 structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter)~^~implicit -VALIDATION_ERROR_2dc20201~^~N~^~Unknown~^~vkGetPhysicalDeviceQueueFamilyProperties2~^~VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_2dc27a01~^~N~^~Unknown~^~vkGetPhysicalDeviceQueueFamilyProperties2~^~VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2de0088c~^~N~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094~^~core~^~The spec valid usage text states 'samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094)~^~ -VALIDATION_ERROR_2de09201~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter)~^~implicit -VALIDATION_ERROR_2de1f401~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2de1f601~^~N~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pPropertyCount-parameter~^~core~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_2de27a01~^~Y~^~None~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter~^~core~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2de2b401~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter~^~core~^~The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter)~^~implicit -VALIDATION_ERROR_2de2fa01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter~^~core~^~The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter)~^~implicit -VALIDATION_ERROR_2de30401~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter~^~core~^~The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter)~^~implicit -VALIDATION_ERROR_2de30601~^~N~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter~^~core~^~The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter)~^~implicit -VALIDATION_ERROR_2de30603~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask~^~core~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_2e017401~^~N~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties2~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pFormatInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pFormatInfo must be a valid pointer to a valid VkPhysicalDeviceSparseImageFormatInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pFormatInfo-parameter)~^~implicit -VALIDATION_ERROR_2e01f401~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties2~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties2 structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pProperties-parameter)~^~implicit -VALIDATION_ERROR_2e01f601~^~N~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties2~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pPropertyCount-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pPropertyCount-parameter)~^~implicit -VALIDATION_ERROR_2e027a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSparseImageFormatProperties2~^~VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2e200009~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceCapabilities2EXT~^~VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent~^~(VK_KHR_surface)+(VK_EXT_display_surface_counter)~^~The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent)~^~implicit -VALIDATION_ERROR_2e224a01~^~N~^~Unknown~^~vkGetPhysicalDeviceSurfaceCapabilities2EXT~^~VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter~^~(VK_KHR_surface)+(VK_EXT_display_surface_counter)~^~The spec valid usage text states 'pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2EXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter)~^~implicit -VALIDATION_ERROR_2e227a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceCapabilities2EXT~^~VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_EXT_display_surface_counter)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2e22ec01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceCapabilities2EXT~^~VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter~^~(VK_KHR_surface)+(VK_EXT_display_surface_counter)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter)~^~implicit -VALIDATION_ERROR_2e424a01~^~N~^~Unknown~^~vkGetPhysicalDeviceSurfaceCapabilities2KHR~^~VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter)~^~implicit -VALIDATION_ERROR_2e425001~^~N~^~Unknown~^~vkGetPhysicalDeviceSurfaceCapabilities2KHR~^~VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter)~^~implicit -VALIDATION_ERROR_2e427a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceCapabilities2KHR~^~VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2e600009~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceCapabilitiesKHR~^~VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent~^~(VK_KHR_surface)~^~The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent)~^~implicit -VALIDATION_ERROR_2e624a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceCapabilitiesKHR~^~VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilitiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter)~^~implicit -VALIDATION_ERROR_2e627a01~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceCapabilitiesKHR~^~VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2e62ec01~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceCapabilitiesKHR~^~VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter)~^~implicit -VALIDATION_ERROR_2e824c01~^~N~^~Unknown~^~vkGetPhysicalDeviceSurfaceFormats2KHR~^~VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'pSurfaceFormatCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter)~^~implicit -VALIDATION_ERROR_2e824e01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceFormats2KHR~^~VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormat2KHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter)~^~implicit -VALIDATION_ERROR_2e825001~^~N~^~Unknown~^~vkGetPhysicalDeviceSurfaceFormats2KHR~^~VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter)~^~implicit -VALIDATION_ERROR_2e827a01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceFormats2KHR~^~VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ea00009~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceFormatsKHR~^~VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent~^~(VK_KHR_surface)~^~The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent)~^~implicit -VALIDATION_ERROR_2ea24c01~^~N~^~Unknown~^~vkGetPhysicalDeviceSurfaceFormatsKHR~^~VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'pSurfaceFormatCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter)~^~implicit -VALIDATION_ERROR_2ea24e01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceFormatsKHR~^~VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormatKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter)~^~implicit -VALIDATION_ERROR_2ea27a01~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceFormatsKHR~^~VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ea2ec01~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceFormatsKHR~^~VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter)~^~implicit -VALIDATION_ERROR_2ec00009~^~Y~^~None~^~vkGetPhysicalDeviceSurfacePresentModesKHR~^~VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent~^~(VK_KHR_surface)~^~The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent)~^~implicit -VALIDATION_ERROR_2ec1e801~^~N~^~Unknown~^~vkGetPhysicalDeviceSurfacePresentModesKHR~^~VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'pPresentModeCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter)~^~implicit -VALIDATION_ERROR_2ec1ea01~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfacePresentModesKHR~^~VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter)~^~implicit -VALIDATION_ERROR_2ec27a01~^~Y~^~None~^~vkGetPhysicalDeviceSurfacePresentModesKHR~^~VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ec2ec01~^~Y~^~None~^~vkGetPhysicalDeviceSurfacePresentModesKHR~^~VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter)~^~implicit -VALIDATION_ERROR_2ee00009~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceSupportKHR~^~VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent~^~(VK_KHR_surface)~^~The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent)~^~implicit -VALIDATION_ERROR_2ee009ea~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceSupportKHR~^~VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269~^~(VK_KHR_surface)~^~The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269)~^~ -VALIDATION_ERROR_2ee24601~^~Y~^~Unknown~^~vkGetPhysicalDeviceSurfaceSupportKHR~^~VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'pSupported must be a valid pointer to a VkBool32 value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter)~^~implicit -VALIDATION_ERROR_2ee27a01~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceSupportKHR~^~VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2ee2ec01~^~Y~^~None~^~vkGetPhysicalDeviceSurfaceSupportKHR~^~VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter~^~(VK_KHR_surface)~^~The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter)~^~implicit -VALIDATION_ERROR_2f000a34~^~Y~^~Unknown~^~vkGetPhysicalDeviceWaylandPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306)~^~ -VALIDATION_ERROR_2f006001~^~Y~^~Unknown~^~vkGetPhysicalDeviceWaylandPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-display-parameter~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'display must be a valid pointer to a wl_display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-display-parameter)~^~implicit -VALIDATION_ERROR_2f027a01~^~Y~^~None~^~vkGetPhysicalDeviceWaylandPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_wayland_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2f200a3a~^~Y~^~Unknown~^~vkGetPhysicalDeviceWin32PresentationSupportKHR~^~VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309)~^~ -VALIDATION_ERROR_2f227a01~^~Y~^~None~^~vkGetPhysicalDeviceWin32PresentationSupportKHR~^~VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_win32_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2f400a40~^~Y~^~Unknown~^~vkGetPhysicalDeviceXcbPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312)~^~ -VALIDATION_ERROR_2f403001~^~Y~^~Unknown~^~vkGetPhysicalDeviceXcbPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-connection-parameter~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'connection must be a valid pointer to a xcb_connection_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-connection-parameter)~^~implicit -VALIDATION_ERROR_2f427a01~^~Y~^~None~^~vkGetPhysicalDeviceXcbPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_xcb_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2f600a46~^~Y~^~Unknown~^~vkGetPhysicalDeviceXlibPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315)~^~ -VALIDATION_ERROR_2f606601~^~Y~^~Unknown~^~vkGetPhysicalDeviceXlibPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-dpy-parameter~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'dpy must be a valid pointer to a Display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-dpy-parameter)~^~implicit -VALIDATION_ERROR_2f627a01~^~Y~^~None~^~vkGetPhysicalDeviceXlibPresentationSupportKHR~^~VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_xlib_surface)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2f805601~^~Y~^~None~^~vkGetPipelineCacheData~^~VUID-vkGetPipelineCacheData-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-device-parameter)~^~implicit -VALIDATION_ERROR_2f812201~^~Y~^~Unknown~^~vkGetPipelineCacheData~^~VUID-vkGetPipelineCacheData-pData-parameter~^~core~^~The spec valid usage text states 'If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pData-parameter)~^~implicit -VALIDATION_ERROR_2f812401~^~N~^~Unknown~^~vkGetPipelineCacheData~^~VUID-vkGetPipelineCacheData-pDataSize-parameter~^~core~^~The spec valid usage text states 'pDataSize must be a valid pointer to a size_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pDataSize-parameter)~^~implicit -VALIDATION_ERROR_2f828001~^~Y~^~None~^~vkGetPipelineCacheData~^~VUID-vkGetPipelineCacheData-pipelineCache-parameter~^~core~^~The spec valid usage text states 'pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pipelineCache-parameter)~^~implicit -VALIDATION_ERROR_2f828007~^~Y~^~Unknown~^~vkGetPipelineCacheData~^~VUID-vkGetPipelineCacheData-pipelineCache-parent~^~core~^~The spec valid usage text states 'pipelineCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pipelineCache-parent)~^~implicit -VALIDATION_ERROR_2fa0065a~^~N~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-firstQuery-00813~^~core~^~The spec valid usage text states 'firstQuery must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-firstQuery-00813)~^~ -VALIDATION_ERROR_2fa0065c~^~N~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-flags-00814~^~core~^~The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is not set in flags then pData and stride must be multiples of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-flags-00814)~^~ -VALIDATION_ERROR_2fa0065e~^~N~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-flags-00815~^~core~^~The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-flags-00815)~^~ -VALIDATION_ERROR_2fa00660~^~N~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-firstQuery-00816~^~core~^~The spec valid usage text states 'The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-firstQuery-00816)~^~ -VALIDATION_ERROR_2fa00662~^~N~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-dataSize-00817~^~core~^~The spec valid usage text states 'dataSize must be large enough to contain the result of each query, as described here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-dataSize-00817)~^~ -VALIDATION_ERROR_2fa00664~^~Y~^~QueryPoolInUseDestroyedSignaled~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-queryType-00818~^~core~^~The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-queryType-00818)~^~ -VALIDATION_ERROR_2fa03c1b~^~Y~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-dataSize-arraylength~^~core~^~The spec valid usage text states 'dataSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-dataSize-arraylength)~^~implicit -VALIDATION_ERROR_2fa05601~^~Y~^~None~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-device-parameter)~^~implicit -VALIDATION_ERROR_2fa09001~^~Y~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkQueryResultFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_2fa12201~^~Y~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-pData-parameter~^~core~^~The spec valid usage text states 'pData must be a valid pointer to an array of dataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-pData-parameter)~^~implicit -VALIDATION_ERROR_2fa29801~^~Y~^~None~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-queryPool-parameter~^~core~^~The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-queryPool-parameter)~^~implicit -VALIDATION_ERROR_2fa29807~^~Y~^~Unknown~^~vkGetQueryPoolResults~^~VUID-vkGetQueryPoolResults-queryPool-parent~^~core~^~The spec valid usage text states 'queryPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-queryPool-parent)~^~implicit -VALIDATION_ERROR_2fc06601~^~Y~^~Unknown~^~vkGetRandROutputDisplayEXT~^~VUID-vkGetRandROutputDisplayEXT-dpy-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)~^~The spec valid usage text states 'dpy must be a valid pointer to a Display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRandROutputDisplayEXT-dpy-parameter)~^~implicit -VALIDATION_ERROR_2fc14801~^~Y~^~Unknown~^~vkGetRandROutputDisplayEXT~^~VUID-vkGetRandROutputDisplayEXT-pDisplay-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)~^~The spec valid usage text states 'pDisplay must be a valid pointer to a VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRandROutputDisplayEXT-pDisplay-parameter)~^~implicit -VALIDATION_ERROR_2fc27a01~^~Y~^~Unknown~^~vkGetRandROutputDisplayEXT~^~VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_2fe00009~^~Y~^~None~^~vkGetRefreshCycleDurationGOOGLE~^~VUID-vkGetRefreshCycleDurationGOOGLE-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-commonparent)~^~implicit -VALIDATION_ERROR_2fe05601~^~Y~^~Unknown~^~vkGetRefreshCycleDurationGOOGLE~^~VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter)~^~implicit -VALIDATION_ERROR_2fe15001~^~Y~^~Unknown~^~vkGetRefreshCycleDurationGOOGLE~^~VUID-vkGetRefreshCycleDurationGOOGLE-pDisplayTimingProperties-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'pDisplayTimingProperties must be a valid pointer to a VkRefreshCycleDurationGOOGLE structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-pDisplayTimingProperties-parameter)~^~implicit -VALIDATION_ERROR_2fe2f001~^~Y~^~Unknown~^~vkGetRefreshCycleDurationGOOGLE~^~VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter)~^~implicit -VALIDATION_ERROR_30005601~^~Y~^~None~^~vkGetRenderAreaGranularity~^~VUID-vkGetRenderAreaGranularity-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-device-parameter)~^~implicit -VALIDATION_ERROR_30017a01~^~Y~^~Unknown~^~vkGetRenderAreaGranularity~^~VUID-vkGetRenderAreaGranularity-pGranularity-parameter~^~core~^~The spec valid usage text states 'pGranularity must be a valid pointer to a VkExtent2D structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-pGranularity-parameter)~^~implicit -VALIDATION_ERROR_3002ae01~^~Y~^~None~^~vkGetRenderAreaGranularity~^~VUID-vkGetRenderAreaGranularity-renderPass-parameter~^~core~^~The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-renderPass-parameter)~^~implicit -VALIDATION_ERROR_3002ae07~^~Y~^~Unknown~^~vkGetRenderAreaGranularity~^~VUID-vkGetRenderAreaGranularity-renderPass-parent~^~core~^~The spec valid usage text states 'renderPass must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-renderPass-parent)~^~implicit -VALIDATION_ERROR_30205601~^~Y~^~Unknown~^~vkGetSemaphoreFdKHR~^~VUID-vkGetSemaphoreFdKHR-device-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-device-parameter)~^~implicit -VALIDATION_ERROR_30216c01~^~Y~^~Unknown~^~vkGetSemaphoreFdKHR~^~VUID-vkGetSemaphoreFdKHR-pFd-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'pFd must be a valid pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-pFd-parameter)~^~implicit -VALIDATION_ERROR_30239e01~^~N~^~None~^~vkGetSemaphoreFdKHR~^~VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'pGetFdInfo must be a valid pointer to a valid VkSemaphoreGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter)~^~implicit -VALIDATION_ERROR_30405601~^~Y~^~Unknown~^~vkGetSemaphoreWin32HandleKHR~^~VUID-vkGetSemaphoreWin32HandleKHR-device-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-device-parameter)~^~implicit -VALIDATION_ERROR_30417c01~^~Y~^~Unknown~^~vkGetSemaphoreWin32HandleKHR~^~VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter)~^~implicit -VALIDATION_ERROR_3043a001~^~N~^~None~^~vkGetSemaphoreWin32HandleKHR~^~VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'pGetWin32HandleInfo must be a valid pointer to a valid VkSemaphoreGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter)~^~implicit -VALIDATION_ERROR_30600009~^~Y~^~None~^~vkGetSwapchainCounterEXT~^~VUID-vkGetSwapchainCounterEXT-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-commonparent)~^~implicit -VALIDATION_ERROR_306009ba~^~N~^~Unknown~^~vkGetSwapchainCounterEXT~^~VUID-vkGetSwapchainCounterEXT-swapchain-01245~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'One or more present commands on swapchain must have been processed by the presentation engine.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-swapchain-01245)~^~ -VALIDATION_ERROR_30603601~^~Y~^~Unknown~^~vkGetSwapchainCounterEXT~^~VUID-vkGetSwapchainCounterEXT-counter-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'counter must be a valid VkSurfaceCounterFlagBitsEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-counter-parameter)~^~implicit -VALIDATION_ERROR_30605601~^~Y~^~Unknown~^~vkGetSwapchainCounterEXT~^~VUID-vkGetSwapchainCounterEXT-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-device-parameter)~^~implicit -VALIDATION_ERROR_30611c01~^~Y~^~Unknown~^~vkGetSwapchainCounterEXT~^~VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'pCounterValue must be a valid pointer to a uint64_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter)~^~implicit -VALIDATION_ERROR_3062f001~^~Y~^~Unknown~^~vkGetSwapchainCounterEXT~^~VUID-vkGetSwapchainCounterEXT-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-swapchain-parameter)~^~implicit -VALIDATION_ERROR_30800009~^~N~^~None~^~vkGetSwapchainImagesKHR~^~VUID-vkGetSwapchainImagesKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-commonparent)~^~implicit -VALIDATION_ERROR_30805601~^~Y~^~None~^~vkGetSwapchainImagesKHR~^~VUID-vkGetSwapchainImagesKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-device-parameter)~^~implicit -VALIDATION_ERROR_30825401~^~N~^~Unknown~^~vkGetSwapchainImagesKHR~^~VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'pSwapchainImageCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter)~^~implicit -VALIDATION_ERROR_30825601~^~Y~^~Unknown~^~vkGetSwapchainImagesKHR~^~VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter)~^~implicit -VALIDATION_ERROR_3082f001~^~Y~^~Unknown~^~vkGetSwapchainImagesKHR~^~VUID-vkGetSwapchainImagesKHR-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-swapchain-parameter)~^~implicit -VALIDATION_ERROR_30a00009~^~Y~^~None~^~vkGetSwapchainStatusKHR~^~VUID-vkGetSwapchainStatusKHR-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-commonparent)~^~implicit -VALIDATION_ERROR_30a05601~^~Y~^~Unknown~^~vkGetSwapchainStatusKHR~^~VUID-vkGetSwapchainStatusKHR-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-device-parameter)~^~implicit -VALIDATION_ERROR_30a2f001~^~Y~^~Unknown~^~vkGetSwapchainStatusKHR~^~VUID-vkGetSwapchainStatusKHR-swapchain-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-swapchain-parameter)~^~implicit -VALIDATION_ERROR_30c008ec~^~N~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-vkImportSemaphoreFdKHR-semaphore-01142~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'semaphore must not be associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-semaphore-01142)~^~ -VALIDATION_ERROR_30c05601~^~Y~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-vkImportSemaphoreFdKHR-device-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-device-parameter)~^~implicit -VALIDATION_ERROR_30c18e01~^~N~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'pImportSemaphoreFdInfo must be a valid pointer to a valid VkImportSemaphoreFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter)~^~implicit -VALIDATION_ERROR_30e05601~^~Y~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-vkImportSemaphoreWin32HandleKHR-device-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHR-device-parameter)~^~implicit -VALIDATION_ERROR_30e19001~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'pImportSemaphoreWin32HandleInfo must be a valid pointer to a valid VkImportSemaphoreWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter)~^~implicit -VALIDATION_ERROR_31005601~^~Y~^~None~^~vkInvalidateMappedMemoryRanges~^~VUID-vkInvalidateMappedMemoryRanges-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-device-parameter)~^~implicit -VALIDATION_ERROR_3100c81b~^~N~^~Unknown~^~vkInvalidateMappedMemoryRanges~^~VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength~^~core~^~The spec valid usage text states 'memoryRangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength)~^~implicit -VALIDATION_ERROR_3101b201~^~Y~^~Unknown~^~vkInvalidateMappedMemoryRanges~^~VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter~^~core~^~The spec valid usage text states 'pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter)~^~implicit -VALIDATION_ERROR_3120054c~^~N~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-memory-00678~^~core~^~The spec valid usage text states 'memory must not be currently mapped' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-00678)~^~ -VALIDATION_ERROR_3120054e~^~N~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-offset-00679~^~core~^~The spec valid usage text states 'offset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-offset-00679)~^~ -VALIDATION_ERROR_31200550~^~N~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-size-00680~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-size-00680)~^~ -VALIDATION_ERROR_31200552~^~Y~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-size-00681~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of the memory minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-size-00681)~^~ -VALIDATION_ERROR_31200554~^~Y~^~MapMemWithoutHostVisibleBit~^~vkMapMemory~^~VUID-vkMapMemory-memory-00682~^~core~^~The spec valid usage text states 'memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-00682)~^~ -VALIDATION_ERROR_31200556~^~N~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-memory-00683~^~(VK_KHR_device_group)~^~The spec valid usage text states 'memory must not have been allocated with multiple instances.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMapMemory-memory-00683)~^~ -VALIDATION_ERROR_31205601~^~Y~^~None~^~vkMapMemory~^~VUID-vkMapMemory-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-device-parameter)~^~implicit -VALIDATION_ERROR_31209005~^~Y~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_3120c601~^~Y~^~None~^~vkMapMemory~^~VUID-vkMapMemory-memory-parameter~^~core~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-parameter)~^~implicit -VALIDATION_ERROR_3120c607~^~Y~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-memory-parent~^~core~^~The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-parent)~^~implicit -VALIDATION_ERROR_31228c01~^~N~^~Unknown~^~vkMapMemory~^~VUID-vkMapMemory-ppData-parameter~^~core~^~The spec valid usage text states 'ppData must be a valid pointer to a pointer value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-ppData-parameter)~^~implicit -VALIDATION_ERROR_31400604~^~N~^~Unknown~^~vkMergePipelineCaches~^~VUID-vkMergePipelineCaches-dstCache-00770~^~core~^~The spec valid usage text states 'dstCache must not appear in the list of source caches' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-dstCache-00770)~^~ -VALIDATION_ERROR_31405601~^~Y~^~None~^~vkMergePipelineCaches~^~VUID-vkMergePipelineCaches-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-device-parameter)~^~implicit -VALIDATION_ERROR_31406e01~^~Y~^~None~^~vkMergePipelineCaches~^~VUID-vkMergePipelineCaches-dstCache-parameter~^~core~^~The spec valid usage text states 'dstCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-dstCache-parameter)~^~implicit -VALIDATION_ERROR_31406e07~^~Y~^~Unknown~^~vkMergePipelineCaches~^~VUID-vkMergePipelineCaches-dstCache-parent~^~core~^~The spec valid usage text states 'dstCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-dstCache-parent)~^~implicit -VALIDATION_ERROR_31423c01~^~Y~^~Unknown~^~vkMergePipelineCaches~^~VUID-vkMergePipelineCaches-pSrcCaches-parameter~^~core~^~The spec valid usage text states 'pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkPipelineCache handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-pSrcCaches-parameter)~^~implicit -VALIDATION_ERROR_31423c07~^~Y~^~None~^~vkMergePipelineCaches~^~VUID-vkMergePipelineCaches-pSrcCaches-parent~^~core~^~The spec valid usage text states 'Each element of pSrcCaches must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-pSrcCaches-parent)~^~implicit -VALIDATION_ERROR_3142ca1b~^~N~^~Unknown~^~vkMergePipelineCaches~^~VUID-vkMergePipelineCaches-srcCacheCount-arraylength~^~core~^~The spec valid usage text states 'srcCacheCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-srcCacheCount-arraylength)~^~implicit -VALIDATION_ERROR_31600009~^~Y~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-commonparent~^~core~^~The spec valid usage text states 'Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-commonparent)~^~implicit -VALIDATION_ERROR_31600011~^~Y~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-queuetype~^~core~^~The spec valid usage text states 'The queue must support sparse binding operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-queuetype)~^~implicit -VALIDATION_ERROR_316008b2~^~N~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-fence-01113~^~core~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-fence-01113)~^~ -VALIDATION_ERROR_316008b4~^~N~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-fence-01114~^~core~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-fence-01114)~^~ -VALIDATION_ERROR_316008b6~^~N~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-pSignalSemaphores-01115~^~core~^~The spec valid usage text states 'Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pSignalSemaphores-01115)~^~ -VALIDATION_ERROR_316008b8~^~N~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-pWaitSemaphores-01116~^~core~^~The spec valid usage text states 'When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, no other queue must be waiting on the same semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pWaitSemaphores-01116)~^~ -VALIDATION_ERROR_316008ba~^~N~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-pWaitSemaphores-01117~^~core~^~The spec valid usage text states 'All elements of the pWaitSemaphores member of all elements of pBindInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pWaitSemaphores-01117)~^~ -VALIDATION_ERROR_31608801~^~Y~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-fence-parameter~^~core~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-fence-parameter)~^~implicit -VALIDATION_ERROR_3160f801~^~Y~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-pBindInfo-parameter~^~core~^~The spec valid usage text states 'If bindInfoCount is not 0, pBindInfo must be a valid pointer to an array of bindInfoCount valid VkBindSparseInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pBindInfo-parameter)~^~implicit -VALIDATION_ERROR_31629c01~^~Y~^~Unknown~^~vkQueueBindSparse~^~VUID-vkQueueBindSparse-queue-parameter~^~core~^~The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-queue-parameter)~^~implicit -VALIDATION_ERROR_31800a18~^~Y~^~Unknown~^~vkQueuePresentKHR~^~VUID-vkQueuePresentKHR-pSwapchains-01292~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pSwapchains-01292)~^~ -VALIDATION_ERROR_31800a1a~^~N~^~Unknown~^~vkQueuePresentKHR~^~VUID-vkQueuePresentKHR-pSwapchains-01293~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)~^~The spec valid usage text states 'If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pSwapchains-01293)~^~ -VALIDATION_ERROR_31800a1c~^~N~^~Unknown~^~vkQueuePresentKHR~^~VUID-vkQueuePresentKHR-pWaitSemaphores-01294~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, no other queue must be waiting on the same semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pWaitSemaphores-01294)~^~ -VALIDATION_ERROR_31800a1e~^~N~^~Unknown~^~vkQueuePresentKHR~^~VUID-vkQueuePresentKHR-pWaitSemaphores-01295~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pWaitSemaphores-01295)~^~ -VALIDATION_ERROR_3181e601~^~N~^~Unknown~^~vkQueuePresentKHR~^~VUID-vkQueuePresentKHR-pPresentInfo-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pPresentInfo-parameter)~^~implicit -VALIDATION_ERROR_31829c01~^~Y~^~None~^~vkQueuePresentKHR~^~VUID-vkQueuePresentKHR-queue-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)~^~The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-queue-parameter)~^~implicit -VALIDATION_ERROR_31a00009~^~Y~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-commonparent~^~core~^~The spec valid usage text states 'Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-commonparent)~^~implicit -VALIDATION_ERROR_31a0007e~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-fence-00063~^~core~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-fence-00063)~^~ -VALIDATION_ERROR_31a00080~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-fence-00064~^~core~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-fence-00064)~^~ -VALIDATION_ERROR_31a00082~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pCommandBuffers-00065~^~core~^~The spec valid usage text states 'Any calls to vkCmdSetEvent, vkCmdResetEvent or vkCmdWaitEvents that have been recorded into any of the command buffer elements of the pCommandBuffers member of any element of pSubmits, must not reference any VkEvent that is referenced by any of those commands in a command buffer that has been submitted to another queue and is still in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00065)~^~ -VALIDATION_ERROR_31a00084~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pWaitDstStageMask-00066~^~core~^~The spec valid usage text states 'Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the table of supported pipeline stages.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pWaitDstStageMask-00066)~^~ -VALIDATION_ERROR_31a00086~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pSignalSemaphores-00067~^~core~^~The spec valid usage text states 'Each element of the pSignalSemaphores member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pSignalSemaphores-00067)~^~ -VALIDATION_ERROR_31a00088~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pWaitSemaphores-00068~^~core~^~The spec valid usage text states 'When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, no other queue must be waiting on the same semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pWaitSemaphores-00068)~^~ -VALIDATION_ERROR_31a0008a~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pWaitSemaphores-00069~^~core~^~The spec valid usage text states 'All elements of the pWaitSemaphores member of all elements of pSubmits must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pWaitSemaphores-00069)~^~ -VALIDATION_ERROR_31a0008c~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pCommandBuffers-00070~^~core~^~The spec valid usage text states 'Each element of the pCommandBuffers member of each element of pSubmits must be in the pending or executable state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00070)~^~ -VALIDATION_ERROR_31a0008e~^~Y~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pCommandBuffers-00071~^~core~^~The spec valid usage text states 'If any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00071)~^~ -VALIDATION_ERROR_31a00090~^~Y~^~ExecuteUnrecordedSecondaryCB~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pCommandBuffers-00072~^~core~^~The spec valid usage text states 'Any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits must be in the pending or executable state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00072)~^~ -VALIDATION_ERROR_31a00092~^~Y~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pCommandBuffers-00073~^~core~^~The spec valid usage text states 'If any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00073)~^~ -VALIDATION_ERROR_31a00094~^~Y~^~MismatchedQueueFamiliesOnSubmit~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pCommandBuffers-00074~^~core~^~The spec valid usage text states 'Each element of the pCommandBuffers member of each element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00074)~^~ -VALIDATION_ERROR_31a08801~^~Y~^~None~^~vkQueueSubmit~^~VUID-vkQueueSubmit-fence-parameter~^~core~^~The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-fence-parameter)~^~implicit -VALIDATION_ERROR_31a24001~^~Y~^~Unknown~^~vkQueueSubmit~^~VUID-vkQueueSubmit-pSubmits-parameter~^~core~^~The spec valid usage text states 'If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pSubmits-parameter)~^~implicit -VALIDATION_ERROR_31a29c01~^~Y~^~None~^~vkQueueSubmit~^~VUID-vkQueueSubmit-queue-parameter~^~core~^~The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-queue-parameter)~^~implicit -VALIDATION_ERROR_31c29c01~^~Y~^~None~^~vkQueueWaitIdle~^~VUID-vkQueueWaitIdle-queue-parameter~^~core~^~The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueWaitIdle-queue-parameter)~^~implicit -VALIDATION_ERROR_31e05601~^~Y~^~Unknown~^~vkRegisterDeviceEventEXT~^~VUID-vkRegisterDeviceEventEXT-device-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-device-parameter)~^~implicit -VALIDATION_ERROR_31e0ec01~^~N~^~Unknown~^~vkRegisterDeviceEventEXT~^~VUID-vkRegisterDeviceEventEXT-pAllocator-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_31e13a01~^~N~^~Unknown~^~vkRegisterDeviceEventEXT~^~VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'pDeviceEventInfo must be a valid pointer to a valid VkDeviceEventInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter)~^~implicit -VALIDATION_ERROR_31e17001~^~Y~^~Unknown~^~vkRegisterDeviceEventEXT~^~VUID-vkRegisterDeviceEventEXT-pFence-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'pFence must be a valid pointer to a VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-pFence-parameter)~^~implicit -VALIDATION_ERROR_32005601~^~Y~^~Unknown~^~vkRegisterDisplayEventEXT~^~VUID-vkRegisterDisplayEventEXT-device-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-device-parameter)~^~implicit -VALIDATION_ERROR_32006001~^~Y~^~Unknown~^~vkRegisterDisplayEventEXT~^~VUID-vkRegisterDisplayEventEXT-display-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-display-parameter)~^~implicit -VALIDATION_ERROR_3200ec01~^~N~^~Unknown~^~vkRegisterDisplayEventEXT~^~VUID-vkRegisterDisplayEventEXT-pAllocator-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_32014c01~^~N~^~Unknown~^~vkRegisterDisplayEventEXT~^~VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'pDisplayEventInfo must be a valid pointer to a valid VkDisplayEventInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter)~^~implicit -VALIDATION_ERROR_32017001~^~Y~^~Unknown~^~vkRegisterDisplayEventEXT~^~VUID-vkRegisterDisplayEventEXT-pFence-parameter~^~(VK_EXT_display_control)~^~The spec valid usage text states 'pFence must be a valid pointer to a VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-pFence-parameter)~^~implicit -VALIDATION_ERROR_32200aa8~^~N~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-pObjectTableEntry-01364~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The contents of pObjectTableEntry must yield plausible bindings supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectTableEntry-01364)~^~ -VALIDATION_ERROR_32200aaa~^~N~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-pObjectIndices-01365~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'At any pObjectIndices there must not be a registered resource already.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectIndices-01365)~^~ -VALIDATION_ERROR_32200aac~^~N~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-pObjectIndices-01366~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'Any value inside pObjectIndices must be below the appropriate VkObjectTableCreateInfoNVX::pObjectEntryCounts limits provided at objectTable creation time.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectIndices-01366)~^~ -VALIDATION_ERROR_32205601~^~Y~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-device-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-device-parameter)~^~implicit -VALIDATION_ERROR_3220d61b~^~Y~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-objectCount-arraylength~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-objectCount-arraylength)~^~implicit -VALIDATION_ERROR_3220d801~^~Y~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-objectTable-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-objectTable-parameter)~^~implicit -VALIDATION_ERROR_3220d807~^~Y~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-objectTable-parent~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-objectTable-parent)~^~implicit -VALIDATION_ERROR_3221cc01~^~Y~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-pObjectIndices-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pObjectIndices must be a valid pointer to an array of objectCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectIndices-parameter)~^~implicit -VALIDATION_ERROR_32229201~^~Y~^~Unknown~^~vkRegisterObjectsNVX~^~VUID-vkRegisterObjectsNVX-ppObjectTableEntries-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'ppObjectTableEntries must be a valid pointer to an array of objectCount valid VkObjectTableEntryNVX structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-ppObjectTableEntries-parameter)~^~implicit -VALIDATION_ERROR_32406001~^~Y~^~Unknown~^~vkReleaseDisplayEXT~^~VUID-vkReleaseDisplayEXT-display-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)~^~The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkReleaseDisplayEXT-display-parameter)~^~implicit -VALIDATION_ERROR_32427a01~^~Y~^~Unknown~^~vkReleaseDisplayEXT~^~VUID-vkReleaseDisplayEXT-physicalDevice-parameter~^~(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkReleaseDisplayEXT-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_3260005a~^~Y~^~Unknown~^~vkResetCommandBuffer~^~VUID-vkResetCommandBuffer-commandBuffer-00045~^~core~^~The spec valid usage text states 'commandBuffer must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-commandBuffer-00045)~^~ -VALIDATION_ERROR_3260005c~^~Y~^~CommandBufferResetErrors~^~vkResetCommandBuffer~^~VUID-vkResetCommandBuffer-commandBuffer-00046~^~core~^~The spec valid usage text states 'commandBuffer must have been allocated from a pool that was created with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-commandBuffer-00046)~^~ -VALIDATION_ERROR_32602401~^~Y~^~Unknown~^~vkResetCommandBuffer~^~VUID-vkResetCommandBuffer-commandBuffer-parameter~^~core~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_32609001~^~Y~^~Unknown~^~vkResetCommandBuffer~^~VUID-vkResetCommandBuffer-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkCommandBufferResetFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_32800050~^~Y~^~None~^~vkResetCommandPool~^~VUID-vkResetCommandPool-commandPool-00040~^~core~^~The spec valid usage text states 'All VkCommandBuffer objects allocated from commandPool must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-commandPool-00040)~^~ -VALIDATION_ERROR_32802801~^~Y~^~None~^~vkResetCommandPool~^~VUID-vkResetCommandPool-commandPool-parameter~^~core~^~The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-commandPool-parameter)~^~implicit -VALIDATION_ERROR_32802807~^~Y~^~Unknown~^~vkResetCommandPool~^~VUID-vkResetCommandPool-commandPool-parent~^~core~^~The spec valid usage text states 'commandPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-commandPool-parent)~^~implicit -VALIDATION_ERROR_32805601~^~Y~^~None~^~vkResetCommandPool~^~VUID-vkResetCommandPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-device-parameter)~^~implicit -VALIDATION_ERROR_32809001~^~Y~^~Unknown~^~vkResetCommandPool~^~VUID-vkResetCommandPool-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkCommandPoolResetFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_32a00272~^~Y~^~DescriptorPoolInUseResetSignaled~^~vkResetDescriptorPool~^~VUID-vkResetDescriptorPool-descriptorPool-00313~^~core~^~The spec valid usage text states 'All uses of descriptorPool (via any allocated descriptor sets) must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-descriptorPool-00313)~^~ -VALIDATION_ERROR_32a04601~^~Y~^~InvalidDescriptorPool~^~vkResetDescriptorPool~^~VUID-vkResetDescriptorPool-descriptorPool-parameter~^~core~^~The spec valid usage text states 'descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-descriptorPool-parameter)~^~implicit -VALIDATION_ERROR_32a04607~^~Y~^~Unknown~^~vkResetDescriptorPool~^~VUID-vkResetDescriptorPool-descriptorPool-parent~^~core~^~The spec valid usage text states 'descriptorPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-descriptorPool-parent)~^~implicit -VALIDATION_ERROR_32a05601~^~Y~^~None~^~vkResetDescriptorPool~^~VUID-vkResetDescriptorPool-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-device-parameter)~^~implicit -VALIDATION_ERROR_32a09005~^~Y~^~Unknown~^~vkResetDescriptorPool~^~VUID-vkResetDescriptorPool-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_32c008f8~^~N~^~Unknown~^~vkResetEvent~^~VUID-vkResetEvent-event-01148~^~core~^~The spec valid usage text states 'event must not be waited on by a vkCmdWaitEvents command that is currently executing' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-event-01148)~^~ -VALIDATION_ERROR_32c05601~^~Y~^~None~^~vkResetEvent~^~VUID-vkResetEvent-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-device-parameter)~^~implicit -VALIDATION_ERROR_32c07e01~^~Y~^~None~^~vkResetEvent~^~VUID-vkResetEvent-event-parameter~^~core~^~The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-event-parameter)~^~implicit -VALIDATION_ERROR_32c07e07~^~Y~^~Unknown~^~vkResetEvent~^~VUID-vkResetEvent-event-parent~^~core~^~The spec valid usage text states 'event must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-event-parent)~^~implicit -VALIDATION_ERROR_32e008c6~^~Y~^~Unknown~^~vkResetFences~^~VUID-vkResetFences-pFences-01123~^~core~^~The spec valid usage text states 'Each element of pFences must not be currently associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-pFences-01123)~^~ -VALIDATION_ERROR_32e05601~^~Y~^~None~^~vkResetFences~^~VUID-vkResetFences-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-device-parameter)~^~implicit -VALIDATION_ERROR_32e08a1b~^~N~^~Unknown~^~vkResetFences~^~VUID-vkResetFences-fenceCount-arraylength~^~core~^~The spec valid usage text states 'fenceCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-fenceCount-arraylength)~^~implicit -VALIDATION_ERROR_32e17201~^~Y~^~Unknown~^~vkResetFences~^~VUID-vkResetFences-pFences-parameter~^~core~^~The spec valid usage text states 'pFences must be a valid pointer to an array of fenceCount valid VkFence handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-pFences-parameter)~^~implicit -VALIDATION_ERROR_32e17207~^~Y~^~None~^~vkResetFences~^~VUID-vkResetFences-pFences-parent~^~core~^~The spec valid usage text states 'Each element of pFences must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-pFences-parent)~^~implicit -VALIDATION_ERROR_33005601~^~Y~^~None~^~vkSetEvent~^~VUID-vkSetEvent-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkSetEvent-device-parameter)~^~implicit -VALIDATION_ERROR_33007e01~^~Y~^~None~^~vkSetEvent~^~VUID-vkSetEvent-event-parameter~^~core~^~The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkSetEvent-event-parameter)~^~implicit -VALIDATION_ERROR_33007e07~^~Y~^~Unknown~^~vkSetEvent~^~VUID-vkSetEvent-event-parent~^~core~^~The spec valid usage text states 'event must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkSetEvent-event-parent)~^~implicit -VALIDATION_ERROR_33200009~^~Y~^~None~^~vkSetHdrMetadataEXT~^~VUID-vkSetHdrMetadataEXT-commonparent~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)~^~The spec valid usage text states 'Both of device, and the elements of pSwapchains must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-commonparent)~^~implicit -VALIDATION_ERROR_33205601~^~Y~^~Unknown~^~vkSetHdrMetadataEXT~^~VUID-vkSetHdrMetadataEXT-device-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-device-parameter)~^~implicit -VALIDATION_ERROR_3321ba01~^~Y~^~Unknown~^~vkSetHdrMetadataEXT~^~VUID-vkSetHdrMetadataEXT-pMetadata-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)~^~The spec valid usage text states 'pMetadata must be a valid pointer to an array of swapchainCount valid VkHdrMetadataEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-pMetadata-parameter)~^~implicit -VALIDATION_ERROR_33225801~^~Y~^~Unknown~^~vkSetHdrMetadataEXT~^~VUID-vkSetHdrMetadataEXT-pSwapchains-parameter~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)~^~The spec valid usage text states 'pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-pSwapchains-parameter)~^~implicit -VALIDATION_ERROR_3322f21b~^~N~^~Unknown~^~vkSetHdrMetadataEXT~^~VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)~^~The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength)~^~implicit -VALIDATION_ERROR_33402801~^~Y~^~Unknown~^~vkTrimCommandPool~^~VUID-vkTrimCommandPool-commandPool-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-commandPool-parameter)~^~implicit -VALIDATION_ERROR_33402807~^~Y~^~Unknown~^~vkTrimCommandPool~^~VUID-vkTrimCommandPool-commandPool-parent~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'commandPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-commandPool-parent)~^~implicit -VALIDATION_ERROR_33405601~^~Y~^~Unknown~^~vkTrimCommandPool~^~VUID-vkTrimCommandPool-device-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-device-parameter)~^~implicit -VALIDATION_ERROR_33409005~^~Y~^~Unknown~^~vkTrimCommandPool~^~VUID-vkTrimCommandPool-flags-zerobitmask~^~(VK_VERSION_1_1,VK_KHR_maintenance1)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_33600562~^~Y~^~Unknown~^~vkUnmapMemory~^~VUID-vkUnmapMemory-memory-00689~^~core~^~The spec valid usage text states 'memory must be currently mapped' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-memory-00689)~^~ -VALIDATION_ERROR_33605601~^~Y~^~None~^~vkUnmapMemory~^~VUID-vkUnmapMemory-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-device-parameter)~^~implicit -VALIDATION_ERROR_3360c601~^~Y~^~None~^~vkUnmapMemory~^~VUID-vkUnmapMemory-memory-parameter~^~core~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-memory-parameter)~^~implicit -VALIDATION_ERROR_3360c607~^~Y~^~Unknown~^~vkUnmapMemory~^~VUID-vkUnmapMemory-memory-parent~^~core~^~The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-memory-parent)~^~implicit -VALIDATION_ERROR_33800aba~^~N~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-pObjectIndices-01373~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'At any pObjectIndices there must be a registered resource already.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectIndices-01373)~^~ -VALIDATION_ERROR_33800abc~^~N~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-01374~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'The pObjectEntryTypes of the resource at pObjectIndices must match.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-01374)~^~ -VALIDATION_ERROR_33800abe~^~N~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-None-01375~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'All operations on the device using the registered resource must have been completed.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-None-01375)~^~ -VALIDATION_ERROR_33805601~^~Y~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-device-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-device-parameter)~^~implicit -VALIDATION_ERROR_3380d61b~^~Y~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-objectCount-arraylength~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-objectCount-arraylength)~^~implicit -VALIDATION_ERROR_3380d801~^~Y~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-objectTable-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-objectTable-parameter)~^~implicit -VALIDATION_ERROR_3380d807~^~Y~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-objectTable-parent~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'objectTable must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-objectTable-parent)~^~implicit -VALIDATION_ERROR_3381c801~^~N~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-parameter)~^~implicit -VALIDATION_ERROR_3381cc01~^~Y~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-vkUnregisterObjectsNVX-pObjectIndices-parameter~^~(VK_NVX_device_generated_commands)~^~The spec valid usage text states 'pObjectIndices must be a valid pointer to an array of objectCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectIndices-parameter)~^~implicit -VALIDATION_ERROR_33a00d2a~^~N~^~None~^~vkUpdateDescriptorSetWithTemplate~^~VUID-vkUpdateDescriptorSetWithTemplate-pData-01685~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-pData-01685)~^~ -VALIDATION_ERROR_33a04801~^~Y~^~Unknown~^~vkUpdateDescriptorSetWithTemplate~^~VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'descriptorSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter)~^~implicit -VALIDATION_ERROR_33a05201~^~Y~^~Unknown~^~vkUpdateDescriptorSetWithTemplate~^~VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter)~^~implicit -VALIDATION_ERROR_33a05207~^~Y~^~Unknown~^~vkUpdateDescriptorSetWithTemplate~^~VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'descriptorUpdateTemplate must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent)~^~implicit -VALIDATION_ERROR_33a05601~^~Y~^~Unknown~^~vkUpdateDescriptorSetWithTemplate~^~VUID-vkUpdateDescriptorSetWithTemplate-device-parameter~^~(VK_VERSION_1_1,VK_KHR_descriptor_update_template)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-device-parameter)~^~implicit -VALIDATION_ERROR_33c00274~^~N~^~Unknown~^~vkUpdateDescriptorSets~^~VUID-vkUpdateDescriptorSets-dstSet-00314~^~!(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'The dstSet member of each element of pDescriptorWrites or pDescriptorCopies must not be used by any command that was recorded to a command buffer which is in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-dstSet-00314)~^~ -VALIDATION_ERROR_33c017ce~^~N~^~None~^~vkUpdateDescriptorSets~^~VUID-vkUpdateDescriptorSets-None-03047~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'Descriptor bindings updated by this command which were created without the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT bits set must not be used by any command that was recorded to a command buffer which is in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSets-None-03047)~^~ -VALIDATION_ERROR_33c05601~^~Y~^~None~^~vkUpdateDescriptorSets~^~VUID-vkUpdateDescriptorSets-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-device-parameter)~^~implicit -VALIDATION_ERROR_33c12c01~^~Y~^~Unknown~^~vkUpdateDescriptorSets~^~VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter~^~core~^~The spec valid usage text states 'If descriptorCopyCount is not 0, pDescriptorCopies must be a valid pointer to an array of descriptorCopyCount valid VkCopyDescriptorSet structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter)~^~implicit -VALIDATION_ERROR_33c13601~^~Y~^~Unknown~^~vkUpdateDescriptorSets~^~VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter~^~core~^~The spec valid usage text states 'If descriptorWriteCount is not 0, pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter)~^~implicit -VALIDATION_ERROR_33e05601~^~Y~^~None~^~vkWaitForFences~^~VUID-vkWaitForFences-device-parameter~^~core~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-device-parameter)~^~implicit -VALIDATION_ERROR_33e08a1b~^~N~^~Unknown~^~vkWaitForFences~^~VUID-vkWaitForFences-fenceCount-arraylength~^~core~^~The spec valid usage text states 'fenceCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-fenceCount-arraylength)~^~implicit -VALIDATION_ERROR_33e17201~^~Y~^~Unknown~^~vkWaitForFences~^~VUID-vkWaitForFences-pFences-parameter~^~core~^~The spec valid usage text states 'pFences must be a valid pointer to an array of fenceCount valid VkFence handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-pFences-parameter)~^~implicit -VALIDATION_ERROR_33e17207~^~Y~^~None~^~vkWaitForFences~^~VUID-vkWaitForFences-pFences-parent~^~core~^~The spec valid usage text states 'Each element of pFences must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-pFences-parent)~^~implicit -VALIDATION_ERROR_3401c40d~^~N~^~None~^~VkPhysicalDeviceProperties2~^~VUID-VkPhysicalDeviceProperties2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceSubgroupProperties, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3402b00b~^~Y~^~None~^~VkPhysicalDeviceProperties2~^~VUID-VkPhysicalDeviceProperties2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-sType-sType)~^~implicit -VALIDATION_ERROR_3402b00f~^~N~^~None~^~VkPhysicalDeviceProperties2~^~VUID-VkPhysicalDeviceProperties2-sType-unique~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-sType-unique)~^~implicit -VALIDATION_ERROR_3421c40d~^~N~^~None~^~VkFormatProperties2~^~VUID-VkFormatProperties2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFormatProperties2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3422b00b~^~Y~^~None~^~VkFormatProperties2~^~VUID-VkFormatProperties2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFormatProperties2-sType-sType)~^~implicit -VALIDATION_ERROR_3441c40d~^~N~^~None~^~VkImageFormatProperties2~^~VUID-VkImageFormatProperties2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkSamplerYcbcrConversionImageFormatProperties, or VkTextureLODGatherFormatPropertiesAMD' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatProperties2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3442b00b~^~Y~^~None~^~VkImageFormatProperties2~^~VUID-VkImageFormatProperties2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatProperties2-sType-sType)~^~implicit -VALIDATION_ERROR_3442b00f~^~N~^~None~^~VkImageFormatProperties2~^~VUID-VkImageFormatProperties2-sType-unique~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatProperties2-sType-unique)~^~implicit -VALIDATION_ERROR_3461c40d~^~N~^~None~^~VkPhysicalDeviceMemoryProperties2~^~VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3462b00b~^~Y~^~None~^~VkPhysicalDeviceMemoryProperties2~^~VUID-VkPhysicalDeviceMemoryProperties2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-sType-sType)~^~implicit -VALIDATION_ERROR_3481c40d~^~N~^~None~^~VkSurfaceCapabilities2KHR~^~VUID-VkSurfaceCapabilities2KHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkSharedPresentSurfaceCapabilitiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2KHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3482b00b~^~Y~^~None~^~VkSurfaceCapabilities2KHR~^~VUID-VkSurfaceCapabilities2KHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2KHR-sType-sType)~^~implicit -VALIDATION_ERROR_34a1c40d~^~N~^~None~^~VkDeviceGroupPresentCapabilitiesKHR~^~VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_34a2b00b~^~Y~^~None~^~VkDeviceGroupPresentCapabilitiesKHR~^~VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType)~^~implicit -VALIDATION_ERROR_34c1c40d~^~N~^~None~^~VkExternalBufferProperties~^~VUID-VkExternalBufferProperties-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalBufferProperties-pNext-pNext)~^~implicit -VALIDATION_ERROR_34c2b00b~^~Y~^~None~^~VkExternalBufferProperties~^~VUID-VkExternalBufferProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalBufferProperties-sType-sType)~^~implicit -VALIDATION_ERROR_3521c40d~^~N~^~None~^~VkExternalSemaphoreProperties~^~VUID-VkExternalSemaphoreProperties-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalSemaphoreProperties-pNext-pNext)~^~implicit -VALIDATION_ERROR_3522b00b~^~Y~^~None~^~VkExternalSemaphoreProperties~^~VUID-VkExternalSemaphoreProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalSemaphoreProperties-sType-sType)~^~implicit -VALIDATION_ERROR_3541c40d~^~N~^~None~^~VkQueueFamilyProperties2~^~VUID-VkQueueFamilyProperties2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkQueueFamilyProperties2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3542b00b~^~N~^~None~^~VkQueueFamilyProperties2~^~VUID-VkQueueFamilyProperties2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkQueueFamilyProperties2-sType-sType)~^~implicit -VALIDATION_ERROR_3561c40d~^~N~^~None~^~VkSparseImageFormatProperties2~^~VUID-VkSparseImageFormatProperties2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageFormatProperties2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3562b00b~^~N~^~None~^~VkSparseImageFormatProperties2~^~VUID-VkSparseImageFormatProperties2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageFormatProperties2-sType-sType)~^~implicit -VALIDATION_ERROR_3581c40d~^~N~^~None~^~VkSurfaceFormat2KHR~^~VUID-VkSurfaceFormat2KHR-pNext-pNext~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceFormat2KHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3582b00b~^~N~^~None~^~VkSurfaceFormat2KHR~^~VUID-VkSurfaceFormat2KHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceFormat2KHR-sType-sType)~^~implicit -VALIDATION_ERROR_35c2b00b~^~N~^~None~^~VkPhysicalDeviceMultiviewProperties~^~VUID-VkPhysicalDeviceMultiviewProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_multiview)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewProperties-sType-sType)~^~implicit -VALIDATION_ERROR_3602b00b~^~N~^~None~^~VkExternalImageFormatProperties~^~VUID-VkExternalImageFormatProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalImageFormatProperties-sType-sType)~^~implicit -VALIDATION_ERROR_3622b00b~^~N~^~None~^~VkPhysicalDeviceIDProperties~^~VUID-VkPhysicalDeviceIDProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities,VK_KHR_external_semaphore_capabilities,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceIDProperties-sType-sType)~^~implicit -VALIDATION_ERROR_3642b00b~^~N~^~None~^~VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX~^~VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType~^~(VK_NVX_multiview_per_view_attributes)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType)~^~implicit -VALIDATION_ERROR_37e2b00b~^~N~^~None~^~VkSharedPresentSurfaceCapabilitiesKHR~^~VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType~^~(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_shared_presentable_image)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3822b00b~^~N~^~None~^~VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT~^~VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3842b00b~^~N~^~None~^~VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT~^~VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3862b00b~^~N~^~None~^~VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT~^~VUID-VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT-sType-sType~^~(VK_EXT_sampler_filter_minmax)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_38800b20~^~N~^~None~^~VkPipelineColorBlendAdvancedStateCreateInfoEXT~^~VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If the non-premultiplied source color property is not supported, srcPremultiplied must be VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424)~^~ -VALIDATION_ERROR_38800b22~^~N~^~None~^~VkPipelineColorBlendAdvancedStateCreateInfoEXT~^~VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If the non-premultiplied destination color property is not supported, dstPremultiplied must be VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425)~^~ -VALIDATION_ERROR_38800b24~^~N~^~None~^~VkPipelineColorBlendAdvancedStateCreateInfoEXT~^~VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'If the correlated overlap property is not supported, blendOverlap must be VK_BLEND_OVERLAP_UNCORRELATED_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426)~^~ -VALIDATION_ERROR_3882b00b~^~N~^~None~^~VkPipelineColorBlendAdvancedStateCreateInfoEXT~^~VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_38834a01~^~N~^~None~^~VkPipelineColorBlendAdvancedStateCreateInfoEXT~^~VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter~^~(VK_EXT_blend_operation_advanced)~^~The spec valid usage text states 'blendOverlap must be a valid VkBlendOverlapEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter)~^~implicit -VALIDATION_ERROR_38a00afa~^~N~^~None~^~VkPipelineCoverageModulationStateCreateInfoNV~^~VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'If coverageModulationTableEnable is VK_TRUE, coverageModulationTableCount must be equal to the number of rasterization samples divided by the number of color samples in the subpass.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405)~^~ -VALIDATION_ERROR_38a09005~^~N~^~None~^~VkPipelineCoverageModulationStateCreateInfoNV~^~VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_38a2b00b~^~N~^~None~^~VkPipelineCoverageModulationStateCreateInfoNV~^~VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_38a34c01~^~N~^~None~^~VkPipelineCoverageModulationStateCreateInfoNV~^~VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'coverageModulationMode must be a valid VkCoverageModulationModeNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter)~^~implicit -VALIDATION_ERROR_38a34e1b~^~N~^~None~^~VkPipelineCoverageModulationStateCreateInfoNV~^~VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableCount-arraylength~^~(VK_NV_framebuffer_mixed_samples)~^~The spec valid usage text states 'coverageModulationTableCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableCount-arraylength)~^~implicit -VALIDATION_ERROR_38c00af8~^~N~^~None~^~VkPipelineCoverageToColorStateCreateInfoNV~^~VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404~^~(VK_NV_fragment_coverage_to_color)~^~The spec valid usage text states 'If coverageToColorEnable is VK_TRUE, then the render pass subpass indicated by VkGraphicsPipelineCreateInfo::renderPass and VkGraphicsPipelineCreateInfo::subpass must have a color attachment at the location selected by coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404)~^~ -VALIDATION_ERROR_38c09005~^~N~^~None~^~VkPipelineCoverageToColorStateCreateInfoNV~^~VUID-VkPipelineCoverageToColorStateCreateInfoNV-flags-zerobitmask~^~(VK_NV_fragment_coverage_to_color)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageToColorStateCreateInfoNV-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_38c2b00b~^~N~^~None~^~VkPipelineCoverageToColorStateCreateInfoNV~^~VUID-VkPipelineCoverageToColorStateCreateInfoNV-sType-sType~^~(VK_NV_fragment_coverage_to_color)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageToColorStateCreateInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_38e2b00b~^~N~^~None~^~VkSamplerReductionModeCreateInfoEXT~^~VUID-VkSamplerReductionModeCreateInfoEXT-sType-sType~^~(VK_EXT_sampler_filter_minmax)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerReductionModeCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_38e35001~^~N~^~None~^~VkSamplerReductionModeCreateInfoEXT~^~VUID-VkSamplerReductionModeCreateInfoEXT-reductionMode-parameter~^~(VK_EXT_sampler_filter_minmax)~^~The spec valid usage text states 'reductionMode must be a valid VkSamplerReductionModeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerReductionModeCreateInfoEXT-reductionMode-parameter)~^~implicit -VALIDATION_ERROR_39400b4c~^~N~^~None~^~VkExportFenceCreateInfo~^~VUID-VkExportFenceCreateInfo-handleTypes-01446~^~(VK_VERSION_1_1,VK_KHR_external_fence)~^~The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalFenceProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceCreateInfo-handleTypes-01446)~^~ -VALIDATION_ERROR_39409e01~^~N~^~None~^~VkExportFenceCreateInfo~^~VUID-VkExportFenceCreateInfo-handleTypes-parameter~^~(VK_VERSION_1_1,VK_KHR_external_fence)~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceCreateInfo-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_3942b00b~^~N~^~None~^~VkExportFenceCreateInfo~^~VUID-VkExportFenceCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_fence)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_39609c01~^~Y~^~None~^~VkPhysicalDeviceExternalFenceInfo~^~VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter)~^~implicit -VALIDATION_ERROR_3961c40d~^~Y~^~None~^~VkPhysicalDeviceExternalFenceInfo~^~VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_3962b00b~^~Y~^~None~^~VkPhysicalDeviceExternalFenceInfo~^~VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3981c40d~^~N~^~None~^~VkExternalFenceProperties~^~VUID-VkExternalFenceProperties-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFenceProperties-pNext-pNext)~^~implicit -VALIDATION_ERROR_3982b00b~^~Y~^~None~^~VkExternalFenceProperties~^~VUID-VkExternalFenceProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFenceProperties-sType-sType)~^~implicit -VALIDATION_ERROR_39a27a01~^~Y~^~None~^~vkGetPhysicalDeviceExternalFenceProperties~^~VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_39a3a201~^~N~^~None~^~vkGetPhysicalDeviceExternalFenceProperties~^~VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'pExternalFenceInfo must be a valid pointer to a valid VkPhysicalDeviceExternalFenceInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter)~^~implicit -VALIDATION_ERROR_39a3a401~^~N~^~None~^~vkGetPhysicalDeviceExternalFenceProperties~^~VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter~^~(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)~^~The spec valid usage text states 'pExternalFenceProperties must be a valid pointer to a VkExternalFenceProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter)~^~implicit -VALIDATION_ERROR_39c00b70~^~N~^~None~^~VkImportFenceFdInfoKHR~^~VUID-VkImportFenceFdInfoKHR-handleType-01464~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportFenceFdInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-handleType-01464)~^~ -VALIDATION_ERROR_39c00c0a~^~N~^~None~^~VkImportFenceFdInfoKHR~^~VUID-VkImportFenceFdInfoKHR-fd-01541~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'fd must obey any requirements listed for handleType in external fence handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-fd-01541)~^~ -VALIDATION_ERROR_39c08801~^~Y~^~None~^~VkImportFenceFdInfoKHR~^~VUID-VkImportFenceFdInfoKHR-fence-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-fence-parameter)~^~implicit -VALIDATION_ERROR_39c09001~^~Y~^~None~^~VkImportFenceFdInfoKHR~^~VUID-VkImportFenceFdInfoKHR-flags-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'flags must be a valid combination of VkFenceImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-flags-parameter)~^~implicit -VALIDATION_ERROR_39c09c01~^~Y~^~None~^~VkImportFenceFdInfoKHR~^~VUID-VkImportFenceFdInfoKHR-handleType-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_39c1c40d~^~Y~^~None~^~VkImportFenceFdInfoKHR~^~VUID-VkImportFenceFdInfoKHR-pNext-pNext~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_39c2b00b~^~Y~^~None~^~VkImportFenceFdInfoKHR~^~VUID-VkImportFenceFdInfoKHR-sType-sType~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_39e00b5a~^~N~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-handleType-01453~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'handleType must have been included in VkExportFenceCreateInfo::handleTypes when fence's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01453)~^~ -VALIDATION_ERROR_39e00b5c~^~N~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-handleType-01454~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01454)~^~ -VALIDATION_ERROR_39e00b5e~^~N~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-fence-01455~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload's handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-fence-01455)~^~ -VALIDATION_ERROR_39e00b60~^~N~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-handleType-01456~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01456)~^~ -VALIDATION_ERROR_39e08801~^~Y~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-fence-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-fence-parameter)~^~implicit -VALIDATION_ERROR_39e09c01~^~Y~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-handleType-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_39e1c40d~^~Y~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-pNext-pNext~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_39e2b00b~^~Y~^~None~^~VkFenceGetFdInfoKHR~^~VUID-VkFenceGetFdInfoKHR-sType-sType~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3a000b6e~^~N~^~None~^~vkImportFenceFdKHR~^~VUID-vkImportFenceFdKHR-fence-01463~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'fence must not be associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceFdKHR-fence-01463)~^~ -VALIDATION_ERROR_3a005601~^~Y~^~None~^~vkImportFenceFdKHR~^~VUID-vkImportFenceFdKHR-device-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceFdKHR-device-parameter)~^~implicit -VALIDATION_ERROR_3a03a801~^~N~^~None~^~vkImportFenceFdKHR~^~VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter)~^~implicit -VALIDATION_ERROR_3a205601~^~Y~^~None~^~vkGetFenceFdKHR~^~VUID-vkGetFenceFdKHR-device-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceFdKHR-device-parameter)~^~implicit -VALIDATION_ERROR_3a216c01~^~Y~^~None~^~vkGetFenceFdKHR~^~VUID-vkGetFenceFdKHR-pFd-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'pFd must be a valid pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceFdKHR-pFd-parameter)~^~implicit -VALIDATION_ERROR_3a239e01~^~N~^~None~^~vkGetFenceFdKHR~^~VUID-vkGetFenceFdKHR-pGetFdInfo-parameter~^~(VK_KHR_external_fence_fd)~^~The spec valid usage text states 'pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceFdKHR-pGetFdInfo-parameter)~^~implicit -VALIDATION_ERROR_3a400b62~^~N~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportFenceWin32HandleInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457)~^~ -VALIDATION_ERROR_3a400b66~^~N~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handleType is not VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459)~^~ -VALIDATION_ERROR_3a400b68~^~N~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460)~^~ -VALIDATION_ERROR_3a400b6a~^~N~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461)~^~ -VALIDATION_ERROR_3a400b6c~^~N~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-handle-01462~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handle-01462)~^~ -VALIDATION_ERROR_3a400c06~^~N~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-handle-01539~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handle is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handle-01539)~^~ -VALIDATION_ERROR_3a400c08~^~N~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-name-01540~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If name is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-name-01540)~^~ -VALIDATION_ERROR_3a408801~^~Y~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter)~^~implicit -VALIDATION_ERROR_3a409001~^~Y~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'flags must be a valid combination of VkFenceImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter)~^~implicit -VALIDATION_ERROR_3a409c01~^~Y~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_3a41c40d~^~Y~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3a42b00b~^~Y~^~None~^~VkImportFenceWin32HandleInfoKHR~^~VUID-VkImportFenceWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3a600b4e~^~N~^~None~^~VkExportFenceWin32HandleInfoKHR~^~VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If VkExportFenceCreateInfo::handleTypes does not include VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, VkExportFenceWin32HandleInfoKHR must not be in the pNext chain of VkFenceCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447)~^~ -VALIDATION_ERROR_3a60f401~^~N~^~None~^~VkExportFenceWin32HandleInfoKHR~^~VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter)~^~implicit -VALIDATION_ERROR_3a62b00b~^~N~^~None~^~VkExportFenceWin32HandleInfoKHR~^~VUID-VkExportFenceWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3a800b50~^~N~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'handleType must have been included in VkExportFenceCreateInfo::handleTypes when the fence's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448)~^~ -VALIDATION_ERROR_3a800b52~^~N~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handleType is defined as an NT handle, vkGetFenceWin32HandleKHR must be called no more than once for each valid unique combination of fence and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449)~^~ -VALIDATION_ERROR_3a800b54~^~N~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-fence-01450~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload's handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-fence-01450)~^~ -VALIDATION_ERROR_3a800b56~^~N~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451)~^~ -VALIDATION_ERROR_3a800b58~^~N~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452)~^~ -VALIDATION_ERROR_3a808801~^~Y~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter)~^~implicit -VALIDATION_ERROR_3a809c01~^~Y~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_3a81c40d~^~Y~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3a82b00b~^~Y~^~None~^~VkFenceGetWin32HandleInfoKHR~^~VUID-VkFenceGetWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3aa05601~^~Y~^~None~^~vkImportFenceWin32HandleKHR~^~VUID-vkImportFenceWin32HandleKHR-device-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceWin32HandleKHR-device-parameter)~^~implicit -VALIDATION_ERROR_3aa3aa01~^~N~^~None~^~vkImportFenceWin32HandleKHR~^~VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'pImportFenceWin32HandleInfo must be a valid pointer to a valid VkImportFenceWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter)~^~implicit -VALIDATION_ERROR_3ac05601~^~Y~^~None~^~vkGetFenceWin32HandleKHR~^~VUID-vkGetFenceWin32HandleKHR-device-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-device-parameter)~^~implicit -VALIDATION_ERROR_3ac17c01~^~Y~^~None~^~vkGetFenceWin32HandleKHR~^~VUID-vkGetFenceWin32HandleKHR-pHandle-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-pHandle-parameter)~^~implicit -VALIDATION_ERROR_3ac3a001~^~N~^~None~^~vkGetFenceWin32HandleKHR~^~VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter~^~(VK_KHR_external_fence_win32)~^~The spec valid usage text states 'pGetWin32HandleInfo must be a valid pointer to a valid VkFenceGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter)~^~implicit -VALIDATION_ERROR_3ae008d8~^~N~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-handleType-01132~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when semaphore's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01132)~^~ -VALIDATION_ERROR_3ae008da~^~N~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload's handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133)~^~ -VALIDATION_ERROR_3ae008dc~^~N~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-handleType-01134~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01134)~^~ -VALIDATION_ERROR_3ae008de~^~N~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-handleType-01135~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01135)~^~ -VALIDATION_ERROR_3ae008e0~^~N~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-handleType-01136~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01136)~^~ -VALIDATION_ERROR_3ae09c01~^~Y~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_3ae1c40d~^~Y~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3ae2b00b~^~Y~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-sType-sType~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3ae2b801~^~Y~^~None~^~VkSemaphoreGetFdInfoKHR~^~VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter~^~(VK_KHR_external_semaphore_fd)~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter)~^~implicit -VALIDATION_ERROR_3b0008cc~^~N~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when the semaphore's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126)~^~ -VALIDATION_ERROR_3b0008ce~^~N~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHR must be called no more than once for each valid unique combination of semaphore and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127)~^~ -VALIDATION_ERROR_3b0008d0~^~N~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload's handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128)~^~ -VALIDATION_ERROR_3b0008d2~^~N~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129)~^~ -VALIDATION_ERROR_3b0008d4~^~N~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130)~^~ -VALIDATION_ERROR_3b0008d6~^~N~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131)~^~ -VALIDATION_ERROR_3b009c01~^~Y~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_3b01c40d~^~Y~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3b02b00b~^~Y~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3b02b801~^~Y~^~None~^~VkSemaphoreGetWin32HandleInfoKHR~^~VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter~^~(VK_KHR_external_semaphore_win32)~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter)~^~implicit -VALIDATION_ERROR_3b20053e~^~N~^~None~^~VkMemoryGetFdInfoKHR~^~VUID-VkMemoryGetFdInfoKHR-handleType-00671~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-handleType-00671)~^~ -VALIDATION_ERROR_3b200540~^~N~^~None~^~VkMemoryGetFdInfoKHR~^~VUID-VkMemoryGetFdInfoKHR-handleType-00672~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-handleType-00672)~^~ -VALIDATION_ERROR_3b209c01~^~Y~^~None~^~VkMemoryGetFdInfoKHR~^~VUID-VkMemoryGetFdInfoKHR-handleType-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_3b20c601~^~Y~^~None~^~VkMemoryGetFdInfoKHR~^~VUID-VkMemoryGetFdInfoKHR-memory-parameter~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-memory-parameter)~^~implicit -VALIDATION_ERROR_3b21c40d~^~Y~^~None~^~VkMemoryGetFdInfoKHR~^~VUID-VkMemoryGetFdInfoKHR-pNext-pNext~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3b22b00b~^~Y~^~None~^~VkMemoryGetFdInfoKHR~^~VUID-VkMemoryGetFdInfoKHR-sType-sType~^~(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3b40052c~^~N~^~None~^~VkMemoryGetWin32HandleInfoKHR~^~VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662)~^~ -VALIDATION_ERROR_3b40052e~^~N~^~None~^~VkMemoryGetWin32HandleInfoKHR~^~VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHR must be called no more than once for each valid unique combination of memory and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663)~^~ -VALIDATION_ERROR_3b400530~^~N~^~None~^~VkMemoryGetWin32HandleInfoKHR~^~VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664)~^~ -VALIDATION_ERROR_3b409c01~^~Y~^~None~^~VkMemoryGetWin32HandleInfoKHR~^~VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter)~^~implicit -VALIDATION_ERROR_3b40c601~^~Y~^~None~^~VkMemoryGetWin32HandleInfoKHR~^~VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter)~^~implicit -VALIDATION_ERROR_3b41c40d~^~Y~^~None~^~VkMemoryGetWin32HandleInfoKHR~^~VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext)~^~implicit -VALIDATION_ERROR_3b42b00b~^~Y~^~None~^~VkMemoryGetWin32HandleInfoKHR~^~VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType~^~(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3b62b00b~^~N~^~None~^~VkMemoryDedicatedRequirements~^~VUID-VkMemoryDedicatedRequirements-sType-sType~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedRequirements-sType-sType)~^~implicit -VALIDATION_ERROR_3b800009~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-commonparent~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-commonparent)~^~implicit -VALIDATION_ERROR_3b800b30~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-image-01432~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'At least one of image and buffer must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01432)~^~ -VALIDATION_ERROR_3b800b32~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-image-01433~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01433)~^~ -VALIDATION_ERROR_3b800b34~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-image-01434~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must have been created without VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in VkImageCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01434)~^~ -VALIDATION_ERROR_3b800b36~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-buffer-01435~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01435)~^~ -VALIDATION_ERROR_3b800b38~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-buffer-01436~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must have been created without VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in VkBufferCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01436)~^~ -VALIDATION_ERROR_3b800e0a~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-image-01797~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must not have been created with VK_IMAGE_CREATE_DISJOINT_BIT set in VkImageCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01797)~^~ -VALIDATION_ERROR_3b800ea8~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-image-01876~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01876)~^~ -VALIDATION_ERROR_3b800eaa~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-buffer-01877~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_win32)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01877)~^~ -VALIDATION_ERROR_3b800eac~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-image-01878~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01878)~^~ -VALIDATION_ERROR_3b800eae~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-buffer-01879~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01879)~^~ -VALIDATION_ERROR_3b801a01~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter)~^~implicit -VALIDATION_ERROR_3b80a001~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-image-parameter~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-parameter)~^~implicit -VALIDATION_ERROR_3b82b00b~^~N~^~None~^~VkMemoryDedicatedAllocateInfo~^~VUID-VkMemoryDedicatedAllocateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_dedicated_allocation)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3ba01a01~^~Y~^~None~^~VkBufferMemoryRequirementsInfo2~^~VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter)~^~implicit -VALIDATION_ERROR_3ba1c40d~^~Y~^~None~^~VkBufferMemoryRequirementsInfo2~^~VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3ba2b00b~^~Y~^~None~^~VkBufferMemoryRequirementsInfo2~^~VUID-VkBufferMemoryRequirementsInfo2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2-sType-sType)~^~implicit -VALIDATION_ERROR_3bc00c6a~^~N~^~None~^~VkImageMemoryRequirementsInfo2~^~VUID-VkImageMemoryRequirementsInfo2-image-01589~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was created with a multi-planar format and the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01589)~^~ -VALIDATION_ERROR_3bc00c6c~^~N~^~None~^~VkImageMemoryRequirementsInfo2~^~VUID-VkImageMemoryRequirementsInfo2-image-01590~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01590)~^~ -VALIDATION_ERROR_3bc00c6e~^~N~^~None~^~VkImageMemoryRequirementsInfo2~^~VUID-VkImageMemoryRequirementsInfo2-image-01591~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If image was created with a single-plane format, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01591)~^~ -VALIDATION_ERROR_3bc00ed2~^~N~^~None~^~VkImageMemoryRequirementsInfo2~^~VUID-VkImageMemoryRequirementsInfo2-image-01897~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01897)~^~ -VALIDATION_ERROR_3bc0a001~^~Y~^~None~^~VkImageMemoryRequirementsInfo2~^~VUID-VkImageMemoryRequirementsInfo2-image-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-parameter)~^~implicit -VALIDATION_ERROR_3bc1c40d~^~Y~^~None~^~VkImageMemoryRequirementsInfo2~^~VUID-VkImageMemoryRequirementsInfo2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkImagePlaneMemoryRequirementsInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3bc2b00b~^~Y~^~None~^~VkImageMemoryRequirementsInfo2~^~VUID-VkImageMemoryRequirementsInfo2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-sType-sType)~^~implicit -VALIDATION_ERROR_3be0a001~^~Y~^~None~^~VkImageSparseMemoryRequirementsInfo2~^~VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter)~^~implicit -VALIDATION_ERROR_3be1c40d~^~Y~^~None~^~VkImageSparseMemoryRequirementsInfo2~^~VUID-VkImageSparseMemoryRequirementsInfo2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSparseMemoryRequirementsInfo2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3be2b00b~^~Y~^~None~^~VkImageSparseMemoryRequirementsInfo2~^~VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType)~^~implicit -VALIDATION_ERROR_3c01c40d~^~N~^~None~^~VkMemoryRequirements2~^~VUID-VkMemoryRequirements2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkMemoryDedicatedRequirements' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryRequirements2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3c02b00b~^~Y~^~None~^~VkMemoryRequirements2~^~VUID-VkMemoryRequirements2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryRequirements2-sType-sType)~^~implicit -VALIDATION_ERROR_3c21c40d~^~N~^~None~^~VkSparseImageMemoryRequirements2~^~VUID-VkSparseImageMemoryRequirements2-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageMemoryRequirements2-pNext-pNext)~^~implicit -VALIDATION_ERROR_3c22b00b~^~N~^~None~^~VkSparseImageMemoryRequirements2~^~VUID-VkSparseImageMemoryRequirements2-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageMemoryRequirements2-sType-sType)~^~implicit -VALIDATION_ERROR_3c405601~^~Y~^~None~^~vkGetImageMemoryRequirements2~^~VUID-vkGetImageMemoryRequirements2-device-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements2-device-parameter)~^~implicit -VALIDATION_ERROR_3c41b401~^~N~^~None~^~vkGetImageMemoryRequirements2~^~VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter)~^~implicit -VALIDATION_ERROR_3c439c01~^~N~^~None~^~vkGetImageMemoryRequirements2~^~VUID-vkGetImageMemoryRequirements2-pInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pInfo must be a valid pointer to a valid VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements2-pInfo-parameter)~^~implicit -VALIDATION_ERROR_3c605601~^~Y~^~None~^~vkGetBufferMemoryRequirements2~^~VUID-vkGetBufferMemoryRequirements2-device-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2-device-parameter)~^~implicit -VALIDATION_ERROR_3c61b401~^~N~^~None~^~vkGetBufferMemoryRequirements2~^~VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter)~^~implicit -VALIDATION_ERROR_3c639c01~^~N~^~None~^~vkGetBufferMemoryRequirements2~^~VUID-vkGetBufferMemoryRequirements2-pInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pInfo must be a valid pointer to a valid VkBufferMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2-pInfo-parameter)~^~implicit -VALIDATION_ERROR_3c805601~^~Y~^~None~^~vkGetImageSparseMemoryRequirements2~^~VUID-vkGetImageSparseMemoryRequirements2-device-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-device-parameter)~^~implicit -VALIDATION_ERROR_3c823601~^~N~^~None~^~vkGetImageSparseMemoryRequirements2~^~VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirementCount-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirementCount-parameter)~^~implicit -VALIDATION_ERROR_3c823801~^~Y~^~None~^~vkGetImageSparseMemoryRequirements2~^~VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirements-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements2 structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirements-parameter)~^~implicit -VALIDATION_ERROR_3c839c01~^~N~^~None~^~vkGetImageSparseMemoryRequirements2~^~VUID-vkGetImageSparseMemoryRequirements2-pInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)~^~The spec valid usage text states 'pInfo must be a valid pointer to a valid VkImageSparseMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-pInfo-parameter)~^~implicit -VALIDATION_ERROR_3ca2b00b~^~N~^~None~^~VkPhysicalDevice16BitStorageFeatures~^~VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType~^~(VK_VERSION_1_1,VK_KHR_16bit_storage)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType)~^~implicit -VALIDATION_ERROR_3cc00b2e~^~N~^~None~^~VkPhysicalDeviceVariablePointerFeatures~^~VUID-VkPhysicalDeviceVariablePointerFeatures-variablePointers-01431~^~(VK_VERSION_1_1,VK_KHR_variable_pointers)~^~The spec valid usage text states 'If variablePointers is enabled then variablePointersStorageBuffer must also be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceVariablePointerFeatures-variablePointers-01431)~^~ -VALIDATION_ERROR_3cc2b00b~^~N~^~None~^~VkPhysicalDeviceVariablePointerFeatures~^~VUID-VkPhysicalDeviceVariablePointerFeatures-sType-sType~^~(VK_VERSION_1_1,VK_KHR_variable_pointers)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceVariablePointerFeatures-sType-sType)~^~implicit -VALIDATION_ERROR_3ce00bec~^~N~^~None~^~VkSampleLocationsInfoEXT~^~VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sampleLocationsPerPixel must be a bit value that is set in VkPhysicalDeviceSampleLocationsPropertiesEXT::sampleLocationSampleCounts' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526)~^~ -VALIDATION_ERROR_3ce00bee~^~N~^~None~^~VkSampleLocationsInfoEXT~^~VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sampleLocationsCount must equal sampleLocationsPerPixel {times} sampleLocationGridSize.width {times} sampleLocationGridSize.height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527)~^~ -VALIDATION_ERROR_3ce2b00b~^~Y~^~None~^~VkSampleLocationsInfoEXT~^~VUID-VkSampleLocationsInfoEXT-sType-sType~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3ce3b201~^~Y~^~None~^~VkSampleLocationsInfoEXT~^~VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sampleLocationsPerPixel must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter)~^~implicit -VALIDATION_ERROR_3ce3b41b~^~Y~^~None~^~VkSampleLocationsInfoEXT~^~VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sampleLocationsCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength)~^~implicit -VALIDATION_ERROR_3ce3b601~^~Y~^~None~^~VkSampleLocationsInfoEXT~^~VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'pSampleLocations must be a valid pointer to an array of sampleLocationsCount VkSampleLocationEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter)~^~implicit -VALIDATION_ERROR_3d02b00b~^~N~^~None~^~VkRenderPassSampleLocationsBeginInfoEXT~^~VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3d03ba01~^~N~^~None~^~VkRenderPassSampleLocationsBeginInfoEXT~^~VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If attachmentInitialSampleLocationsCount is not 0, pAttachmentInitialSampleLocations must be a valid pointer to an array of attachmentInitialSampleLocationsCount valid VkAttachmentSampleLocationsEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter)~^~implicit -VALIDATION_ERROR_3d03e801~^~N~^~None~^~VkRenderPassSampleLocationsBeginInfoEXT~^~VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If postSubpassSampleLocationsCount is not 0, pPostSubpassSampleLocations must be a valid pointer to an array of postSubpassSampleLocationsCount valid VkSubpassSampleLocationsEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter)~^~implicit -VALIDATION_ERROR_3d22b00b~^~N~^~None~^~VkPipelineSampleLocationsStateCreateInfoEXT~^~VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3d23c601~^~N~^~None~^~VkPipelineSampleLocationsStateCreateInfoEXT~^~VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter)~^~implicit -VALIDATION_ERROR_3d42b00b~^~N~^~None~^~VkPhysicalDeviceSampleLocationsPropertiesEXT~^~VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3d61c40d~^~N~^~None~^~VkMultisamplePropertiesEXT~^~VUID-VkMultisamplePropertiesEXT-pNext-pNext~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMultisamplePropertiesEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_3d62b00b~^~Y~^~None~^~VkMultisamplePropertiesEXT~^~VUID-VkMultisamplePropertiesEXT-sType-sType~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMultisamplePropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3d827a01~^~Y~^~None~^~vkGetPhysicalDeviceMultisamplePropertiesEXT~^~VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter)~^~implicit -VALIDATION_ERROR_3d82b401~^~Y~^~None~^~vkGetPhysicalDeviceMultisamplePropertiesEXT~^~VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter)~^~implicit -VALIDATION_ERROR_3d83ca01~^~N~^~None~^~vkGetPhysicalDeviceMultisamplePropertiesEXT~^~VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'pMultisampleProperties must be a valid pointer to a VkMultisamplePropertiesEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter)~^~implicit -VALIDATION_ERROR_3da00bfc~^~N~^~None~^~VkValidationCacheCreateInfoEXT~^~VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetValidationCacheDataEXT when pInitialData was originally retrieved' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534)~^~ -VALIDATION_ERROR_3da00bfe~^~N~^~None~^~VkValidationCacheCreateInfoEXT~^~VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetValidationCacheDataEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535)~^~ -VALIDATION_ERROR_3da09005~^~Y~^~None~^~VkValidationCacheCreateInfoEXT~^~VUID-VkValidationCacheCreateInfoEXT-flags-zerobitmask~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_3da19601~^~Y~^~None~^~VkValidationCacheCreateInfoEXT~^~VUID-VkValidationCacheCreateInfoEXT-pInitialData-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-pInitialData-parameter)~^~implicit -VALIDATION_ERROR_3da1c40d~^~Y~^~None~^~VkValidationCacheCreateInfoEXT~^~VUID-VkValidationCacheCreateInfoEXT-pNext-pNext~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_3da2b00b~^~Y~^~None~^~VkValidationCacheCreateInfoEXT~^~VUID-VkValidationCacheCreateInfoEXT-sType-sType~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3dc2b00b~^~N~^~None~^~VkShaderModuleValidationCacheCreateInfoEXT~^~VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_3dc3c401~^~N~^~None~^~VkShaderModuleValidationCacheCreateInfoEXT~^~VUID-VkShaderModuleValidationCacheCreateInfoEXT-validationCache-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'validationCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleValidationCacheCreateInfoEXT-validationCache-parameter)~^~implicit -VALIDATION_ERROR_3de05601~^~Y~^~None~^~vkCreateValidationCacheEXT~^~VUID-vkCreateValidationCacheEXT-device-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-device-parameter)~^~implicit -VALIDATION_ERROR_3de0ec01~^~N~^~None~^~vkCreateValidationCacheEXT~^~VUID-vkCreateValidationCacheEXT-pAllocator-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_3de11e01~^~N~^~None~^~vkCreateValidationCacheEXT~^~VUID-vkCreateValidationCacheEXT-pCreateInfo-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkValidationCacheCreateInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_3de3c201~^~Y~^~None~^~vkCreateValidationCacheEXT~^~VUID-vkCreateValidationCacheEXT-pValidationCache-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'pValidationCache must be a valid pointer to a VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-pValidationCache-parameter)~^~implicit -VALIDATION_ERROR_3e005601~^~Y~^~None~^~vkGetValidationCacheDataEXT~^~VUID-vkGetValidationCacheDataEXT-device-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-device-parameter)~^~implicit -VALIDATION_ERROR_3e012201~^~Y~^~None~^~vkGetValidationCacheDataEXT~^~VUID-vkGetValidationCacheDataEXT-pData-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-pData-parameter)~^~implicit -VALIDATION_ERROR_3e012401~^~N~^~None~^~vkGetValidationCacheDataEXT~^~VUID-vkGetValidationCacheDataEXT-pDataSize-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'pDataSize must be a valid pointer to a size_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-pDataSize-parameter)~^~implicit -VALIDATION_ERROR_3e03c401~^~Y~^~None~^~vkGetValidationCacheDataEXT~^~VUID-vkGetValidationCacheDataEXT-validationCache-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'validationCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-validationCache-parameter)~^~implicit -VALIDATION_ERROR_3e03c407~^~Y~^~None~^~vkGetValidationCacheDataEXT~^~VUID-vkGetValidationCacheDataEXT-validationCache-parent~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'validationCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-validationCache-parent)~^~implicit -VALIDATION_ERROR_3e200bf0~^~N~^~None~^~vkCmdSetSampleLocationsEXT~^~VUID-vkCmdSetSampleLocationsEXT-None-01528~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-None-01528)~^~ -VALIDATION_ERROR_3e200bf2~^~N~^~None~^~vkCmdSetSampleLocationsEXT~^~VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'The sampleLocationsPerPixel member of pSampleLocationsInfo must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529)~^~ -VALIDATION_ERROR_3e200bf4~^~N~^~None~^~vkCmdSetSampleLocationsEXT~^~VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE then the current render pass must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sample locations state pointed to by pSampleLocationsInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530)~^~ -VALIDATION_ERROR_3e202401~^~Y~^~None~^~vkCmdSetSampleLocationsEXT~^~VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_3e202413~^~Y~^~None~^~vkCmdSetSampleLocationsEXT~^~VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_3e202415~^~N~^~None~^~vkCmdSetSampleLocationsEXT~^~VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_3e23c801~^~N~^~None~^~vkCmdSetSampleLocationsEXT~^~VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'pSampleLocationsInfo must be a valid pointer to a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter)~^~implicit -VALIDATION_ERROR_3e400c02~^~N~^~None~^~vkDestroyValidationCacheEXT~^~VUID-vkDestroyValidationCacheEXT-validationCache-01537~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when validationCache was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-01537)~^~ -VALIDATION_ERROR_3e400c04~^~N~^~None~^~vkDestroyValidationCacheEXT~^~VUID-vkDestroyValidationCacheEXT-validationCache-01538~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when validationCache was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-01538)~^~ -VALIDATION_ERROR_3e405601~^~Y~^~None~^~vkDestroyValidationCacheEXT~^~VUID-vkDestroyValidationCacheEXT-device-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-device-parameter)~^~implicit -VALIDATION_ERROR_3e40ec01~^~N~^~None~^~vkDestroyValidationCacheEXT~^~VUID-vkDestroyValidationCacheEXT-pAllocator-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_3e43c401~^~Y~^~None~^~vkDestroyValidationCacheEXT~^~VUID-vkDestroyValidationCacheEXT-validationCache-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If validationCache is not VK_NULL_HANDLE, validationCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-parameter)~^~implicit -VALIDATION_ERROR_3e43c407~^~Y~^~None~^~vkDestroyValidationCacheEXT~^~VUID-vkDestroyValidationCacheEXT-validationCache-parent~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'If validationCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-parent)~^~implicit -VALIDATION_ERROR_3e600c00~^~Y~^~None~^~vkMergeValidationCachesEXT~^~VUID-vkMergeValidationCachesEXT-dstCache-01536~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'dstCache must not appear in the list of source caches' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-dstCache-01536)~^~ -VALIDATION_ERROR_3e605601~^~Y~^~None~^~vkMergeValidationCachesEXT~^~VUID-vkMergeValidationCachesEXT-device-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-device-parameter)~^~implicit -VALIDATION_ERROR_3e606e01~^~Y~^~None~^~vkMergeValidationCachesEXT~^~VUID-vkMergeValidationCachesEXT-dstCache-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'dstCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-dstCache-parameter)~^~implicit -VALIDATION_ERROR_3e606e07~^~Y~^~None~^~vkMergeValidationCachesEXT~^~VUID-vkMergeValidationCachesEXT-dstCache-parent~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'dstCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-dstCache-parent)~^~implicit -VALIDATION_ERROR_3e623c01~^~Y~^~None~^~vkMergeValidationCachesEXT~^~VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkValidationCacheEXT handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter)~^~implicit -VALIDATION_ERROR_3e623c07~^~Y~^~None~^~vkMergeValidationCachesEXT~^~VUID-vkMergeValidationCachesEXT-pSrcCaches-parent~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'Each element of pSrcCaches must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-pSrcCaches-parent)~^~implicit -VALIDATION_ERROR_3e62ca1b~^~N~^~None~^~vkMergeValidationCachesEXT~^~VUID-vkMergeValidationCachesEXT-srcCacheCount-arraylength~^~(VK_EXT_validation_cache)~^~The spec valid usage text states 'srcCacheCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-srcCacheCount-arraylength)~^~implicit -VALIDATION_ERROR_3e800bf6~^~N~^~None~^~VkAttachmentSampleLocationsEXT~^~VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'attachmentIndex must be less than the attachmentCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531)~^~ -VALIDATION_ERROR_3e83c601~^~N~^~None~^~VkAttachmentSampleLocationsEXT~^~VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter)~^~implicit -VALIDATION_ERROR_3ea00bf8~^~N~^~None~^~VkSubpassSampleLocationsEXT~^~VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'subpassIndex must be less than the subpassCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532)~^~ -VALIDATION_ERROR_3ea3c601~^~N~^~None~^~VkSubpassSampleLocationsEXT~^~VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter~^~(VK_EXT_sample_locations)~^~The spec valid usage text states 'sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter)~^~implicit -VALIDATION_ERROR_3ec2b00b~^~N~^~None~^~VkPhysicalDevicePointClippingProperties~^~VUID-VkPhysicalDevicePointClippingProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDevicePointClippingProperties-sType-sType)~^~implicit -VALIDATION_ERROR_3ee00c01~^~N~^~None~^~VkInputAttachmentAspectReference~^~VUID-VkInputAttachmentAspectReference-aspectMask-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-aspectMask-parameter)~^~implicit -VALIDATION_ERROR_3ee00c03~^~N~^~None~^~VkInputAttachmentAspectReference~^~VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask)~^~implicit -VALIDATION_ERROR_3ee00c40~^~N~^~None~^~VkInputAttachmentAspectReference~^~VUID-VkInputAttachmentAspectReference-pCreateInfo-01568~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'There must be an input attachment at pCreateInfo::pSubpasses[subpass].pInputAttachments[inputAttachmentIndex].' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-pCreateInfo-01568)~^~ -VALIDATION_ERROR_3ee00c42~^~N~^~None~^~VkInputAttachmentAspectReference~^~VUID-VkInputAttachmentAspectReference-None-01569~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'The specified input attachment must have more than one aspect mask.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-None-01569)~^~ -VALIDATION_ERROR_3ee00c44~^~N~^~None~^~VkInputAttachmentAspectReference~^~VUID-VkInputAttachmentAspectReference-aspectMask-01570~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'aspectMask must be a subset of the aspect masks in the specified input attachment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-aspectMask-01570)~^~ -VALIDATION_ERROR_3f02b00b~^~N~^~None~^~VkRenderPassInputAttachmentAspectCreateInfo~^~VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3f03ce1b~^~N~^~None~^~VkRenderPassInputAttachmentAspectCreateInfo~^~VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'aspectReferenceCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength)~^~implicit -VALIDATION_ERROR_3f03d001~^~N~^~None~^~VkRenderPassInputAttachmentAspectCreateInfo~^~VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'pAspectReferences must be a valid pointer to an array of aspectReferenceCount valid VkInputAttachmentAspectReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter)~^~implicit -VALIDATION_ERROR_3f200c66~^~Y~^~InvalidImageViewUsageCreateInfo~^~VkImageViewUsageCreateInfo~^~VUID-VkImageViewUsageCreateInfo-usage-01587~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'usage must not include any set bits that were not set in the usage member of the VkImageCreateInfo structure used to create the image this image view is created from.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-usage-01587)~^~ -VALIDATION_ERROR_3f22b00b~^~N~^~None~^~VkImageViewUsageCreateInfo~^~VUID-VkImageViewUsageCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3f230601~^~Y~^~InvalidImageViewUsageCreateInfo~^~VkImageViewUsageCreateInfo~^~VUID-VkImageViewUsageCreateInfo-usage-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-usage-parameter)~^~implicit -VALIDATION_ERROR_3f230603~^~Y~^~InvalidImageViewUsageCreateInfo~^~VkImageViewUsageCreateInfo~^~VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask)~^~implicit -VALIDATION_ERROR_3f42b00b~^~N~^~None~^~VkPipelineTessellationDomainOriginStateCreateInfo~^~VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3f43d201~^~N~^~None~^~VkPipelineTessellationDomainOriginStateCreateInfo~^~VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance2)~^~The spec valid usage text states 'domainOrigin must be a valid VkTessellationDomainOrigin value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter)~^~implicit -VALIDATION_ERROR_3f600c54~^~N~^~None~^~VkImageFormatListCreateInfoKHR~^~VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01578~^~(VK_KHR_image_format_list)~^~The spec valid usage text states 'If viewFormatCount is not 0, all of the formats in the pViewFormats array must be compatible with the format specified in the format field of VkImageCreateInfo, as described in the compatibility table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01578)~^~ -VALIDATION_ERROR_3f600c56~^~N~^~None~^~VkImageFormatListCreateInfoKHR~^~VUID-VkImageFormatListCreateInfoKHR-flags-01579~^~(VK_KHR_image_format_list)~^~The spec valid usage text states 'If VkImageCreateInfo::flags does not contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, viewFormatCount must be 0 or 1.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-flags-01579)~^~ -VALIDATION_ERROR_3f600c58~^~N~^~None~^~VkImageFormatListCreateInfoKHR~^~VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01580~^~(VK_KHR_image_format_list)~^~The spec valid usage text states 'If viewFormatCount is not 0, VkImageCreateInfo::format must be in pViewFormats.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01580)~^~ -VALIDATION_ERROR_3f62b00b~^~N~^~None~^~VkImageFormatListCreateInfoKHR~^~VUID-VkImageFormatListCreateInfoKHR-sType-sType~^~(VK_KHR_image_format_list)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-sType-sType)~^~implicit -VALIDATION_ERROR_3f63e401~^~N~^~None~^~VkImageFormatListCreateInfoKHR~^~VUID-VkImageFormatListCreateInfoKHR-pViewFormats-parameter~^~(VK_KHR_image_format_list)~^~The spec valid usage text states 'If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-pViewFormats-parameter)~^~implicit -VALIDATION_ERROR_3f800ce2~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-format-01649~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'format must not be VK_FORMAT_UNDEFINED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01649)~^~ -VALIDATION_ERROR_3f800ce4~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-format-01650~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'format must support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01650)~^~ -VALIDATION_ERROR_3f800ce6~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_COSITED_EVEN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651)~^~ -VALIDATION_ERROR_3f800ce8~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_MIDPOINT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652)~^~ -VALIDATION_ERROR_3f800cea~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-format-01653~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'format must represent unsigned normalized values (i.e. the format must be a UNORM format)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01653)~^~ -VALIDATION_ERROR_3f800cec~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-None-01654~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the format has a _422 or _420 suffix:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-None-01654)~^~ -VALIDATION_ERROR_3f800cee~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to channels of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a channel which contains zero or one as a consequence of conversion to RGBA' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655)~^~ -VALIDATION_ERROR_3f800cf0~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, forceExplicitReconstruction must be FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656)~^~ -VALIDATION_ERROR_3f800cf2~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, chromaFilter must be VK_FILTER_NEAREST' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657)~^~ -VALIDATION_ERROR_3f800ee0~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-format-01904~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If an external format conversion is being created, format must be VK_FORMAT_UNDEFINED, otherwise it must not be VK_FORMAT_UNDEFINED.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01904)~^~ -VALIDATION_ERROR_3f802c01~^~N~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'components must be a valid VkComponentMapping structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter)~^~implicit -VALIDATION_ERROR_3f809201~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter)~^~implicit -VALIDATION_ERROR_3f81c40d~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkExternalFormatANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext)~^~implicit -VALIDATION_ERROR_3f82b00b~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3f83d401~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'ycbcrModel must be a valid VkSamplerYcbcrModelConversion value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter)~^~implicit -VALIDATION_ERROR_3f83d601~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'ycbcrRange must be a valid VkSamplerYcbcrRange value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter)~^~implicit -VALIDATION_ERROR_3f83d801~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'xChromaOffset must be a valid VkChromaLocation value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter)~^~implicit -VALIDATION_ERROR_3f83da01~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'yChromaOffset must be a valid VkChromaLocation value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter)~^~implicit -VALIDATION_ERROR_3f83dc01~^~Y~^~None~^~VkSamplerYcbcrConversionCreateInfo~^~VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'chromaFilter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter)~^~implicit -VALIDATION_ERROR_3fa00cd4~^~N~^~None~^~VkBindImagePlaneMemoryInfo~^~VUID-VkBindImagePlaneMemoryInfo-planeAspect-01642~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'planeAspect must be a single valid plane aspect for the image format (that is, planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT for "_2PLANE" formats and planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT for "_3PLANE" formats)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-planeAspect-01642)~^~ -VALIDATION_ERROR_3fa00cd6~^~N~^~None~^~VkBindImagePlaneMemoryInfo~^~VUID-VkBindImagePlaneMemoryInfo-None-01643~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'A single call to vkBindImageMemory2 must bind all or none of the planes of an image (i.e. bindings to all planes of an image must be made in a single vkBindImageMemory2 call), as separate bindings' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-None-01643)~^~ -VALIDATION_ERROR_3fa2b00b~^~N~^~None~^~VkBindImagePlaneMemoryInfo~^~VUID-VkBindImagePlaneMemoryInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3fa3de01~^~N~^~None~^~VkBindImagePlaneMemoryInfo~^~VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'planeAspect must be a valid VkImageAspectFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter)~^~implicit -VALIDATION_ERROR_3fc00c70~^~N~^~None~^~VkImagePlaneMemoryRequirementsInfo~^~VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-01592~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'planeAspect must be an aspect that exists in the format; that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-01592)~^~ -VALIDATION_ERROR_3fc2b00b~^~N~^~None~^~VkImagePlaneMemoryRequirementsInfo~^~VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType)~^~implicit -VALIDATION_ERROR_3fc3de01~^~N~^~None~^~VkImagePlaneMemoryRequirementsInfo~^~VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter~^~(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'planeAspect must be a valid VkImageAspectFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter)~^~implicit -VALIDATION_ERROR_3fe00ce0~^~N~^~None~^~vkCreateSamplerYcbcrConversion~^~VUID-vkCreateSamplerYcbcrConversion-None-01648~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'The sampler Y'CBCR conversion feature must be enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-None-01648)~^~ -VALIDATION_ERROR_3fe05601~^~Y~^~None~^~vkCreateSamplerYcbcrConversion~^~VUID-vkCreateSamplerYcbcrConversion-device-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-device-parameter)~^~implicit -VALIDATION_ERROR_3fe0ec01~^~N~^~None~^~vkCreateSamplerYcbcrConversion~^~VUID-vkCreateSamplerYcbcrConversion-pAllocator-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_3fe11e01~^~N~^~None~^~vkCreateSamplerYcbcrConversion~^~VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_3fe3e001~^~Y~^~None~^~vkCreateSamplerYcbcrConversion~^~VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter)~^~implicit -VALIDATION_ERROR_40000c8c~^~N~^~None~^~VkBindBufferMemoryDeviceGroupInfo~^~VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceIndexCount must either be zero or equal to the number of physical devices in the logical device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606)~^~ -VALIDATION_ERROR_40000c8e~^~N~^~None~^~VkBindBufferMemoryDeviceGroupInfo~^~VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'All elements of pDeviceIndices must be valid device indices' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607)~^~ -VALIDATION_ERROR_40013e01~^~N~^~None~^~VkBindBufferMemoryDeviceGroupInfo~^~VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter)~^~implicit -VALIDATION_ERROR_4002b00b~^~N~^~None~^~VkBindBufferMemoryDeviceGroupInfo~^~VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType)~^~implicit -VALIDATION_ERROR_40200cc2~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633)~^~ -VALIDATION_ERROR_40200cc4~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'deviceIndexCount must either be zero or equal to the number of physical devices in the logical device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634)~^~ -VALIDATION_ERROR_40200cc6~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'All elements of pDeviceIndices must be valid device indices.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635)~^~ -VALIDATION_ERROR_40200cc8~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636)~^~ -VALIDATION_ERROR_40200cca~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'Elements of pSplitInstanceBindRegions that correspond to the same instance of an image must not overlap.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637)~^~ -VALIDATION_ERROR_40200ccc~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'The offset.x member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of all non-metadata aspects of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638)~^~ -VALIDATION_ERROR_40200cce~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'The offset.y member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of all non-metadata aspects of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639)~^~ -VALIDATION_ERROR_40200cd0~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'The extent.width member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block width of all non-metadata aspects of the image, or else extent.width + offset.x must equal the width of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640)~^~ -VALIDATION_ERROR_40200cd2~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'The extent.height member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block height of all non-metadata aspects of the image, or else extent.height offset.y must equal the width of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641)~^~ -VALIDATION_ERROR_40213e01~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter)~^~implicit -VALIDATION_ERROR_4022b00b~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType)~^~implicit -VALIDATION_ERROR_4023fe01~^~N~^~None~^~VkBindImageMemoryDeviceGroupInfo~^~VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter~^~(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)~^~The spec valid usage text states 'If splitInstanceBindRegionCount is not 0, pSplitInstanceBindRegions must be a valid pointer to an array of splitInstanceBindRegionCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter)~^~implicit -VALIDATION_ERROR_40405601~^~Y~^~None~^~vkDestroySamplerYcbcrConversion~^~VUID-vkDestroySamplerYcbcrConversion-device-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-device-parameter)~^~implicit -VALIDATION_ERROR_4040ec01~^~N~^~None~^~vkDestroySamplerYcbcrConversion~^~VUID-vkDestroySamplerYcbcrConversion-pAllocator-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_4043e201~^~Y~^~None~^~vkDestroySamplerYcbcrConversion~^~VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter)~^~implicit -VALIDATION_ERROR_4043e207~^~Y~^~None~^~vkDestroySamplerYcbcrConversion~^~VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent)~^~implicit -VALIDATION_ERROR_4062b00b~^~N~^~None~^~VkPhysicalDeviceSamplerYcbcrConversionFeatures~^~VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType)~^~implicit -VALIDATION_ERROR_4082b00b~^~N~^~None~^~VkSamplerYcbcrConversionImageFormatProperties~^~VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType)~^~implicit -VALIDATION_ERROR_40a2b00b~^~N~^~None~^~VkSamplerYcbcrConversionInfo~^~VUID-VkSamplerYcbcrConversionInfo-sType-sType~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionInfo-sType-sType)~^~implicit -VALIDATION_ERROR_40a3e601~^~N~^~None~^~VkSamplerYcbcrConversionInfo~^~VUID-VkSamplerYcbcrConversionInfo-conversion-parameter~^~(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)~^~The spec valid usage text states 'conversion must be a valid VkSamplerYcbcrConversion handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionInfo-conversion-parameter)~^~implicit -VALIDATION_ERROR_40c2b00b~^~N~^~None~^~VkDeviceQueueGlobalPriorityCreateInfoEXT~^~VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType~^~(VK_EXT_global_priority)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_40c3ea01~^~N~^~None~^~VkDeviceQueueGlobalPriorityCreateInfoEXT~^~VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter~^~(VK_EXT_global_priority)~^~The spec valid usage text states 'globalPriority must be a valid VkQueueGlobalPriorityEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter)~^~implicit -VALIDATION_ERROR_40e05601~^~Y~^~None~^~vkGetShaderInfoAMD~^~VUID-vkGetShaderInfoAMD-device-parameter~^~(VK_AMD_shader_info)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-device-parameter)~^~implicit -VALIDATION_ERROR_40e27c01~^~Y~^~None~^~vkGetShaderInfoAMD~^~VUID-vkGetShaderInfoAMD-pipeline-parameter~^~(VK_AMD_shader_info)~^~The spec valid usage text states 'pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pipeline-parameter)~^~implicit -VALIDATION_ERROR_40e27c07~^~Y~^~None~^~vkGetShaderInfoAMD~^~VUID-vkGetShaderInfoAMD-pipeline-parent~^~(VK_AMD_shader_info)~^~The spec valid usage text states 'pipeline must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pipeline-parent)~^~implicit -VALIDATION_ERROR_40e39c01~^~Y~^~None~^~vkGetShaderInfoAMD~^~VUID-vkGetShaderInfoAMD-pInfo-parameter~^~(VK_AMD_shader_info)~^~The spec valid usage text states 'If the value referenced by pInfoSize is not 0, and pInfo is not NULL, pInfo must be a valid pointer to an array of pInfoSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pInfo-parameter)~^~implicit -VALIDATION_ERROR_40e3ec01~^~Y~^~None~^~vkGetShaderInfoAMD~^~VUID-vkGetShaderInfoAMD-shaderStage-parameter~^~(VK_AMD_shader_info)~^~The spec valid usage text states 'shaderStage must be a valid VkShaderStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-shaderStage-parameter)~^~implicit -VALIDATION_ERROR_40e3ee01~^~Y~^~None~^~vkGetShaderInfoAMD~^~VUID-vkGetShaderInfoAMD-infoType-parameter~^~(VK_AMD_shader_info)~^~The spec valid usage text states 'infoType must be a valid VkShaderInfoTypeAMD value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-infoType-parameter)~^~implicit -VALIDATION_ERROR_40e3f001~^~N~^~None~^~vkGetShaderInfoAMD~^~VUID-vkGetShaderInfoAMD-pInfoSize-parameter~^~(VK_AMD_shader_info)~^~The spec valid usage text states 'pInfoSize must be a valid pointer to a size_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pInfoSize-parameter)~^~implicit -VALIDATION_ERROR_41200da6~^~N~^~None~^~VkImportMemoryHostPointerInfoEXT~^~VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryPropertiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747)~^~ -VALIDATION_ERROR_41200da8~^~N~^~None~^~VkImportMemoryHostPointerInfoEXT~^~VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748)~^~ -VALIDATION_ERROR_41200daa~^~N~^~None~^~VkImportMemoryHostPointerInfoEXT~^~VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749)~^~ -VALIDATION_ERROR_41200dac~^~N~^~None~^~VkImportMemoryHostPointerInfoEXT~^~VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750)~^~ -VALIDATION_ERROR_41200dae~^~N~^~None~^~VkImportMemoryHostPointerInfoEXT~^~VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host mapped foreign memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751)~^~ -VALIDATION_ERROR_41209c01~^~N~^~None~^~VkImportMemoryHostPointerInfoEXT~^~VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter)~^~implicit -VALIDATION_ERROR_4122b00b~^~N~^~None~^~VkImportMemoryHostPointerInfoEXT~^~VUID-VkImportMemoryHostPointerInfoEXT-sType-sType~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4141c40d~^~N~^~None~^~VkMemoryHostPointerPropertiesEXT~^~VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_4142b00b~^~Y~^~None~^~VkMemoryHostPointerPropertiesEXT~^~VUID-VkMemoryHostPointerPropertiesEXT-sType-sType~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryHostPointerPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4162b00b~^~N~^~None~^~VkPhysicalDeviceExternalMemoryHostPropertiesEXT~^~VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_41800db0~^~N~^~None~^~vkGetMemoryHostPointerPropertiesEXT~^~VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752)~^~ -VALIDATION_ERROR_41800db2~^~N~^~None~^~vkGetMemoryHostPointerPropertiesEXT~^~VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753)~^~ -VALIDATION_ERROR_41800db4~^~N~^~None~^~vkGetMemoryHostPointerPropertiesEXT~^~VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to host memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754)~^~ -VALIDATION_ERROR_41800db6~^~N~^~None~^~vkGetMemoryHostPointerPropertiesEXT~^~VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to host mapped foreign memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755)~^~ -VALIDATION_ERROR_41805601~^~Y~^~None~^~vkGetMemoryHostPointerPropertiesEXT~^~VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter)~^~implicit -VALIDATION_ERROR_41809c01~^~Y~^~None~^~vkGetMemoryHostPointerPropertiesEXT~^~VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter)~^~implicit -VALIDATION_ERROR_4183f401~^~N~^~None~^~vkGetMemoryHostPointerPropertiesEXT~^~VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter~^~(VK_EXT_external_memory_host)~^~The spec valid usage text states 'pMemoryHostPointerProperties must be a valid pointer to a VkMemoryHostPointerPropertiesEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter)~^~implicit -VALIDATION_ERROR_41a2b00b~^~N~^~None~^~VkPhysicalDeviceConservativeRasterizationPropertiesEXT~^~VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType~^~(VK_EXT_conservative_rasterization)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_41c00dd2~^~N~^~None~^~VkPipelineRasterizationConservativeStateCreateInfoEXT~^~VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769~^~(VK_EXT_conservative_rasterization)~^~The spec valid usage text states 'extraPrimitiveOverestimationSize must be in the range of 0.0 to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769)~^~ -VALIDATION_ERROR_41c09005~^~N~^~None~^~VkPipelineRasterizationConservativeStateCreateInfoEXT~^~VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask~^~(VK_EXT_conservative_rasterization)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_41c2b00b~^~N~^~None~^~VkPipelineRasterizationConservativeStateCreateInfoEXT~^~VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType~^~(VK_EXT_conservative_rasterization)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_41c3f801~^~N~^~None~^~VkPipelineRasterizationConservativeStateCreateInfoEXT~^~VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter~^~(VK_EXT_conservative_rasterization)~^~The spec valid usage text states 'conservativeRasterizationMode must be a valid VkConservativeRasterizationModeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter)~^~implicit -VALIDATION_ERROR_41e00009~^~Y~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-commonparent~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commonparent)~^~implicit -VALIDATION_ERROR_41e00e0c~^~N~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'dstOffset must be less than or equal to the size of dstBuffer minus 4.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798)~^~ -VALIDATION_ERROR_41e00e0e~^~N~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799)~^~ -VALIDATION_ERROR_41e00e10~^~N~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800)~^~ -VALIDATION_ERROR_41e00e12~^~N~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'dstOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801)~^~ -VALIDATION_ERROR_41e02401~^~Y~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_41e02413~^~N~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_41e02415~^~N~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_41e06c01~^~Y~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter)~^~implicit -VALIDATION_ERROR_41e28401~^~Y~^~None~^~vkCmdWriteBufferMarkerAMD~^~VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter~^~(VK_AMD_buffer_marker)~^~The spec valid usage text states 'pipelineStage must be a valid VkPipelineStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter)~^~implicit -VALIDATION_ERROR_4201c40d~^~N~^~None~^~VkDescriptorSetLayoutSupport~^~VUID-VkDescriptorSetLayoutSupport-pNext-pNext~^~(VK_VERSION_1_1,VK_KHR_maintenance3)~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountLayoutSupportEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutSupport-pNext-pNext)~^~implicit -VALIDATION_ERROR_4202b00b~^~Y~^~None~^~VkDescriptorSetLayoutSupport~^~VUID-VkDescriptorSetLayoutSupport-sType-sType~^~(VK_VERSION_1_1,VK_KHR_maintenance3)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutSupport-sType-sType)~^~implicit -VALIDATION_ERROR_42200e64~^~N~^~None~^~VkDeviceQueueInfo2~^~VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842)~^~ -VALIDATION_ERROR_42200e66~^~N~^~None~^~VkDeviceQueueInfo2~^~VUID-VkDeviceQueueInfo2-queueIndex-01843~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'queueIndex must be less than the number of queues created for the specified queue family index and VkDeviceQueueCreateFlags member flags equal to this flags value when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-queueIndex-01843)~^~ -VALIDATION_ERROR_42209001~^~N~^~None~^~VkDeviceQueueInfo2~^~VUID-VkDeviceQueueInfo2-flags-parameter~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'flags must be a valid combination of VkDeviceQueueCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-flags-parameter)~^~implicit -VALIDATION_ERROR_42209003~^~Y~^~None~^~VkDeviceQueueInfo2~^~VUID-VkDeviceQueueInfo2-flags-requiredbitmask~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-flags-requiredbitmask)~^~implicit -VALIDATION_ERROR_4221c40d~^~Y~^~None~^~VkDeviceQueueInfo2~^~VUID-VkDeviceQueueInfo2-pNext-pNext~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-pNext-pNext)~^~implicit -VALIDATION_ERROR_4222b00b~^~Y~^~None~^~VkDeviceQueueInfo2~^~VUID-VkDeviceQueueInfo2-sType-sType~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-sType-sType)~^~implicit -VALIDATION_ERROR_4242b00b~^~N~^~None~^~VkPhysicalDeviceMaintenance3Properties~^~VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType~^~(VK_VERSION_1_1,VK_KHR_maintenance3)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType)~^~implicit -VALIDATION_ERROR_4262b00b~^~N~^~None~^~VkPhysicalDeviceProtectedMemoryFeatures~^~VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType)~^~implicit -VALIDATION_ERROR_4282b00b~^~N~^~None~^~VkPhysicalDeviceProtectedMemoryProperties~^~VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType)~^~implicit -VALIDATION_ERROR_42a2b00b~^~N~^~None~^~VkPhysicalDeviceShaderDrawParameterFeatures~^~VUID-VkPhysicalDeviceShaderDrawParameterFeatures-sType-sType~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderDrawParameterFeatures-sType-sType)~^~implicit -VALIDATION_ERROR_42c2b00b~^~N~^~None~^~VkPhysicalDeviceSubgroupProperties~^~VUID-VkPhysicalDeviceSubgroupProperties-sType-sType~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSubgroupProperties-sType-sType)~^~implicit -VALIDATION_ERROR_42e00e30~^~N~^~None~^~VkProtectedSubmitInfo~^~VUID-VkProtectedSubmitInfo-protectedSubmit-01816~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If the protected memory feature is not enabled, protectedSubmit must not be VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-protectedSubmit-01816)~^~ -VALIDATION_ERROR_42e00e32~^~N~^~None~^~VkProtectedSubmitInfo~^~VUID-VkProtectedSubmitInfo-protectedSubmit-01817~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If protectedSubmit is VK_TRUE, then each element of the pCommandBuffers array must be a protected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-protectedSubmit-01817)~^~ -VALIDATION_ERROR_42e00e34~^~N~^~None~^~VkProtectedSubmitInfo~^~VUID-VkProtectedSubmitInfo-protectedSubmit-01818~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If protectedSubmit is VK_FALSE, then each element of the pCommandBuffers array must be an unprotected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-protectedSubmit-01818)~^~ -VALIDATION_ERROR_42e00e36~^~N~^~None~^~VkProtectedSubmitInfo~^~VUID-VkProtectedSubmitInfo-pNext-01819~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'If the VkSubmitInfo::pNext chain does not include a VkProtectedSubmitInfo structure, then each element of the command buffer of the pCommandBuffers array must be an unprotected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-pNext-01819)~^~ -VALIDATION_ERROR_42e2b00b~^~N~^~None~^~VkProtectedSubmitInfo~^~VUID-VkProtectedSubmitInfo-sType-sType~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-sType-sType)~^~implicit -VALIDATION_ERROR_43040001~^~N~^~None~^~vkEnumerateInstanceVersion~^~VUID-vkEnumerateInstanceVersion-pApiVersion-parameter~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'pApiVersion must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumerateInstanceVersion-pApiVersion-parameter)~^~implicit -VALIDATION_ERROR_43205601~^~Y~^~None~^~vkGetDescriptorSetLayoutSupport~^~VUID-vkGetDescriptorSetLayoutSupport-device-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance3)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDescriptorSetLayoutSupport-device-parameter)~^~implicit -VALIDATION_ERROR_43211e01~^~N~^~None~^~vkGetDescriptorSetLayoutSupport~^~VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance3)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_43240201~^~N~^~None~^~vkGetDescriptorSetLayoutSupport~^~VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter~^~(VK_VERSION_1_1,VK_KHR_maintenance3)~^~The spec valid usage text states 'pSupport must be a valid pointer to a VkDescriptorSetLayoutSupport structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter)~^~implicit -VALIDATION_ERROR_43405601~^~Y~^~None~^~vkGetDeviceQueue2~^~VUID-vkGetDeviceQueue2-device-parameter~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceQueue2-device-parameter)~^~implicit -VALIDATION_ERROR_4341fc01~^~Y~^~None~^~vkGetDeviceQueue2~^~VUID-vkGetDeviceQueue2-pQueue-parameter~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'pQueue must be a valid pointer to a VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceQueue2-pQueue-parameter)~^~implicit -VALIDATION_ERROR_43440401~^~N~^~None~^~vkGetDeviceQueue2~^~VUID-vkGetDeviceQueue2-pQueueInfo-parameter~^~(VK_VERSION_1_1)~^~The spec valid usage text states 'pQueueInfo must be a valid pointer to a valid VkDeviceQueueInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceQueue2-pQueueInfo-parameter)~^~implicit -VALIDATION_ERROR_43600ee2~^~N~^~None~^~VkDebugUtilsObjectNameInfoEXT~^~VUID-VkDebugUtilsObjectNameInfoEXT-objectType-01905~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectType must not be VK_OBJECT_TYPE_UNKNOWN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectType-01905)~^~ -VALIDATION_ERROR_43600ee4~^~N~^~None~^~VkDebugUtilsObjectNameInfoEXT~^~VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01906~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectHandle must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01906)~^~ -VALIDATION_ERROR_43600ee6~^~N~^~None~^~VkDebugUtilsObjectNameInfoEXT~^~VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01907~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectHandle must be a Vulkan object of the type associated with objectType as defined in debugging-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01907)~^~ -VALIDATION_ERROR_4360da01~^~Y~^~None~^~VkDebugUtilsObjectNameInfoEXT~^~VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectType must be a valid VkObjectType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter)~^~implicit -VALIDATION_ERROR_4361c40d~^~Y~^~None~^~VkDebugUtilsObjectNameInfoEXT~^~VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_4361ce01~^~N~^~None~^~VkDebugUtilsObjectNameInfoEXT~^~VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If pObjectName is not NULL, pObjectName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter)~^~implicit -VALIDATION_ERROR_4362b00b~^~Y~^~None~^~VkDebugUtilsObjectNameInfoEXT~^~VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_43800ee8~^~N~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectType must not be VK_OBJECT_TYPE_UNKNOWN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908)~^~ -VALIDATION_ERROR_43800eea~^~N~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01909~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectHandle must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01909)~^~ -VALIDATION_ERROR_43800eec~^~N~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectHandle must be a Vulkan object of the type associated with objectType as defined in debugging-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910)~^~ -VALIDATION_ERROR_4380da01~^~Y~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectType must be a valid VkObjectType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter)~^~implicit -VALIDATION_ERROR_4381c40d~^~Y~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_43825a01~^~Y~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pTag must be a valid pointer to an array of tagSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter)~^~implicit -VALIDATION_ERROR_4382b00b~^~Y~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4382f41b~^~Y~^~None~^~VkDebugUtilsObjectTagInfoEXT~^~VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'tagSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength)~^~implicit -VALIDATION_ERROR_43a1c40d~^~Y~^~None~^~VkDebugUtilsLabelEXT~^~VUID-VkDebugUtilsLabelEXT-pNext-pNext~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsLabelEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_43a2b00b~^~Y~^~None~^~VkDebugUtilsLabelEXT~^~VUID-VkDebugUtilsLabelEXT-sType-sType~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsLabelEXT-sType-sType)~^~implicit -VALIDATION_ERROR_43a40801~^~Y~^~None~^~VkDebugUtilsLabelEXT~^~VUID-VkDebugUtilsLabelEXT-pLabelName-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pLabelName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsLabelEXT-pLabelName-parameter)~^~implicit -VALIDATION_ERROR_43c09005~^~Y~^~None~^~VkDebugUtilsMessengerCallbackDataEXT~^~VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_43c0d61b~^~N~^~None~^~VkDebugUtilsMessengerCallbackDataEXT~^~VUID-VkDebugUtilsMessengerCallbackDataEXT-objectCount-arraylength~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-objectCount-arraylength)~^~implicit -VALIDATION_ERROR_43c1b801~^~Y~^~None~^~VkDebugUtilsMessengerCallbackDataEXT~^~VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pMessage must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter)~^~implicit -VALIDATION_ERROR_43c1c40d~^~Y~^~None~^~VkDebugUtilsMessengerCallbackDataEXT~^~VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext)~^~implicit -VALIDATION_ERROR_43c2b00b~^~Y~^~None~^~VkDebugUtilsMessengerCallbackDataEXT~^~VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType)~^~implicit -VALIDATION_ERROR_43c42201~^~N~^~None~^~VkDebugUtilsMessengerCallbackDataEXT~^~VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If pMessageIdName is not NULL, pMessageIdName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter)~^~implicit -VALIDATION_ERROR_43e00ef4~^~N~^~None~^~VkDebugUtilsMessengerCreateInfoEXT~^~VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914)~^~ -VALIDATION_ERROR_43e09005~^~Y~^~None~^~VkDebugUtilsMessengerCreateInfoEXT~^~VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask)~^~implicit -VALIDATION_ERROR_43e2b00b~^~Y~^~None~^~VkDebugUtilsMessengerCreateInfoEXT~^~VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_43e40a01~^~N~^~None~^~VkDebugUtilsMessengerCreateInfoEXT~^~VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messageSeverity must be a valid combination of VkDebugUtilsMessageSeverityFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter)~^~implicit -VALIDATION_ERROR_43e40a03~^~Y~^~None~^~VkDebugUtilsMessengerCreateInfoEXT~^~VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messageSeverity must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask)~^~implicit -VALIDATION_ERROR_43e40c01~^~N~^~None~^~VkDebugUtilsMessengerCreateInfoEXT~^~VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messageType must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter)~^~implicit -VALIDATION_ERROR_43e40c03~^~Y~^~None~^~VkDebugUtilsMessengerCreateInfoEXT~^~VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messageType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask)~^~implicit -VALIDATION_ERROR_4400bc01~^~N~^~None~^~vkCreateDebugUtilsMessengerEXT~^~VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter)~^~implicit -VALIDATION_ERROR_4400ec01~^~N~^~None~^~vkCreateDebugUtilsMessengerEXT~^~VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_44011e01~^~N~^~None~^~vkCreateDebugUtilsMessengerEXT~^~VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDebugUtilsMessengerCreateInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter)~^~implicit -VALIDATION_ERROR_44041001~^~Y~^~None~^~vkCreateDebugUtilsMessengerEXT~^~VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pMessenger must be a valid pointer to a VkDebugUtilsMessengerEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter)~^~implicit -VALIDATION_ERROR_4420bc01~^~N~^~None~^~vkSubmitDebugUtilsMessageEXT~^~VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter)~^~implicit -VALIDATION_ERROR_44240a01~^~Y~^~None~^~vkSubmitDebugUtilsMessageEXT~^~VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messageSeverity must be a valid VkDebugUtilsMessageSeverityFlagBitsEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter)~^~implicit -VALIDATION_ERROR_44241201~^~N~^~None~^~vkSubmitDebugUtilsMessageEXT~^~VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messageTypes must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter)~^~implicit -VALIDATION_ERROR_44241203~^~Y~^~None~^~vkSubmitDebugUtilsMessageEXT~^~VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messageTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask)~^~implicit -VALIDATION_ERROR_44242801~^~N~^~None~^~vkSubmitDebugUtilsMessageEXT~^~VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pCallbackData must be a valid pointer to a valid VkDebugUtilsMessengerCallbackDataEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter)~^~implicit -VALIDATION_ERROR_4442b00b~^~N~^~None~^~VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT~^~VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType~^~(VK_EXT_vertex_attribute_divisor)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4462b00b~^~N~^~None~^~VkPipelineVertexInputDivisorStateCreateInfoEXT~^~VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType~^~(VK_EXT_vertex_attribute_divisor)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4464141b~^~N~^~None~^~VkPipelineVertexInputDivisorStateCreateInfoEXT~^~VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength~^~(VK_EXT_vertex_attribute_divisor)~^~The spec valid usage text states 'vertexBindingDivisorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength)~^~implicit -VALIDATION_ERROR_44641601~^~N~^~None~^~VkPipelineVertexInputDivisorStateCreateInfoEXT~^~VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter~^~(VK_EXT_vertex_attribute_divisor)~^~The spec valid usage text states 'pVertexBindingDivisors must be a valid pointer to an array of vertexBindingDivisorCount VkVertexInputBindingDivisorDescriptionEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter)~^~implicit -VALIDATION_ERROR_44800ecc~^~N~^~None~^~VkExternalFormatANDROID~^~VUID-VkExternalFormatANDROID-externalFormat-01894~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'externalFormat must be 0 or a value returned in the externalFormat member of VkAndroidHardwareBufferFormatPropertiesANDROID by an earlier call to vkGetAndroidHardwareBufferPropertiesANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFormatANDROID-externalFormat-01894)~^~ -VALIDATION_ERROR_4482b00b~^~N~^~None~^~VkExternalFormatANDROID~^~VUID-VkExternalFormatANDROID-sType-sType~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFormatANDROID-sType-sType)~^~implicit -VALIDATION_ERROR_44a00eb0~^~N~^~None~^~VkImportAndroidHardwareBufferInfoANDROID~^~VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If buffer is not NULL, Android hardware buffers must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880)~^~ -VALIDATION_ERROR_44a00eb2~^~N~^~None~^~VkImportAndroidHardwareBufferInfoANDROID~^~VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If buffer is not NULL, it must be a valid Android hardware buffer object with format and usage compatible with Vulkan as described by VkExternalMemoryHandleTypeFlagBits.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881)~^~ -VALIDATION_ERROR_44a01a01~^~N~^~None~^~VkImportAndroidHardwareBufferInfoANDROID~^~VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-parameter~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'buffer must be a valid pointer to a AHardwareBuffer value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-parameter)~^~implicit -VALIDATION_ERROR_44a2b00b~^~N~^~None~^~VkImportAndroidHardwareBufferInfoANDROID~^~VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType)~^~implicit -VALIDATION_ERROR_44c00eb4~^~N~^~None~^~VkMemoryGetAndroidHardwareBufferInfoANDROID~^~VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882)~^~ -VALIDATION_ERROR_44c00eb6~^~N~^~None~^~VkMemoryGetAndroidHardwareBufferInfoANDROID~^~VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo with non-NULL image member, then that image must already be bound to memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883)~^~ -VALIDATION_ERROR_44e00ef0~^~N~^~None~^~vkCmdEndDebugUtilsLabelEXT~^~VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912)~^~ -VALIDATION_ERROR_44e00ef2~^~N~^~None~^~vkCmdEndDebugUtilsLabelEXT~^~VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913)~^~ -VALIDATION_ERROR_44e02401~^~N~^~None~^~vkCmdEndDebugUtilsLabelEXT~^~VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_44e02413~^~N~^~None~^~vkCmdEndDebugUtilsLabelEXT~^~VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_44e02415~^~N~^~None~^~vkCmdEndDebugUtilsLabelEXT~^~VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_45000ef6~^~N~^~None~^~vkDestroyDebugUtilsMessengerEXT~^~VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If VkAllocationCallbacks were provided when messenger was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915)~^~ -VALIDATION_ERROR_45000ef8~^~N~^~None~^~vkDestroyDebugUtilsMessengerEXT~^~VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If no VkAllocationCallbacks were provided when messenger was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916)~^~ -VALIDATION_ERROR_4500bc01~^~N~^~None~^~vkDestroyDebugUtilsMessengerEXT~^~VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter)~^~implicit -VALIDATION_ERROR_4500ec01~^~N~^~None~^~vkDestroyDebugUtilsMessengerEXT~^~VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-parameter)~^~implicit -VALIDATION_ERROR_45042601~^~N~^~None~^~vkDestroyDebugUtilsMessengerEXT~^~VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messenger must be a valid VkDebugUtilsMessengerEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter)~^~implicit -VALIDATION_ERROR_45042607~^~N~^~None~^~vkDestroyDebugUtilsMessengerEXT~^~VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'messenger must have been created, allocated, or retrieved from instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent)~^~implicit -VALIDATION_ERROR_45200eb8~^~N~^~None~^~vkGetAndroidHardwareBufferPropertiesANDROID~^~VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884)~^~ -VALIDATION_ERROR_45201a01~^~Y~^~None~^~vkGetAndroidHardwareBufferPropertiesANDROID~^~VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-parameter~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'buffer must be a valid pointer to a valid AHardwareBuffer value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-parameter)~^~implicit -VALIDATION_ERROR_45205601~^~Y~^~None~^~vkGetAndroidHardwareBufferPropertiesANDROID~^~VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter)~^~implicit -VALIDATION_ERROR_4521f401~^~N~^~None~^~vkGetAndroidHardwareBufferPropertiesANDROID~^~VUID-vkGetAndroidHardwareBufferPropertiesANDROID-pProperties-parameter~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'pProperties must be a valid pointer to a VkAndroidHardwareBufferPropertiesANDROID structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-pProperties-parameter)~^~implicit -VALIDATION_ERROR_45400eee~^~N~^~None~^~vkQueueEndDebugUtilsLabelEXT~^~VUID-vkQueueEndDebugUtilsLabelEXT-None-01911~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'There must be an outstanding vkQueueBeginDebugUtilsLabelEXT command prior to the vkQueueEndDebugUtilsLabelEXT on the queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueEndDebugUtilsLabelEXT-None-01911)~^~ -VALIDATION_ERROR_45429c01~^~N~^~None~^~vkQueueEndDebugUtilsLabelEXT~^~VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter)~^~implicit -VALIDATION_ERROR_4562b00b~^~N~^~None~^~VkAndroidHardwareBufferUsageANDROID~^~VUID-VkAndroidHardwareBufferUsageANDROID-sType-sType~^~(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidHardwareBufferUsageANDROID-sType-sType)~^~implicit -VALIDATION_ERROR_45a05601~^~Y~^~None~^~vkGetMemoryAndroidHardwareBufferANDROID~^~VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter)~^~implicit -VALIDATION_ERROR_45a10001~^~Y~^~None~^~vkGetMemoryAndroidHardwareBufferANDROID~^~VUID-vkGetMemoryAndroidHardwareBufferANDROID-pBuffer-parameter~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'pBuffer must be a valid pointer to a valid pointer to a AHardwareBuffer value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryAndroidHardwareBufferANDROID-pBuffer-parameter)~^~implicit -VALIDATION_ERROR_45a39c01~^~N~^~None~^~vkGetMemoryAndroidHardwareBufferANDROID~^~VUID-vkGetMemoryAndroidHardwareBufferANDROID-pInfo-parameter~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'pInfo must be a valid pointer to a valid VkMemoryGetAndroidHardwareBufferInfoANDROID structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryAndroidHardwareBufferANDROID-pInfo-parameter)~^~implicit -VALIDATION_ERROR_45c2b00b~^~N~^~None~^~VkAndroidHardwareBufferFormatPropertiesANDROID~^~VUID-VkAndroidHardwareBufferFormatPropertiesANDROID-sType-sType~^~(VK_ANDROID_external_memory_android_hardware_buffer)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidHardwareBufferFormatPropertiesANDROID-sType-sType)~^~implicit -VALIDATION_ERROR_45e02401~^~N~^~None~^~vkCmdBeginDebugUtilsLabelEXT~^~VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_45e02413~^~N~^~None~^~vkCmdBeginDebugUtilsLabelEXT~^~VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_45e02415~^~N~^~None~^~vkCmdBeginDebugUtilsLabelEXT~^~VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_45e42401~^~N~^~None~^~vkCmdBeginDebugUtilsLabelEXT~^~VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter)~^~implicit -VALIDATION_ERROR_46002401~^~N~^~None~^~vkCmdInsertDebugUtilsLabelEXT~^~VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter)~^~implicit -VALIDATION_ERROR_46002413~^~N~^~None~^~vkCmdInsertDebugUtilsLabelEXT~^~VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording)~^~implicit -VALIDATION_ERROR_46002415~^~N~^~None~^~vkCmdInsertDebugUtilsLabelEXT~^~VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool)~^~implicit -VALIDATION_ERROR_46042401~^~N~^~None~^~vkCmdInsertDebugUtilsLabelEXT~^~VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter)~^~implicit -VALIDATION_ERROR_46229c01~^~N~^~None~^~vkQueueBeginDebugUtilsLabelEXT~^~VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter)~^~implicit -VALIDATION_ERROR_46242401~^~N~^~None~^~vkQueueBeginDebugUtilsLabelEXT~^~VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter)~^~implicit -VALIDATION_ERROR_46429c01~^~N~^~None~^~vkQueueInsertDebugUtilsLabelEXT~^~VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter)~^~implicit -VALIDATION_ERROR_46442401~^~N~^~None~^~vkQueueInsertDebugUtilsLabelEXT~^~VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter)~^~implicit -VALIDATION_ERROR_46605601~^~N~^~None~^~vkSetDebugUtilsObjectNameEXT~^~VUID-vkSetDebugUtilsObjectNameEXT-device-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectNameEXT-device-parameter)~^~implicit -VALIDATION_ERROR_4661c201~^~N~^~None~^~vkSetDebugUtilsObjectNameEXT~^~VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pNameInfo must be a valid pointer to a valid VkDebugUtilsObjectNameInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter)~^~implicit -VALIDATION_ERROR_46805601~^~N~^~None~^~vkSetDebugUtilsObjectTagEXT~^~VUID-vkSetDebugUtilsObjectTagEXT-device-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectTagEXT-device-parameter)~^~implicit -VALIDATION_ERROR_46825c01~^~N~^~None~^~vkSetDebugUtilsObjectTagEXT~^~VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter~^~(VK_EXT_debug_utils)~^~The spec valid usage text states 'pTagInfo must be a valid pointer to a valid VkDebugUtilsObjectTagInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter)~^~implicit -VALIDATION_ERROR_46a01774~^~Y~^~DescriptorIndexingSetLayout~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-bindingCount-03002~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If bindingCount is not zero, bindingCount must equal VkDescriptorSetLayoutCreateInfo::bindingCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-bindingCount-03002)~^~ -VALIDATION_ERROR_46a01776~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-flags-03003~^~(VK_EXT_descriptor_indexing)+(VK_KHR_push_descriptor)~^~The spec valid usage text states 'If VkDescriptorSetLayoutCreateInfo::flags includes VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT, or VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-flags-03003)~^~ -VALIDATION_ERROR_46a01778~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03004~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03004)~^~ -VALIDATION_ERROR_46a0177a~^~Y~^~DescriptorIndexingSetLayout~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformBufferUpdateAfterBind-03005~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformBufferUpdateAfterBind-03005)~^~ -VALIDATION_ERROR_46a0177c~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingSampledImageUpdateAfterBind-03006~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingSampledImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingSampledImageUpdateAfterBind-03006)~^~ -VALIDATION_ERROR_46a0177e~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageImageUpdateAfterBind-03007~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageImageUpdateAfterBind-03007)~^~ -VALIDATION_ERROR_46a01780~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageBufferUpdateAfterBind-03008~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageBufferUpdateAfterBind-03008)~^~ -VALIDATION_ERROR_46a01782~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformTexelBufferUpdateAfterBind-03009~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformTexelBufferUpdateAfterBind-03009)~^~ -VALIDATION_ERROR_46a01784~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageTexelBufferUpdateAfterBind-03010~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageTexelBufferUpdateAfterBind-03010)~^~ -VALIDATION_ERROR_46a01786~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-None-03011~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-None-03011)~^~ -VALIDATION_ERROR_46a01788~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUpdateUnusedWhilePending-03012~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUpdateUnusedWhilePending is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUpdateUnusedWhilePending-03012)~^~ -VALIDATION_ERROR_46a0178a~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingPartiallyBound-03013~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingPartiallyBound is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingPartiallyBound-03013)~^~ -VALIDATION_ERROR_46a0178c~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingVariableDescriptorCount-03014~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingVariableDescriptorCount is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingVariableDescriptorCount-03014)~^~ -VALIDATION_ERROR_46a0178e~^~Y~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03015~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, that element's descriptorType must not be VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03015)~^~ -VALIDATION_ERROR_46a2b00b~^~N~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-sType-sType~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_46a42a01~^~N~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-parameter~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If bindingCount is not 0, pBindingFlags must be a valid pointer to an array of bindingCount valid combinations of VkDescriptorBindingFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-parameter)~^~implicit -VALIDATION_ERROR_46a42a03~^~N~^~None~^~VkDescriptorSetLayoutBindingFlagsCreateInfoEXT~^~VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-requiredbitmask~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'Each element of pBindingFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-requiredbitmask)~^~implicit -VALIDATION_ERROR_46c017ca~^~Y~^~None~^~VkDescriptorSetVariableDescriptorCountAllocateInfoEXT~^~VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-descriptorSetCount-03045~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If descriptorSetCount is not zero, descriptorSetCount must equal VkDescriptorSetAllocateInfo::descriptorSetCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-descriptorSetCount-03045)~^~ -VALIDATION_ERROR_46c017cc~^~Y~^~DescriptorIndexingSetLayout~^~VkDescriptorSetVariableDescriptorCountAllocateInfoEXT~^~VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pSetLayouts-03046~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If VkDescriptorSetAllocateInfo::pSetLayouts[i] has a variable descriptor count binding, then pDescriptorCounts[i] must be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pSetLayouts-03046)~^~ -VALIDATION_ERROR_46c2b00b~^~N~^~None~^~VkDescriptorSetVariableDescriptorCountAllocateInfoEXT~^~VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-sType-sType~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-sType-sType)~^~implicit -VALIDATION_ERROR_46c42c01~^~N~^~None~^~VkDescriptorSetVariableDescriptorCountAllocateInfoEXT~^~VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pDescriptorCounts-parameter~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'If descriptorSetCount is not 0, pDescriptorCounts must be a valid pointer to an array of descriptorSetCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pDescriptorCounts-parameter)~^~implicit -VALIDATION_ERROR_46e2b00b~^~N~^~None~^~VkDescriptorSetVariableDescriptorCountLayoutSupportEXT~^~VUID-VkDescriptorSetVariableDescriptorCountLayoutSupportEXT-sType-sType~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountLayoutSupportEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4702b00b~^~N~^~None~^~VkPhysicalDeviceDescriptorIndexingFeaturesEXT~^~VUID-VkPhysicalDeviceDescriptorIndexingFeaturesEXT-sType-sType~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceDescriptorIndexingFeaturesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4722b00b~^~N~^~None~^~VkPhysicalDeviceDescriptorIndexingPropertiesEXT~^~VUID-VkPhysicalDeviceDescriptorIndexingPropertiesEXT-sType-sType~^~(VK_EXT_descriptor_indexing)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceDescriptorIndexingPropertiesEXT-sType-sType)~^~implicit -VALIDATION_ERROR_4742b00b~^~N~^~None~^~VkPhysicalDeviceShaderCorePropertiesAMD~^~VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType~^~(VK_AMD_shader_core_properties)~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType)~^~implicit -VALIDATION_ERROR_47600e9a~^~N~^~None~^~VkVertexInputBindingDivisorDescriptionEXT~^~VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869~^~(VK_EXT_vertex_attribute_divisor)~^~The spec valid usage text states 'binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869)~^~ -VALIDATION_ERROR_47600e9c~^~N~^~None~^~VkVertexInputBindingDivisorDescriptionEXT~^~VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870~^~(VK_EXT_vertex_attribute_divisor)~^~The spec valid usage text states 'divisor must be a value between 0 and VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870)~^~ -VALIDATION_ERROR_47600e9e~^~N~^~None~^~VkVertexInputBindingDivisorDescriptionEXT~^~VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871~^~(VK_EXT_vertex_attribute_divisor)~^~The spec valid usage text states 'VkVertexInputBindingDescription::inputRate must be of type VK_VERTEX_INPUT_RATE_INSTANCE for this binding.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871)~^~ - diff --git a/layers/vk_validation_error_messages.h b/layers/vk_validation_error_messages.h deleted file mode 100644 index a023c45b..00000000 --- a/layers/vk_validation_error_messages.h +++ /dev/null @@ -1,11826 +0,0 @@ -/* THIS FILE IS GENERATED. DO NOT EDIT. */ - -/* - * Vulkan - * - * Copyright (c) 2016 Google Inc. - * Copyright (c) 2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Tobin Ehlis - */ - -#pragma once - -// Disable auto-formatting for generated file -// clang-format off - -#include -#include - -// enum values for unique validation error codes -// Corresponding validation error message for each enum is given in the mapping table below -// When a given error occurs, these enum values should be passed to the as the messageCode -// parameter to the PFN_vkDebugReportCallbackEXT function -enum UNIQUE_VALIDATION_ERROR_CODE { - VALIDATION_ERROR_UNDEFINED = -1, - VALIDATION_ERROR_00000009 = 0x00000009, - VALIDATION_ERROR_00000a10 = 0x00000a10, - VALIDATION_ERROR_00000a12 = 0x00000a12, - VALIDATION_ERROR_00000a14 = 0x00000a14, - VALIDATION_ERROR_00000a16 = 0x00000a16, - VALIDATION_ERROR_00000d16 = 0x00000d16, - VALIDATION_ERROR_00000dea = 0x00000dea, - VALIDATION_ERROR_00000dec = 0x00000dec, - VALIDATION_ERROR_00000e18 = 0x00000e18, - VALIDATION_ERROR_00008801 = 0x00008801, - VALIDATION_ERROR_0001c40d = 0x0001c40d, - VALIDATION_ERROR_0002b00b = 0x0002b00b, - VALIDATION_ERROR_0002b801 = 0x0002b801, - VALIDATION_ERROR_0002f001 = 0x0002f001, - VALIDATION_ERROR_002004f0 = 0x002004f0, - VALIDATION_ERROR_002004f2 = 0x002004f2, - VALIDATION_ERROR_002004f4 = 0x002004f4, - VALIDATION_ERROR_002004f6 = 0x002004f6, - VALIDATION_ERROR_004009c0 = 0x004009c0, - VALIDATION_ERROR_00409005 = 0x00409005, - VALIDATION_ERROR_0041c40d = 0x0041c40d, - VALIDATION_ERROR_0042b00b = 0x0042b00b, - VALIDATION_ERROR_0060f001 = 0x0060f001, - VALIDATION_ERROR_00615c01 = 0x00615c01, - VALIDATION_ERROR_0061c40d = 0x0061c40d, - VALIDATION_ERROR_0062b00b = 0x0062b00b, - VALIDATION_ERROR_00800696 = 0x00800696, - VALIDATION_ERROR_00808e01 = 0x00808e01, - VALIDATION_ERROR_00809001 = 0x00809001, - VALIDATION_ERROR_00809201 = 0x00809201, - VALIDATION_ERROR_0080b801 = 0x0080b801, - VALIDATION_ERROR_0080c201 = 0x0080c201, - VALIDATION_ERROR_0082b401 = 0x0082b401, - VALIDATION_ERROR_0082e001 = 0x0082e001, - VALIDATION_ERROR_0082e201 = 0x0082e201, - VALIDATION_ERROR_0082e401 = 0x0082e401, - VALIDATION_ERROR_00a006b2 = 0x00a006b2, - VALIDATION_ERROR_00a0be01 = 0x00a0be01, - VALIDATION_ERROR_00c00009 = 0x00c00009, - VALIDATION_ERROR_00c00c72 = 0x00c00c72, - VALIDATION_ERROR_00c00c74 = 0x00c00c74, - VALIDATION_ERROR_00c00c76 = 0x00c00c76, - VALIDATION_ERROR_00c00c78 = 0x00c00c78, - VALIDATION_ERROR_00c00c7a = 0x00c00c7a, - VALIDATION_ERROR_00c00c7c = 0x00c00c7c, - VALIDATION_ERROR_00c00c7e = 0x00c00c7e, - VALIDATION_ERROR_00c00c80 = 0x00c00c80, - VALIDATION_ERROR_00c00c82 = 0x00c00c82, - VALIDATION_ERROR_00c00c84 = 0x00c00c84, - VALIDATION_ERROR_00c00c86 = 0x00c00c86, - VALIDATION_ERROR_00c00c88 = 0x00c00c88, - VALIDATION_ERROR_00c00c8a = 0x00c00c8a, - VALIDATION_ERROR_00c00ed8 = 0x00c00ed8, - VALIDATION_ERROR_00c01a01 = 0x00c01a01, - VALIDATION_ERROR_00c0c601 = 0x00c0c601, - VALIDATION_ERROR_00c1c40d = 0x00c1c40d, - VALIDATION_ERROR_00c2b00b = 0x00c2b00b, - VALIDATION_ERROR_00e00009 = 0x00e00009, - VALIDATION_ERROR_00e00c92 = 0x00e00c92, - VALIDATION_ERROR_00e00c94 = 0x00e00c94, - VALIDATION_ERROR_00e00c96 = 0x00e00c96, - VALIDATION_ERROR_00e00c98 = 0x00e00c98, - VALIDATION_ERROR_00e00c9a = 0x00e00c9a, - VALIDATION_ERROR_00e00c9c = 0x00e00c9c, - VALIDATION_ERROR_00e00c9e = 0x00e00c9e, - VALIDATION_ERROR_00e00ca0 = 0x00e00ca0, - VALIDATION_ERROR_00e00ca2 = 0x00e00ca2, - VALIDATION_ERROR_00e00ca4 = 0x00e00ca4, - VALIDATION_ERROR_00e00ca6 = 0x00e00ca6, - VALIDATION_ERROR_00e00ca8 = 0x00e00ca8, - VALIDATION_ERROR_00e00caa = 0x00e00caa, - VALIDATION_ERROR_00e00cac = 0x00e00cac, - VALIDATION_ERROR_00e00cae = 0x00e00cae, - VALIDATION_ERROR_00e00cb0 = 0x00e00cb0, - VALIDATION_ERROR_00e00cb2 = 0x00e00cb2, - VALIDATION_ERROR_00e00cb4 = 0x00e00cb4, - VALIDATION_ERROR_00e00cb6 = 0x00e00cb6, - VALIDATION_ERROR_00e00cb8 = 0x00e00cb8, - VALIDATION_ERROR_00e00cba = 0x00e00cba, - VALIDATION_ERROR_00e00cbc = 0x00e00cbc, - VALIDATION_ERROR_00e00cbe = 0x00e00cbe, - VALIDATION_ERROR_00e00cc0 = 0x00e00cc0, - VALIDATION_ERROR_00e00ede = 0x00e00ede, - VALIDATION_ERROR_00e0a001 = 0x00e0a001, - VALIDATION_ERROR_00e1c40d = 0x00e1c40d, - VALIDATION_ERROR_00e2b00b = 0x00e2b00b, - VALIDATION_ERROR_00e2b00f = 0x00e2b00f, - VALIDATION_ERROR_01000cd8 = 0x01000cd8, - VALIDATION_ERROR_0102b00b = 0x0102b00b, - VALIDATION_ERROR_0102f001 = 0x0102f001, - VALIDATION_ERROR_01200009 = 0x01200009, - VALIDATION_ERROR_01210201 = 0x01210201, - VALIDATION_ERROR_01218001 = 0x01218001, - VALIDATION_ERROR_01218c01 = 0x01218c01, - VALIDATION_ERROR_0121c40d = 0x0121c40d, - VALIDATION_ERROR_01223401 = 0x01223401, - VALIDATION_ERROR_01227601 = 0x01227601, - VALIDATION_ERROR_0122b00b = 0x0122b00b, - VALIDATION_ERROR_01400720 = 0x01400720, - VALIDATION_ERROR_01400722 = 0x01400722, - VALIDATION_ERROR_01400724 = 0x01400724, - VALIDATION_ERROR_01400726 = 0x01400726, - VALIDATION_ERROR_01400728 = 0x01400728, - VALIDATION_ERROR_0140072a = 0x0140072a, - VALIDATION_ERROR_0140072c = 0x0140072c, - VALIDATION_ERROR_01400730 = 0x01400730, - VALIDATION_ERROR_01400ade = 0x01400ade, - VALIDATION_ERROR_01400b16 = 0x01400b16, - VALIDATION_ERROR_01400c46 = 0x01400c46, - VALIDATION_ERROR_01400ebe = 0x01400ebe, - VALIDATION_ERROR_01400ec0 = 0x01400ec0, - VALIDATION_ERROR_01409001 = 0x01409001, - VALIDATION_ERROR_0141c40d = 0x0141c40d, - VALIDATION_ERROR_0142b00b = 0x0142b00b, - VALIDATION_ERROR_0142b00f = 0x0142b00f, - VALIDATION_ERROR_0142c001 = 0x0142c001, - VALIDATION_ERROR_01430601 = 0x01430601, - VALIDATION_ERROR_01430603 = 0x01430603, - VALIDATION_ERROR_01600182 = 0x01600182, - VALIDATION_ERROR_01600184 = 0x01600184, - VALIDATION_ERROR_01600186 = 0x01600186, - VALIDATION_ERROR_01600188 = 0x01600188, - VALIDATION_ERROR_0160018a = 0x0160018a, - VALIDATION_ERROR_0160018c = 0x0160018c, - VALIDATION_ERROR_0160018e = 0x0160018e, - VALIDATION_ERROR_01600190 = 0x01600190, - VALIDATION_ERROR_01600192 = 0x01600192, - VALIDATION_ERROR_01600196 = 0x01600196, - VALIDATION_ERROR_01600198 = 0x01600198, - VALIDATION_ERROR_0160019a = 0x0160019a, - VALIDATION_ERROR_0160019c = 0x0160019c, - VALIDATION_ERROR_0160019e = 0x0160019e, - VALIDATION_ERROR_016001a0 = 0x016001a0, - VALIDATION_ERROR_016001a2 = 0x016001a2, - VALIDATION_ERROR_016001a6 = 0x016001a6, - VALIDATION_ERROR_016001a8 = 0x016001a8, - VALIDATION_ERROR_016001aa = 0x016001aa, - VALIDATION_ERROR_016001ac = 0x016001ac, - VALIDATION_ERROR_01600c2c = 0x01600c2c, - VALIDATION_ERROR_01600c2e = 0x01600c2e, - VALIDATION_ERROR_01600c30 = 0x01600c30, - VALIDATION_ERROR_01600d8e = 0x01600d8e, - VALIDATION_ERROR_01600d90 = 0x01600d90, - VALIDATION_ERROR_01600d92 = 0x01600d92, - VALIDATION_ERROR_01600d94 = 0x01600d94, - VALIDATION_ERROR_01600d96 = 0x01600d96, - VALIDATION_ERROR_01600d98 = 0x01600d98, - VALIDATION_ERROR_01600d9a = 0x01600d9a, - VALIDATION_ERROR_0160aa01 = 0x0160aa01, - VALIDATION_ERROR_01800946 = 0x01800946, - VALIDATION_ERROR_01800948 = 0x01800948, - VALIDATION_ERROR_0180094a = 0x0180094a, - VALIDATION_ERROR_0180094c = 0x0180094c, - VALIDATION_ERROR_0180094e = 0x0180094e, - VALIDATION_ERROR_01800950 = 0x01800950, - VALIDATION_ERROR_01800952 = 0x01800952, - VALIDATION_ERROR_01800958 = 0x01800958, - VALIDATION_ERROR_01800dc6 = 0x01800dc6, - VALIDATION_ERROR_01800dc8 = 0x01800dc8, - VALIDATION_ERROR_01800dca = 0x01800dca, - VALIDATION_ERROR_01800f16 = 0x01800f16, - VALIDATION_ERROR_01801a01 = 0x01801a01, - VALIDATION_ERROR_01806801 = 0x01806801, - VALIDATION_ERROR_0181c40d = 0x0181c40d, - VALIDATION_ERROR_0182b00b = 0x0182b00b, - VALIDATION_ERROR_0182c401 = 0x0182c401, - VALIDATION_ERROR_01a0073a = 0x01a0073a, - VALIDATION_ERROR_01a0073c = 0x01a0073c, - VALIDATION_ERROR_01a00740 = 0x01a00740, - VALIDATION_ERROR_01a00742 = 0x01a00742, - VALIDATION_ERROR_01a00744 = 0x01a00744, - VALIDATION_ERROR_01a00746 = 0x01a00746, - VALIDATION_ERROR_01a00748 = 0x01a00748, - VALIDATION_ERROR_01a0074a = 0x01a0074a, - VALIDATION_ERROR_01a0074c = 0x01a0074c, - VALIDATION_ERROR_01a0074e = 0x01a0074e, - VALIDATION_ERROR_01a01a01 = 0x01a01a01, - VALIDATION_ERROR_01a09005 = 0x01a09005, - VALIDATION_ERROR_01a09201 = 0x01a09201, - VALIDATION_ERROR_01a1c40d = 0x01a1c40d, - VALIDATION_ERROR_01a2b00b = 0x01a2b00b, - VALIDATION_ERROR_01c00026 = 0x01c00026, - VALIDATION_ERROR_01c00028 = 0x01c00028, - VALIDATION_ERROR_01c0002a = 0x01c0002a, - VALIDATION_ERROR_01c00c01 = 0x01c00c01, - VALIDATION_ERROR_01c00c03 = 0x01c00c03, - VALIDATION_ERROR_01c00e22 = 0x01c00e22, - VALIDATION_ERROR_01c00e24 = 0x01c00e24, - VALIDATION_ERROR_01e0002c = 0x01e0002c, - VALIDATION_ERROR_0200002e = 0x0200002e, - VALIDATION_ERROR_02200009 = 0x02200009, - VALIDATION_ERROR_02200a66 = 0x02200a66, - VALIDATION_ERROR_02200a68 = 0x02200a68, - VALIDATION_ERROR_02200a6a = 0x02200a6a, - VALIDATION_ERROR_02200a6c = 0x02200a6c, - VALIDATION_ERROR_02200a6e = 0x02200a6e, - VALIDATION_ERROR_02200a70 = 0x02200a70, - VALIDATION_ERROR_02200a72 = 0x02200a72, - VALIDATION_ERROR_02200a74 = 0x02200a74, - VALIDATION_ERROR_02200a76 = 0x02200a76, - VALIDATION_ERROR_02200a78 = 0x02200a78, - VALIDATION_ERROR_02200a7a = 0x02200a7a, - VALIDATION_ERROR_0220b401 = 0x0220b401, - VALIDATION_ERROR_0220b61b = 0x0220b61b, - VALIDATION_ERROR_0220d801 = 0x0220d801, - VALIDATION_ERROR_02219401 = 0x02219401, - VALIDATION_ERROR_0221c40d = 0x0221c40d, - VALIDATION_ERROR_0222b00b = 0x0222b00b, - VALIDATION_ERROR_0222ba01 = 0x0222ba01, - VALIDATION_ERROR_0222bc01 = 0x0222bc01, - VALIDATION_ERROR_0222f601 = 0x0222f601, - VALIDATION_ERROR_02400009 = 0x02400009, - VALIDATION_ERROR_0240b401 = 0x0240b401, - VALIDATION_ERROR_0240d801 = 0x0240d801, - VALIDATION_ERROR_0241c40d = 0x0241c40d, - VALIDATION_ERROR_0242b00b = 0x0242b00b, - VALIDATION_ERROR_02600058 = 0x02600058, - VALIDATION_ERROR_02602801 = 0x02602801, - VALIDATION_ERROR_0260c001 = 0x0260c001, - VALIDATION_ERROR_0261c40d = 0x0261c40d, - VALIDATION_ERROR_0262b00b = 0x0262b00b, - VALIDATION_ERROR_0280006a = 0x0280006a, - VALIDATION_ERROR_0280006c = 0x0280006c, - VALIDATION_ERROR_0280006e = 0x0280006e, - VALIDATION_ERROR_02809001 = 0x02809001, - VALIDATION_ERROR_0281c40d = 0x0281c40d, - VALIDATION_ERROR_0282b00b = 0x0282b00b, - VALIDATION_ERROR_02a00009 = 0x02a00009, - VALIDATION_ERROR_02a00070 = 0x02a00070, - VALIDATION_ERROR_02a00072 = 0x02a00072, - VALIDATION_ERROR_02a00074 = 0x02a00074, - VALIDATION_ERROR_02a1c40d = 0x02a1c40d, - VALIDATION_ERROR_02a2b00b = 0x02a2b00b, - VALIDATION_ERROR_02c0004e = 0x02c0004e, - VALIDATION_ERROR_02c09001 = 0x02c09001, - VALIDATION_ERROR_02c1c40d = 0x02c1c40d, - VALIDATION_ERROR_02c2b00b = 0x02c2b00b, - VALIDATION_ERROR_02e00001 = 0x02e00001, - VALIDATION_ERROR_02e01001 = 0x02e01001, - VALIDATION_ERROR_02e09a01 = 0x02e09a01, - VALIDATION_ERROR_02e2a201 = 0x02e2a201, - VALIDATION_ERROR_03000009 = 0x03000009, - VALIDATION_ERROR_03000572 = 0x03000572, - VALIDATION_ERROR_03000574 = 0x03000574, - VALIDATION_ERROR_03000576 = 0x03000576, - VALIDATION_ERROR_03000578 = 0x03000578, - VALIDATION_ERROR_0300057a = 0x0300057a, - VALIDATION_ERROR_0300057c = 0x0300057c, - VALIDATION_ERROR_0300057e = 0x0300057e, - VALIDATION_ERROR_03000d2e = 0x03000d2e, - VALIDATION_ERROR_03009001 = 0x03009001, - VALIDATION_ERROR_0300be01 = 0x0300be01, - VALIDATION_ERROR_0301c40d = 0x0301c40d, - VALIDATION_ERROR_0302b00b = 0x0302b00b, - VALIDATION_ERROR_0302d801 = 0x0302d801, - VALIDATION_ERROR_03200009 = 0x03200009, - VALIDATION_ERROR_032002b2 = 0x032002b2, - VALIDATION_ERROR_032002b4 = 0x032002b4, - VALIDATION_ERROR_032002b6 = 0x032002b6, - VALIDATION_ERROR_032002b8 = 0x032002b8, - VALIDATION_ERROR_032002ba = 0x032002ba, - VALIDATION_ERROR_03200efc = 0x03200efc, - VALIDATION_ERROR_03200efe = 0x03200efe, - VALIDATION_ERROR_03200f00 = 0x03200f00, - VALIDATION_ERROR_03200f02 = 0x03200f02, - VALIDATION_ERROR_03207601 = 0x03207601, - VALIDATION_ERROR_0321c40d = 0x0321c40d, - VALIDATION_ERROR_0322b00b = 0x0322b00b, - VALIDATION_ERROR_0322d201 = 0x0322d201, - VALIDATION_ERROR_0340009e = 0x0340009e, - VALIDATION_ERROR_034000a0 = 0x034000a0, - VALIDATION_ERROR_03423201 = 0x03423201, - VALIDATION_ERROR_03427401 = 0x03427401, - VALIDATION_ERROR_0342b00b = 0x0342b00b, - VALIDATION_ERROR_0361a801 = 0x0361a801, - VALIDATION_ERROR_0361c40d = 0x0361c40d, - VALIDATION_ERROR_0362b00b = 0x0362b00b, - VALIDATION_ERROR_03800ba4 = 0x03800ba4, - VALIDATION_ERROR_03800ba6 = 0x03800ba6, - VALIDATION_ERROR_03800ba8 = 0x03800ba8, - VALIDATION_ERROR_0380da01 = 0x0380da01, - VALIDATION_ERROR_0381c40d = 0x0381c40d, - VALIDATION_ERROR_0381ce01 = 0x0381ce01, - VALIDATION_ERROR_0382b00b = 0x0382b00b, - VALIDATION_ERROR_03a00baa = 0x03a00baa, - VALIDATION_ERROR_03a00bac = 0x03a00bac, - VALIDATION_ERROR_03a00bae = 0x03a00bae, - VALIDATION_ERROR_03a0da01 = 0x03a0da01, - VALIDATION_ERROR_03a1c40d = 0x03a1c40d, - VALIDATION_ERROR_03a25a01 = 0x03a25a01, - VALIDATION_ERROR_03a2b00b = 0x03a2b00b, - VALIDATION_ERROR_03a2f41b = 0x03a2f41b, - VALIDATION_ERROR_03c00ad2 = 0x03c00ad2, - VALIDATION_ERROR_03c09001 = 0x03c09001, - VALIDATION_ERROR_03c2b00b = 0x03c2b00b, - VALIDATION_ERROR_03e2b00b = 0x03e2b00b, - VALIDATION_ERROR_040007c4 = 0x040007c4, - VALIDATION_ERROR_0402b00b = 0x0402b00b, - VALIDATION_ERROR_04200009 = 0x04200009, - VALIDATION_ERROR_04200512 = 0x04200512, - VALIDATION_ERROR_04200514 = 0x04200514, - VALIDATION_ERROR_04200516 = 0x04200516, - VALIDATION_ERROR_04200518 = 0x04200518, - VALIDATION_ERROR_0420051a = 0x0420051a, - VALIDATION_ERROR_0420051c = 0x0420051c, - VALIDATION_ERROR_0420051e = 0x0420051e, - VALIDATION_ERROR_04201a01 = 0x04201a01, - VALIDATION_ERROR_0420a001 = 0x0420a001, - VALIDATION_ERROR_0422b00b = 0x0422b00b, - VALIDATION_ERROR_044002a8 = 0x044002a8, - VALIDATION_ERROR_044002aa = 0x044002aa, - VALIDATION_ERROR_044002ac = 0x044002ac, - VALIDATION_ERROR_04401a01 = 0x04401a01, - VALIDATION_ERROR_04600009 = 0x04600009, - VALIDATION_ERROR_046002ae = 0x046002ae, - VALIDATION_ERROR_046002b0 = 0x046002b0, - VALIDATION_ERROR_04600c36 = 0x04600c36, - VALIDATION_ERROR_04600c38 = 0x04600c38, - VALIDATION_ERROR_0480025a = 0x0480025a, - VALIDATION_ERROR_04809001 = 0x04809001, - VALIDATION_ERROR_0481c40d = 0x0481c40d, - VALIDATION_ERROR_0481e401 = 0x0481e401, - VALIDATION_ERROR_0482881b = 0x0482881b, - VALIDATION_ERROR_0482b00b = 0x0482b00b, - VALIDATION_ERROR_04a0025c = 0x04a0025c, - VALIDATION_ERROR_04a30401 = 0x04a30401, - VALIDATION_ERROR_04c00009 = 0x04c00009, - VALIDATION_ERROR_04c00264 = 0x04c00264, - VALIDATION_ERROR_04c00266 = 0x04c00266, - VALIDATION_ERROR_04c00268 = 0x04c00268, - VALIDATION_ERROR_04c017c8 = 0x04c017c8, - VALIDATION_ERROR_04c04601 = 0x04c04601, - VALIDATION_ERROR_04c04a1b = 0x04c04a1b, - VALIDATION_ERROR_04c1c40d = 0x04c1c40d, - VALIDATION_ERROR_04c22c01 = 0x04c22c01, - VALIDATION_ERROR_04c2b00b = 0x04c2b00b, - VALIDATION_ERROR_04e00234 = 0x04e00234, - VALIDATION_ERROR_04e00236 = 0x04e00236, - VALIDATION_ERROR_04e00bcc = 0x04e00bcc, - VALIDATION_ERROR_04e04e01 = 0x04e04e01, - VALIDATION_ERROR_0500022e = 0x0500022e, - VALIDATION_ERROR_05000230 = 0x05000230, - VALIDATION_ERROR_05000232 = 0x05000232, - VALIDATION_ERROR_05001770 = 0x05001770, - VALIDATION_ERROR_05001772 = 0x05001772, - VALIDATION_ERROR_05009001 = 0x05009001, - VALIDATION_ERROR_0500fc01 = 0x0500fc01, - VALIDATION_ERROR_0501c40d = 0x0501c40d, - VALIDATION_ERROR_0502b00b = 0x0502b00b, - VALIDATION_ERROR_05200009 = 0x05200009, - VALIDATION_ERROR_052002bc = 0x052002bc, - VALIDATION_ERROR_052002be = 0x052002be, - VALIDATION_ERROR_052002c0 = 0x052002c0, - VALIDATION_ERROR_052002c2 = 0x052002c2, - VALIDATION_ERROR_05204c01 = 0x05204c01, - VALIDATION_ERROR_0520501b = 0x0520501b, - VALIDATION_ERROR_05209005 = 0x05209005, - VALIDATION_ERROR_05213201 = 0x05213201, - VALIDATION_ERROR_0521c40d = 0x0521c40d, - VALIDATION_ERROR_0522b00b = 0x0522b00b, - VALIDATION_ERROR_0522f801 = 0x0522f801, - VALIDATION_ERROR_054002c4 = 0x054002c4, - VALIDATION_ERROR_054002c6 = 0x054002c6, - VALIDATION_ERROR_05404e01 = 0x05404e01, - VALIDATION_ERROR_056002e8 = 0x056002e8, - VALIDATION_ERROR_056002ea = 0x056002ea, - VALIDATION_ERROR_056002ec = 0x056002ec, - VALIDATION_ERROR_05600e60 = 0x05600e60, - VALIDATION_ERROR_05609005 = 0x05609005, - VALIDATION_ERROR_05615a01 = 0x05615a01, - VALIDATION_ERROR_0561c40d = 0x0561c40d, - VALIDATION_ERROR_0561fe01 = 0x0561fe01, - VALIDATION_ERROR_05628e01 = 0x05628e01, - VALIDATION_ERROR_05629001 = 0x05629001, - VALIDATION_ERROR_0562a01b = 0x0562a01b, - VALIDATION_ERROR_0562b00b = 0x0562b00b, - VALIDATION_ERROR_0562b00f = 0x0562b00f, - VALIDATION_ERROR_05805801 = 0x05805801, - VALIDATION_ERROR_0581c40d = 0x0581c40d, - VALIDATION_ERROR_0582b00b = 0x0582b00b, - VALIDATION_ERROR_05a1c40d = 0x05a1c40d, - VALIDATION_ERROR_05a2b00b = 0x05a2b00b, - VALIDATION_ERROR_05c1c40d = 0x05c1c40d, - VALIDATION_ERROR_05c2b00b = 0x05c2b00b, - VALIDATION_ERROR_05e008bc = 0x05e008bc, - VALIDATION_ERROR_05e008be = 0x05e008be, - VALIDATION_ERROR_05e2b00b = 0x05e2b00b, - VALIDATION_ERROR_060000d4 = 0x060000d4, - VALIDATION_ERROR_060000d6 = 0x060000d6, - VALIDATION_ERROR_0602b00b = 0x0602b00b, - VALIDATION_ERROR_062002ee = 0x062002ee, - VALIDATION_ERROR_062002f0 = 0x062002f0, - VALIDATION_ERROR_062002f2 = 0x062002f2, - VALIDATION_ERROR_0621dc01 = 0x0621dc01, - VALIDATION_ERROR_0622b00b = 0x0622b00b, - VALIDATION_ERROR_06400a22 = 0x06400a22, - VALIDATION_ERROR_06400a24 = 0x06400a24, - VALIDATION_ERROR_06400a26 = 0x06400a26, - VALIDATION_ERROR_06400a28 = 0x06400a28, - VALIDATION_ERROR_06400a2a = 0x06400a2a, - VALIDATION_ERROR_06400a2c = 0x06400a2c, - VALIDATION_ERROR_06400a2e = 0x06400a2e, - VALIDATION_ERROR_0640ce01 = 0x0640ce01, - VALIDATION_ERROR_06414001 = 0x06414001, - VALIDATION_ERROR_0642b00b = 0x0642b00b, - VALIDATION_ERROR_06600712 = 0x06600712, - VALIDATION_ERROR_06600714 = 0x06600714, - VALIDATION_ERROR_06600716 = 0x06600716, - VALIDATION_ERROR_06600718 = 0x06600718, - VALIDATION_ERROR_06614201 = 0x06614201, - VALIDATION_ERROR_0662b00b = 0x0662b00b, - VALIDATION_ERROR_068000a4 = 0x068000a4, - VALIDATION_ERROR_068000a6 = 0x068000a6, - VALIDATION_ERROR_068000a8 = 0x068000a8, - VALIDATION_ERROR_068000aa = 0x068000aa, - VALIDATION_ERROR_068000ac = 0x068000ac, - VALIDATION_ERROR_06811201 = 0x06811201, - VALIDATION_ERROR_06823001 = 0x06823001, - VALIDATION_ERROR_06827201 = 0x06827201, - VALIDATION_ERROR_0682b00b = 0x0682b00b, - VALIDATION_ERROR_06a0d001 = 0x06a0d001, - VALIDATION_ERROR_06a0d003 = 0x06a0d003, - VALIDATION_ERROR_06a2b00b = 0x06a2b00b, - VALIDATION_ERROR_06c002fa = 0x06c002fa, - VALIDATION_ERROR_06c002fc = 0x06c002fc, - VALIDATION_ERROR_06c002fe = 0x06c002fe, - VALIDATION_ERROR_06c09001 = 0x06c09001, - VALIDATION_ERROR_06c1c40d = 0x06c1c40d, - VALIDATION_ERROR_06c20401 = 0x06c20401, - VALIDATION_ERROR_06c29e1b = 0x06c29e1b, - VALIDATION_ERROR_06c2b00b = 0x06c2b00b, - VALIDATION_ERROR_06e00342 = 0x06e00342, - VALIDATION_ERROR_06e00344 = 0x06e00344, - VALIDATION_ERROR_06e00346 = 0x06e00346, - VALIDATION_ERROR_07006201 = 0x07006201, - VALIDATION_ERROR_0701c40d = 0x0701c40d, - VALIDATION_ERROR_0702b00b = 0x0702b00b, - VALIDATION_ERROR_072009c4 = 0x072009c4, - VALIDATION_ERROR_072009c6 = 0x072009c6, - VALIDATION_ERROR_07209005 = 0x07209005, - VALIDATION_ERROR_0721c40d = 0x0721c40d, - VALIDATION_ERROR_0722b00b = 0x0722b00b, - VALIDATION_ERROR_0741c40d = 0x0741c40d, - VALIDATION_ERROR_07428a01 = 0x07428a01, - VALIDATION_ERROR_0742b00b = 0x0742b00b, - VALIDATION_ERROR_076009d2 = 0x076009d2, - VALIDATION_ERROR_076009d4 = 0x076009d4, - VALIDATION_ERROR_076009d6 = 0x076009d6, - VALIDATION_ERROR_0762b00b = 0x0762b00b, - VALIDATION_ERROR_078009c8 = 0x078009c8, - VALIDATION_ERROR_078009ca = 0x078009ca, - VALIDATION_ERROR_078009cc = 0x078009cc, - VALIDATION_ERROR_078009ce = 0x078009ce, - VALIDATION_ERROR_078009d0 = 0x078009d0, - VALIDATION_ERROR_07800a01 = 0x07800a01, - VALIDATION_ERROR_07806401 = 0x07806401, - VALIDATION_ERROR_07809005 = 0x07809005, - VALIDATION_ERROR_0781c40d = 0x0781c40d, - VALIDATION_ERROR_0782b00b = 0x0782b00b, - VALIDATION_ERROR_07830201 = 0x07830201, - VALIDATION_ERROR_07a00450 = 0x07a00450, - VALIDATION_ERROR_07a00452 = 0x07a00452, - VALIDATION_ERROR_07a00454 = 0x07a00454, - VALIDATION_ERROR_07c003e8 = 0x07c003e8, - VALIDATION_ERROR_07c003ea = 0x07c003ea, - VALIDATION_ERROR_07e09005 = 0x07e09005, - VALIDATION_ERROR_07e1c40d = 0x07e1c40d, - VALIDATION_ERROR_07e2b00b = 0x07e2b00b, - VALIDATION_ERROR_08000520 = 0x08000520, - VALIDATION_ERROR_08009e01 = 0x08009e01, - VALIDATION_ERROR_0802b00b = 0x0802b00b, - VALIDATION_ERROR_08209e01 = 0x08209e01, - VALIDATION_ERROR_0822b00b = 0x0822b00b, - VALIDATION_ERROR_08400522 = 0x08400522, - VALIDATION_ERROR_0840f401 = 0x0840f401, - VALIDATION_ERROR_0842b00b = 0x0842b00b, - VALIDATION_ERROR_0860f401 = 0x0860f401, - VALIDATION_ERROR_0862b00b = 0x0862b00b, - VALIDATION_ERROR_088008c8 = 0x088008c8, - VALIDATION_ERROR_08809e01 = 0x08809e01, - VALIDATION_ERROR_0882b00b = 0x0882b00b, - VALIDATION_ERROR_08a008ca = 0x08a008ca, - VALIDATION_ERROR_08a0f401 = 0x08a0f401, - VALIDATION_ERROR_08a2b00b = 0x08a2b00b, - VALIDATION_ERROR_08c09e01 = 0x08c09e01, - VALIDATION_ERROR_08c2b00b = 0x08c2b00b, - VALIDATION_ERROR_08e09e01 = 0x08e09e01, - VALIDATION_ERROR_08e09e03 = 0x08e09e03, - VALIDATION_ERROR_08e2b00b = 0x08e2b00b, - VALIDATION_ERROR_09009e01 = 0x09009e01, - VALIDATION_ERROR_0902b00b = 0x0902b00b, - VALIDATION_ERROR_09209001 = 0x09209001, - VALIDATION_ERROR_0921c40d = 0x0921c40d, - VALIDATION_ERROR_0922b00b = 0x0922b00b, - VALIDATION_ERROR_0922b00f = 0x0922b00f, - VALIDATION_ERROR_09400009 = 0x09400009, - VALIDATION_ERROR_094006d8 = 0x094006d8, - VALIDATION_ERROR_094006da = 0x094006da, - VALIDATION_ERROR_094006dc = 0x094006dc, - VALIDATION_ERROR_094006de = 0x094006de, - VALIDATION_ERROR_094006e0 = 0x094006e0, - VALIDATION_ERROR_094006e2 = 0x094006e2, - VALIDATION_ERROR_094006e4 = 0x094006e4, - VALIDATION_ERROR_094006e6 = 0x094006e6, - VALIDATION_ERROR_094006e8 = 0x094006e8, - VALIDATION_ERROR_094006ea = 0x094006ea, - VALIDATION_ERROR_094006ec = 0x094006ec, - VALIDATION_ERROR_094006ee = 0x094006ee, - VALIDATION_ERROR_094006f0 = 0x094006f0, - VALIDATION_ERROR_094006f2 = 0x094006f2, - VALIDATION_ERROR_094006f4 = 0x094006f4, - VALIDATION_ERROR_094006f6 = 0x094006f6, - VALIDATION_ERROR_09409005 = 0x09409005, - VALIDATION_ERROR_0940f201 = 0x0940f201, - VALIDATION_ERROR_0941c40d = 0x0941c40d, - VALIDATION_ERROR_0942ae01 = 0x0942ae01, - VALIDATION_ERROR_0942b00b = 0x0942b00b, - VALIDATION_ERROR_09600009 = 0x09600009, - VALIDATION_ERROR_096005a4 = 0x096005a4, - VALIDATION_ERROR_096005a6 = 0x096005a6, - VALIDATION_ERROR_096005a8 = 0x096005a8, - VALIDATION_ERROR_096005aa = 0x096005aa, - VALIDATION_ERROR_096005ac = 0x096005ac, - VALIDATION_ERROR_096005ae = 0x096005ae, - VALIDATION_ERROR_096005b0 = 0x096005b0, - VALIDATION_ERROR_096005b2 = 0x096005b2, - VALIDATION_ERROR_096005b4 = 0x096005b4, - VALIDATION_ERROR_096005b6 = 0x096005b6, - VALIDATION_ERROR_096005b8 = 0x096005b8, - VALIDATION_ERROR_096005ba = 0x096005ba, - VALIDATION_ERROR_096005bc = 0x096005bc, - VALIDATION_ERROR_096005be = 0x096005be, - VALIDATION_ERROR_096005c0 = 0x096005c0, - VALIDATION_ERROR_096005c2 = 0x096005c2, - VALIDATION_ERROR_096005c4 = 0x096005c4, - VALIDATION_ERROR_096005c6 = 0x096005c6, - VALIDATION_ERROR_096005c8 = 0x096005c8, - VALIDATION_ERROR_096005ca = 0x096005ca, - VALIDATION_ERROR_096005cc = 0x096005cc, - VALIDATION_ERROR_096005ce = 0x096005ce, - VALIDATION_ERROR_096005d0 = 0x096005d0, - VALIDATION_ERROR_096005d2 = 0x096005d2, - VALIDATION_ERROR_096005d4 = 0x096005d4, - VALIDATION_ERROR_096005d6 = 0x096005d6, - VALIDATION_ERROR_096005d8 = 0x096005d8, - VALIDATION_ERROR_096005da = 0x096005da, - VALIDATION_ERROR_096005dc = 0x096005dc, - VALIDATION_ERROR_096005de = 0x096005de, - VALIDATION_ERROR_096005e0 = 0x096005e0, - VALIDATION_ERROR_096005e2 = 0x096005e2, - VALIDATION_ERROR_096005e4 = 0x096005e4, - VALIDATION_ERROR_096005e6 = 0x096005e6, - VALIDATION_ERROR_096005e8 = 0x096005e8, - VALIDATION_ERROR_096005ea = 0x096005ea, - VALIDATION_ERROR_096005ec = 0x096005ec, - VALIDATION_ERROR_096005ee = 0x096005ee, - VALIDATION_ERROR_096005f0 = 0x096005f0, - VALIDATION_ERROR_096005f2 = 0x096005f2, - VALIDATION_ERROR_096005f4 = 0x096005f4, - VALIDATION_ERROR_096005f6 = 0x096005f6, - VALIDATION_ERROR_096005f8 = 0x096005f8, - VALIDATION_ERROR_09600b06 = 0x09600b06, - VALIDATION_ERROR_09600b08 = 0x09600b08, - VALIDATION_ERROR_09600bc2 = 0x09600bc2, - VALIDATION_ERROR_09600be2 = 0x09600be2, - VALIDATION_ERROR_09600be4 = 0x09600be4, - VALIDATION_ERROR_09600be6 = 0x09600be6, - VALIDATION_ERROR_09600be8 = 0x09600be8, - VALIDATION_ERROR_09600c3a = 0x09600c3a, - VALIDATION_ERROR_09600d30 = 0x09600d30, - VALIDATION_ERROR_09600d66 = 0x09600d66, - VALIDATION_ERROR_09600db8 = 0x09600db8, - VALIDATION_ERROR_09600dba = 0x09600dba, - VALIDATION_ERROR_09609001 = 0x09609001, - VALIDATION_ERROR_0960be01 = 0x0960be01, - VALIDATION_ERROR_09615601 = 0x09615601, - VALIDATION_ERROR_09619801 = 0x09619801, - VALIDATION_ERROR_0961c40d = 0x0961c40d, - VALIDATION_ERROR_09620801 = 0x09620801, - VALIDATION_ERROR_09623e01 = 0x09623e01, - VALIDATION_ERROR_09626801 = 0x09626801, - VALIDATION_ERROR_0962ae01 = 0x0962ae01, - VALIDATION_ERROR_0962b00b = 0x0962b00b, - VALIDATION_ERROR_0962da1b = 0x0962da1b, - VALIDATION_ERROR_09800a48 = 0x09800a48, - VALIDATION_ERROR_09809005 = 0x09809005, - VALIDATION_ERROR_0981c40d = 0x0981c40d, - VALIDATION_ERROR_0982b00b = 0x0982b00b, - VALIDATION_ERROR_09a001dc = 0x09a001dc, - VALIDATION_ERROR_09a001de = 0x09a001de, - VALIDATION_ERROR_09a001e0 = 0x09a001e0, - VALIDATION_ERROR_09a001e2 = 0x09a001e2, - VALIDATION_ERROR_09a001e4 = 0x09a001e4, - VALIDATION_ERROR_09a001e6 = 0x09a001e6, - VALIDATION_ERROR_09a001e8 = 0x09a001e8, - VALIDATION_ERROR_09a001ea = 0x09a001ea, - VALIDATION_ERROR_09a001ec = 0x09a001ec, - VALIDATION_ERROR_09a001ee = 0x09a001ee, - VALIDATION_ERROR_09a001f0 = 0x09a001f0, - VALIDATION_ERROR_09a001f2 = 0x09a001f2, - VALIDATION_ERROR_09a001f4 = 0x09a001f4, - VALIDATION_ERROR_09a001f6 = 0x09a001f6, - VALIDATION_ERROR_09a001f8 = 0x09a001f8, - VALIDATION_ERROR_09a07a01 = 0x09a07a01, - VALIDATION_ERROR_09a2d601 = 0x09a2d601, - VALIDATION_ERROR_09c00112 = 0x09c00112, - VALIDATION_ERROR_09c00114 = 0x09c00114, - VALIDATION_ERROR_09c00116 = 0x09c00116, - VALIDATION_ERROR_09c00118 = 0x09c00118, - VALIDATION_ERROR_09c0011a = 0x09c0011a, - VALIDATION_ERROR_09c0011c = 0x09c0011c, - VALIDATION_ERROR_09c0011e = 0x09c0011e, - VALIDATION_ERROR_09c00120 = 0x09c00120, - VALIDATION_ERROR_09c00122 = 0x09c00122, - VALIDATION_ERROR_09c00124 = 0x09c00124, - VALIDATION_ERROR_09c00126 = 0x09c00126, - VALIDATION_ERROR_09c0012c = 0x09c0012c, - VALIDATION_ERROR_09c0012e = 0x09c0012e, - VALIDATION_ERROR_09c00130 = 0x09c00130, - VALIDATION_ERROR_09c00132 = 0x09c00132, - VALIDATION_ERROR_09c0013a = 0x09c0013a, - VALIDATION_ERROR_09c0013c = 0x09c0013c, - VALIDATION_ERROR_09c0013e = 0x09c0013e, - VALIDATION_ERROR_09c00140 = 0x09c00140, - VALIDATION_ERROR_09c00144 = 0x09c00144, - VALIDATION_ERROR_09c00146 = 0x09c00146, - VALIDATION_ERROR_09c00148 = 0x09c00148, - VALIDATION_ERROR_09c0014a = 0x09c0014a, - VALIDATION_ERROR_09c00c1e = 0x09c00c1e, - VALIDATION_ERROR_09c00c20 = 0x09c00c20, - VALIDATION_ERROR_09c00c22 = 0x09c00c22, - VALIDATION_ERROR_09c00c24 = 0x09c00c24, - VALIDATION_ERROR_09c00c26 = 0x09c00c26, - VALIDATION_ERROR_09c00c28 = 0x09c00c28, - VALIDATION_ERROR_09c00c2a = 0x09c00c2a, - VALIDATION_ERROR_09c00d7e = 0x09c00d7e, - VALIDATION_ERROR_09c00d80 = 0x09c00d80, - VALIDATION_ERROR_09c00d82 = 0x09c00d82, - VALIDATION_ERROR_09c00d84 = 0x09c00d84, - VALIDATION_ERROR_09c00d86 = 0x09c00d86, - VALIDATION_ERROR_09c00d88 = 0x09c00d88, - VALIDATION_ERROR_09c00d8a = 0x09c00d8a, - VALIDATION_ERROR_09c00d8c = 0x09c00d8c, - VALIDATION_ERROR_09c00df2 = 0x09c00df2, - VALIDATION_ERROR_09c00df4 = 0x09c00df4, - VALIDATION_ERROR_09c00df6 = 0x09c00df6, - VALIDATION_ERROR_09c00df8 = 0x09c00df8, - VALIDATION_ERROR_09c00dfa = 0x09c00dfa, - VALIDATION_ERROR_09c00dfc = 0x09c00dfc, - VALIDATION_ERROR_09c00dfe = 0x09c00dfe, - VALIDATION_ERROR_09c00e00 = 0x09c00e00, - VALIDATION_ERROR_09c07a01 = 0x09c07a01, - VALIDATION_ERROR_09c2d601 = 0x09c2d601, - VALIDATION_ERROR_09e00758 = 0x09e00758, - VALIDATION_ERROR_09e0075a = 0x09e0075a, - VALIDATION_ERROR_09e0075c = 0x09e0075c, - VALIDATION_ERROR_09e0075e = 0x09e0075e, - VALIDATION_ERROR_09e00760 = 0x09e00760, - VALIDATION_ERROR_09e00762 = 0x09e00762, - VALIDATION_ERROR_09e00764 = 0x09e00764, - VALIDATION_ERROR_09e00766 = 0x09e00766, - VALIDATION_ERROR_09e00768 = 0x09e00768, - VALIDATION_ERROR_09e0076a = 0x09e0076a, - VALIDATION_ERROR_09e0076c = 0x09e0076c, - VALIDATION_ERROR_09e0076e = 0x09e0076e, - VALIDATION_ERROR_09e00770 = 0x09e00770, - VALIDATION_ERROR_09e00772 = 0x09e00772, - VALIDATION_ERROR_09e00774 = 0x09e00774, - VALIDATION_ERROR_09e00776 = 0x09e00776, - VALIDATION_ERROR_09e00778 = 0x09e00778, - VALIDATION_ERROR_09e0077a = 0x09e0077a, - VALIDATION_ERROR_09e0077c = 0x09e0077c, - VALIDATION_ERROR_09e0077e = 0x09e0077e, - VALIDATION_ERROR_09e00780 = 0x09e00780, - VALIDATION_ERROR_09e00782 = 0x09e00782, - VALIDATION_ERROR_09e00784 = 0x09e00784, - VALIDATION_ERROR_09e00786 = 0x09e00786, - VALIDATION_ERROR_09e00788 = 0x09e00788, - VALIDATION_ERROR_09e0078a = 0x09e0078a, - VALIDATION_ERROR_09e0078c = 0x09e0078c, - VALIDATION_ERROR_09e0078e = 0x09e0078e, - VALIDATION_ERROR_09e00790 = 0x09e00790, - VALIDATION_ERROR_09e00792 = 0x09e00792, - VALIDATION_ERROR_09e00794 = 0x09e00794, - VALIDATION_ERROR_09e00796 = 0x09e00796, - VALIDATION_ERROR_09e00798 = 0x09e00798, - VALIDATION_ERROR_09e0079a = 0x09e0079a, - VALIDATION_ERROR_09e0079c = 0x09e0079c, - VALIDATION_ERROR_09e0079e = 0x09e0079e, - VALIDATION_ERROR_09e007a0 = 0x09e007a0, - VALIDATION_ERROR_09e007b6 = 0x09e007b6, - VALIDATION_ERROR_09e007b8 = 0x09e007b8, - VALIDATION_ERROR_09e007bc = 0x09e007bc, - VALIDATION_ERROR_09e007be = 0x09e007be, - VALIDATION_ERROR_09e007c0 = 0x09e007c0, - VALIDATION_ERROR_09e007c2 = 0x09e007c2, - VALIDATION_ERROR_09e00ae0 = 0x09e00ae0, - VALIDATION_ERROR_09e00b18 = 0x09e00b18, - VALIDATION_ERROR_09e00b1a = 0x09e00b1a, - VALIDATION_ERROR_09e00b46 = 0x09e00b46, - VALIDATION_ERROR_09e00bfa = 0x09e00bfa, - VALIDATION_ERROR_09e00c48 = 0x09e00c48, - VALIDATION_ERROR_09e00c4a = 0x09e00c4a, - VALIDATION_ERROR_09e00c4c = 0x09e00c4c, - VALIDATION_ERROR_09e00c4e = 0x09e00c4e, - VALIDATION_ERROR_09e00c50 = 0x09e00c50, - VALIDATION_ERROR_09e00c52 = 0x09e00c52, - VALIDATION_ERROR_09e00ec2 = 0x09e00ec2, - VALIDATION_ERROR_09e00ec4 = 0x09e00ec4, - VALIDATION_ERROR_09e00ec6 = 0x09e00ec6, - VALIDATION_ERROR_09e00ec8 = 0x09e00ec8, - VALIDATION_ERROR_09e00eca = 0x09e00eca, - VALIDATION_ERROR_09e00f08 = 0x09e00f08, - VALIDATION_ERROR_09e00f0a = 0x09e00f0a, - VALIDATION_ERROR_09e09001 = 0x09e09001, - VALIDATION_ERROR_09e09201 = 0x09e09201, - VALIDATION_ERROR_09e0ac01 = 0x09e0ac01, - VALIDATION_ERROR_09e0b801 = 0x09e0b801, - VALIDATION_ERROR_09e1c40d = 0x09e1c40d, - VALIDATION_ERROR_09e2b00b = 0x09e2b00b, - VALIDATION_ERROR_09e2b00f = 0x09e2b00f, - VALIDATION_ERROR_09e2b401 = 0x09e2b401, - VALIDATION_ERROR_09e2c001 = 0x09e2c001, - VALIDATION_ERROR_09e2fa01 = 0x09e2fa01, - VALIDATION_ERROR_09e30601 = 0x09e30601, - VALIDATION_ERROR_09e30603 = 0x09e30603, - VALIDATION_ERROR_0a00095a = 0x0a00095a, - VALIDATION_ERROR_0a00095c = 0x0a00095c, - VALIDATION_ERROR_0a00095e = 0x0a00095e, - VALIDATION_ERROR_0a000960 = 0x0a000960, - VALIDATION_ERROR_0a000962 = 0x0a000962, - VALIDATION_ERROR_0a00096a = 0x0a00096a, - VALIDATION_ERROR_0a00096e = 0x0a00096e, - VALIDATION_ERROR_0a000970 = 0x0a000970, - VALIDATION_ERROR_0a000972 = 0x0a000972, - VALIDATION_ERROR_0a000974 = 0x0a000974, - VALIDATION_ERROR_0a000976 = 0x0a000976, - VALIDATION_ERROR_0a000978 = 0x0a000978, - VALIDATION_ERROR_0a00097a = 0x0a00097a, - VALIDATION_ERROR_0a000aca = 0x0a000aca, - VALIDATION_ERROR_0a000b9c = 0x0a000b9c, - VALIDATION_ERROR_0a000ba0 = 0x0a000ba0, - VALIDATION_ERROR_0a000cf4 = 0x0a000cf4, - VALIDATION_ERROR_0a000cf6 = 0x0a000cf6, - VALIDATION_ERROR_0a000d0e = 0x0a000d0e, - VALIDATION_ERROR_0a000d10 = 0x0a000d10, - VALIDATION_ERROR_0a000d12 = 0x0a000d12, - VALIDATION_ERROR_0a000d78 = 0x0a000d78, - VALIDATION_ERROR_0a000d7a = 0x0a000d7a, - VALIDATION_ERROR_0a000dcc = 0x0a000dcc, - VALIDATION_ERROR_0a000dce = 0x0a000dce, - VALIDATION_ERROR_0a000dd0 = 0x0a000dd0, - VALIDATION_ERROR_0a000f18 = 0x0a000f18, - VALIDATION_ERROR_0a006801 = 0x0a006801, - VALIDATION_ERROR_0a00a001 = 0x0a00a001, - VALIDATION_ERROR_0a00d401 = 0x0a00d401, - VALIDATION_ERROR_0a00dc01 = 0x0a00dc01, - VALIDATION_ERROR_0a01c40d = 0x0a01c40d, - VALIDATION_ERROR_0a02b00b = 0x0a02b00b, - VALIDATION_ERROR_0a02c401 = 0x0a02c401, - VALIDATION_ERROR_0a02ea01 = 0x0a02ea01, - VALIDATION_ERROR_0a200214 = 0x0a200214, - VALIDATION_ERROR_0a200216 = 0x0a200216, - VALIDATION_ERROR_0a200218 = 0x0a200218, - VALIDATION_ERROR_0a20021a = 0x0a20021a, - VALIDATION_ERROR_0a20021c = 0x0a20021c, - VALIDATION_ERROR_0a20021e = 0x0a20021e, - VALIDATION_ERROR_0a200220 = 0x0a200220, - VALIDATION_ERROR_0a200222 = 0x0a200222, - VALIDATION_ERROR_0a200224 = 0x0a200224, - VALIDATION_ERROR_0a200226 = 0x0a200226, - VALIDATION_ERROR_0a200228 = 0x0a200228, - VALIDATION_ERROR_0a20022a = 0x0a20022a, - VALIDATION_ERROR_0a20022c = 0x0a20022c, - VALIDATION_ERROR_0a207a01 = 0x0a207a01, - VALIDATION_ERROR_0a22d601 = 0x0a22d601, - VALIDATION_ERROR_0a400c01 = 0x0a400c01, - VALIDATION_ERROR_0a400c03 = 0x0a400c03, - VALIDATION_ERROR_0a60014e = 0x0a60014e, - VALIDATION_ERROR_0a600150 = 0x0a600150, - VALIDATION_ERROR_0a600c01 = 0x0a600c01, - VALIDATION_ERROR_0a600c03 = 0x0a600c03, - VALIDATION_ERROR_0a600d48 = 0x0a600d48, - VALIDATION_ERROR_0a800c01 = 0x0a800c01, - VALIDATION_ERROR_0a800c03 = 0x0a800c03, - VALIDATION_ERROR_0a800d0c = 0x0a800d0c, - VALIDATION_ERROR_0a800d70 = 0x0a800d70, - VALIDATION_ERROR_0a800d72 = 0x0a800d72, - VALIDATION_ERROR_0aa007c6 = 0x0aa007c6, - VALIDATION_ERROR_0aa2b00b = 0x0aa2b00b, - VALIDATION_ERROR_0aa2f001 = 0x0aa2f001, - VALIDATION_ERROR_0ac007d6 = 0x0ac007d6, - VALIDATION_ERROR_0ac007d8 = 0x0ac007d8, - VALIDATION_ERROR_0ac007da = 0x0ac007da, - VALIDATION_ERROR_0ac007dc = 0x0ac007dc, - VALIDATION_ERROR_0ac007de = 0x0ac007de, - VALIDATION_ERROR_0ac007e0 = 0x0ac007e0, - VALIDATION_ERROR_0ac007e2 = 0x0ac007e2, - VALIDATION_ERROR_0ac007e4 = 0x0ac007e4, - VALIDATION_ERROR_0ac007e6 = 0x0ac007e6, - VALIDATION_ERROR_0ac007e8 = 0x0ac007e8, - VALIDATION_ERROR_0ac007ea = 0x0ac007ea, - VALIDATION_ERROR_0ac007ec = 0x0ac007ec, - VALIDATION_ERROR_0ac007ee = 0x0ac007ee, - VALIDATION_ERROR_0ac007f0 = 0x0ac007f0, - VALIDATION_ERROR_0ac007f4 = 0x0ac007f4, - VALIDATION_ERROR_0ac007f6 = 0x0ac007f6, - VALIDATION_ERROR_0ac007f8 = 0x0ac007f8, - VALIDATION_ERROR_0ac007fa = 0x0ac007fa, - VALIDATION_ERROR_0ac00b8c = 0x0ac00b8c, - VALIDATION_ERROR_0ac00b90 = 0x0ac00b90, - VALIDATION_ERROR_0ac00b94 = 0x0ac00b94, - VALIDATION_ERROR_0ac00b96 = 0x0ac00b96, - VALIDATION_ERROR_0ac00b98 = 0x0ac00b98, - VALIDATION_ERROR_0ac00b9a = 0x0ac00b9a, - VALIDATION_ERROR_0ac00c5e = 0x0ac00c5e, - VALIDATION_ERROR_0ac00c60 = 0x0ac00c60, - VALIDATION_ERROR_0ac00c62 = 0x0ac00c62, - VALIDATION_ERROR_0ac00c64 = 0x0ac00c64, - VALIDATION_ERROR_0ac00d6c = 0x0ac00d6c, - VALIDATION_ERROR_0ac00d6e = 0x0ac00d6e, - VALIDATION_ERROR_0ac00dbe = 0x0ac00dbe, - VALIDATION_ERROR_0ac00dc0 = 0x0ac00dc0, - VALIDATION_ERROR_0ac00dc2 = 0x0ac00dc2, - VALIDATION_ERROR_0ac00dc4 = 0x0ac00dc4, - VALIDATION_ERROR_0ac00ed0 = 0x0ac00ed0, - VALIDATION_ERROR_0ac02c01 = 0x0ac02c01, - VALIDATION_ERROR_0ac09005 = 0x0ac09005, - VALIDATION_ERROR_0ac09201 = 0x0ac09201, - VALIDATION_ERROR_0ac0a001 = 0x0ac0a001, - VALIDATION_ERROR_0ac1c40d = 0x0ac1c40d, - VALIDATION_ERROR_0ac2b00b = 0x0ac2b00b, - VALIDATION_ERROR_0ac2b00f = 0x0ac2b00f, - VALIDATION_ERROR_0ac2ea01 = 0x0ac2ea01, - VALIDATION_ERROR_0ac30801 = 0x0ac30801, - VALIDATION_ERROR_0ae00536 = 0x0ae00536, - VALIDATION_ERROR_0ae00538 = 0x0ae00538, - VALIDATION_ERROR_0ae0053a = 0x0ae0053a, - VALIDATION_ERROR_0ae0053c = 0x0ae0053c, - VALIDATION_ERROR_0ae00be0 = 0x0ae00be0, - VALIDATION_ERROR_0ae00da4 = 0x0ae00da4, - VALIDATION_ERROR_0ae09c01 = 0x0ae09c01, - VALIDATION_ERROR_0ae2b00b = 0x0ae2b00b, - VALIDATION_ERROR_0b000524 = 0x0b000524, - VALIDATION_ERROR_0b000526 = 0x0b000526, - VALIDATION_ERROR_0b000528 = 0x0b000528, - VALIDATION_ERROR_0b00052a = 0x0b00052a, - VALIDATION_ERROR_0b000b3e = 0x0b000b3e, - VALIDATION_ERROR_0b000b40 = 0x0b000b40, - VALIDATION_ERROR_0b000b42 = 0x0b000b42, - VALIDATION_ERROR_0b000bdc = 0x0b000bdc, - VALIDATION_ERROR_0b000bde = 0x0b000bde, - VALIDATION_ERROR_0b009c01 = 0x0b009c01, - VALIDATION_ERROR_0b02b00b = 0x0b02b00b, - VALIDATION_ERROR_0b200a5e = 0x0b200a5e, - VALIDATION_ERROR_0b200a60 = 0x0b200a60, - VALIDATION_ERROR_0b209c01 = 0x0b209c01, - VALIDATION_ERROR_0b22b00b = 0x0b22b00b, - VALIDATION_ERROR_0b4008ee = 0x0b4008ee, - VALIDATION_ERROR_0b400c10 = 0x0b400c10, - VALIDATION_ERROR_0b409001 = 0x0b409001, - VALIDATION_ERROR_0b409c01 = 0x0b409c01, - VALIDATION_ERROR_0b41c40d = 0x0b41c40d, - VALIDATION_ERROR_0b42b00b = 0x0b42b00b, - VALIDATION_ERROR_0b42b801 = 0x0b42b801, - VALIDATION_ERROR_0b6008e8 = 0x0b6008e8, - VALIDATION_ERROR_0b600b74 = 0x0b600b74, - VALIDATION_ERROR_0b600b76 = 0x0b600b76, - VALIDATION_ERROR_0b600b78 = 0x0b600b78, - VALIDATION_ERROR_0b600b7a = 0x0b600b7a, - VALIDATION_ERROR_0b600c0c = 0x0b600c0c, - VALIDATION_ERROR_0b600c0e = 0x0b600c0e, - VALIDATION_ERROR_0b609001 = 0x0b609001, - VALIDATION_ERROR_0b609c01 = 0x0b609c01, - VALIDATION_ERROR_0b61c40d = 0x0b61c40d, - VALIDATION_ERROR_0b62b00b = 0x0b62b00b, - VALIDATION_ERROR_0b62b801 = 0x0b62b801, - VALIDATION_ERROR_0b800a86 = 0x0b800a86, - VALIDATION_ERROR_0b800a88 = 0x0b800a88, - VALIDATION_ERROR_0b800a8a = 0x0b800a8a, - VALIDATION_ERROR_0b800a8c = 0x0b800a8c, - VALIDATION_ERROR_0b800a8e = 0x0b800a8e, - VALIDATION_ERROR_0b809001 = 0x0b809001, - VALIDATION_ERROR_0b809003 = 0x0b809003, - VALIDATION_ERROR_0b81c40d = 0x0b81c40d, - VALIDATION_ERROR_0b826001 = 0x0b826001, - VALIDATION_ERROR_0b827e01 = 0x0b827e01, - VALIDATION_ERROR_0b82b00b = 0x0b82b00b, - VALIDATION_ERROR_0b82fc1b = 0x0b82fc1b, - VALIDATION_ERROR_0ba00a7c = 0x0ba00a7c, - VALIDATION_ERROR_0ba00a7e = 0x0ba00a7e, - VALIDATION_ERROR_0ba00a80 = 0x0ba00a80, - VALIDATION_ERROR_0ba2fe01 = 0x0ba2fe01, - VALIDATION_ERROR_0bc00a82 = 0x0bc00a82, - VALIDATION_ERROR_0bc00a84 = 0x0bc00a84, - VALIDATION_ERROR_0bc01a01 = 0x0bc01a01, - VALIDATION_ERROR_0bc2fe01 = 0x0bc2fe01, - VALIDATION_ERROR_0be09005 = 0x0be09005, - VALIDATION_ERROR_0be0ee01 = 0x0be0ee01, - VALIDATION_ERROR_0be1c40d = 0x0be1c40d, - VALIDATION_ERROR_0be28e01 = 0x0be28e01, - VALIDATION_ERROR_0be29001 = 0x0be29001, - VALIDATION_ERROR_0be2b00b = 0x0be2b00b, - VALIDATION_ERROR_0be2b00f = 0x0be2b00f, - VALIDATION_ERROR_0c000a4a = 0x0c000a4a, - VALIDATION_ERROR_0c009005 = 0x0c009005, - VALIDATION_ERROR_0c01c40d = 0x0c01c40d, - VALIDATION_ERROR_0c02b00b = 0x0c02b00b, - VALIDATION_ERROR_0c200558 = 0x0c200558, - VALIDATION_ERROR_0c20055a = 0x0c20055a, - VALIDATION_ERROR_0c20055c = 0x0c20055c, - VALIDATION_ERROR_0c20055e = 0x0c20055e, - VALIDATION_ERROR_0c200ada = 0x0c200ada, - VALIDATION_ERROR_0c200adc = 0x0c200adc, - VALIDATION_ERROR_0c20c601 = 0x0c20c601, - VALIDATION_ERROR_0c21c40d = 0x0c21c40d, - VALIDATION_ERROR_0c22b00b = 0x0c22b00b, - VALIDATION_ERROR_0c400546 = 0x0c400546, - VALIDATION_ERROR_0c400548 = 0x0c400548, - VALIDATION_ERROR_0c409001 = 0x0c409001, - VALIDATION_ERROR_0c42b00b = 0x0c42b00b, - VALIDATION_ERROR_0c6004fc = 0x0c6004fc, - VALIDATION_ERROR_0c6004fe = 0x0c6004fe, - VALIDATION_ERROR_0c600500 = 0x0c600500, - VALIDATION_ERROR_0c600502 = 0x0c600502, - VALIDATION_ERROR_0c600506 = 0x0c600506, - VALIDATION_ERROR_0c600508 = 0x0c600508, - VALIDATION_ERROR_0c60050a = 0x0c60050a, - VALIDATION_ERROR_0c60050c = 0x0c60050c, - VALIDATION_ERROR_0c60050e = 0x0c60050e, - VALIDATION_ERROR_0c600510 = 0x0c600510, - VALIDATION_ERROR_0c600d9c = 0x0c600d9c, - VALIDATION_ERROR_0c600d9e = 0x0c600d9e, - VALIDATION_ERROR_0c600da0 = 0x0c600da0, - VALIDATION_ERROR_0c600da2 = 0x0c600da2, - VALIDATION_ERROR_0c600ea0 = 0x0c600ea0, - VALIDATION_ERROR_0c600ea2 = 0x0c600ea2, - VALIDATION_ERROR_0c600ea4 = 0x0c600ea4, - VALIDATION_ERROR_0c600ea6 = 0x0c600ea6, - VALIDATION_ERROR_0c61c40d = 0x0c61c40d, - VALIDATION_ERROR_0c62b00b = 0x0c62b00b, - VALIDATION_ERROR_0c62b00f = 0x0c62b00f, - VALIDATION_ERROR_0c806801 = 0x0c806801, - VALIDATION_ERROR_0c81c40d = 0x0c81c40d, - VALIDATION_ERROR_0c82b00b = 0x0c82b00b, - VALIDATION_ERROR_0c82c401 = 0x0c82c401, - VALIDATION_ERROR_0ca009de = 0x0ca009de, - VALIDATION_ERROR_0ca009e0 = 0x0ca009e0, - VALIDATION_ERROR_0ca09005 = 0x0ca09005, - VALIDATION_ERROR_0ca1c40d = 0x0ca1c40d, - VALIDATION_ERROR_0ca2b00b = 0x0ca2b00b, - VALIDATION_ERROR_0cc00a96 = 0x0cc00a96, - VALIDATION_ERROR_0cc00a98 = 0x0cc00a98, - VALIDATION_ERROR_0cc00a9a = 0x0cc00a9a, - VALIDATION_ERROR_0cc00a9c = 0x0cc00a9c, - VALIDATION_ERROR_0cc00a9e = 0x0cc00a9e, - VALIDATION_ERROR_0cc00aa0 = 0x0cc00aa0, - VALIDATION_ERROR_0cc0d61b = 0x0cc0d61b, - VALIDATION_ERROR_0cc1c40d = 0x0cc1c40d, - VALIDATION_ERROR_0cc1c601 = 0x0cc1c601, - VALIDATION_ERROR_0cc1c801 = 0x0cc1c801, - VALIDATION_ERROR_0cc1ca01 = 0x0cc1ca01, - VALIDATION_ERROR_0cc1ca03 = 0x0cc1ca03, - VALIDATION_ERROR_0cc2b00b = 0x0cc2b00b, - VALIDATION_ERROR_0ce00009 = 0x0ce00009, - VALIDATION_ERROR_0ce00ab2 = 0x0ce00ab2, - VALIDATION_ERROR_0ce04801 = 0x0ce04801, - VALIDATION_ERROR_0ce09001 = 0x0ce09001, - VALIDATION_ERROR_0ce09003 = 0x0ce09003, - VALIDATION_ERROR_0ce28201 = 0x0ce28201, - VALIDATION_ERROR_0ce30401 = 0x0ce30401, - VALIDATION_ERROR_0d000aae = 0x0d000aae, - VALIDATION_ERROR_0d009001 = 0x0d009001, - VALIDATION_ERROR_0d009003 = 0x0d009003, - VALIDATION_ERROR_0d030401 = 0x0d030401, - VALIDATION_ERROR_0d200ab6 = 0x0d200ab6, - VALIDATION_ERROR_0d201a01 = 0x0d201a01, - VALIDATION_ERROR_0d209001 = 0x0d209001, - VALIDATION_ERROR_0d209003 = 0x0d209003, - VALIDATION_ERROR_0d20b201 = 0x0d20b201, - VALIDATION_ERROR_0d230401 = 0x0d230401, - VALIDATION_ERROR_0d400ab0 = 0x0d400ab0, - VALIDATION_ERROR_0d409001 = 0x0d409001, - VALIDATION_ERROR_0d409003 = 0x0d409003, - VALIDATION_ERROR_0d427c01 = 0x0d427c01, - VALIDATION_ERROR_0d430401 = 0x0d430401, - VALIDATION_ERROR_0d600ab8 = 0x0d600ab8, - VALIDATION_ERROR_0d609001 = 0x0d609001, - VALIDATION_ERROR_0d609003 = 0x0d609003, - VALIDATION_ERROR_0d628201 = 0x0d628201, - VALIDATION_ERROR_0d62dc01 = 0x0d62dc01, - VALIDATION_ERROR_0d62dc03 = 0x0d62dc03, - VALIDATION_ERROR_0d630401 = 0x0d630401, - VALIDATION_ERROR_0d800ab4 = 0x0d800ab4, - VALIDATION_ERROR_0d801a01 = 0x0d801a01, - VALIDATION_ERROR_0d809001 = 0x0d809001, - VALIDATION_ERROR_0d809003 = 0x0d809003, - VALIDATION_ERROR_0d830401 = 0x0d830401, - VALIDATION_ERROR_0da2b00b = 0x0da2b00b, - VALIDATION_ERROR_0dc09001 = 0x0dc09001, - VALIDATION_ERROR_0dc09c01 = 0x0dc09c01, - VALIDATION_ERROR_0dc1c40d = 0x0dc1c40d, - VALIDATION_ERROR_0dc2b00b = 0x0dc2b00b, - VALIDATION_ERROR_0dc30601 = 0x0dc30601, - VALIDATION_ERROR_0dc30603 = 0x0dc30603, - VALIDATION_ERROR_0de09c01 = 0x0de09c01, - VALIDATION_ERROR_0de2b00b = 0x0de2b00b, - VALIDATION_ERROR_0e009c01 = 0x0e009c01, - VALIDATION_ERROR_0e01c40d = 0x0e01c40d, - VALIDATION_ERROR_0e02b00b = 0x0e02b00b, - VALIDATION_ERROR_0e42b00b = 0x0e42b00b, - VALIDATION_ERROR_0e609001 = 0x0e609001, - VALIDATION_ERROR_0e609201 = 0x0e609201, - VALIDATION_ERROR_0e61c40d = 0x0e61c40d, - VALIDATION_ERROR_0e62b00b = 0x0e62b00b, - VALIDATION_ERROR_0e62fa01 = 0x0e62fa01, - VALIDATION_ERROR_0e630401 = 0x0e630401, - VALIDATION_ERROR_0e630601 = 0x0e630601, - VALIDATION_ERROR_0e630603 = 0x0e630603, - VALIDATION_ERROR_0e800488 = 0x0e800488, - VALIDATION_ERROR_0e80048a = 0x0e80048a, - VALIDATION_ERROR_0e82b00b = 0x0e82b00b, - VALIDATION_ERROR_0ea2b00b = 0x0ea2b00b, - VALIDATION_ERROR_0ec0088e = 0x0ec0088e, - VALIDATION_ERROR_0ec09201 = 0x0ec09201, - VALIDATION_ERROR_0ec1c40d = 0x0ec1c40d, - VALIDATION_ERROR_0ec2b00b = 0x0ec2b00b, - VALIDATION_ERROR_0ec2b401 = 0x0ec2b401, - VALIDATION_ERROR_0ec2fa01 = 0x0ec2fa01, - VALIDATION_ERROR_0ec30401 = 0x0ec30401, - VALIDATION_ERROR_0ec30601 = 0x0ec30601, - VALIDATION_ERROR_0ec30603 = 0x0ec30603, - VALIDATION_ERROR_0ee1c40d = 0x0ee1c40d, - VALIDATION_ERROR_0ee2b00b = 0x0ee2b00b, - VALIDATION_ERROR_0ee2ec01 = 0x0ee2ec01, - VALIDATION_ERROR_0f000600 = 0x0f000600, - VALIDATION_ERROR_0f000602 = 0x0f000602, - VALIDATION_ERROR_0f009005 = 0x0f009005, - VALIDATION_ERROR_0f019601 = 0x0f019601, - VALIDATION_ERROR_0f01c40d = 0x0f01c40d, - VALIDATION_ERROR_0f02b00b = 0x0f02b00b, - VALIDATION_ERROR_0f2004c0 = 0x0f2004c0, - VALIDATION_ERROR_0f2004c2 = 0x0f2004c2, - VALIDATION_ERROR_0f2004c4 = 0x0f2004c4, - VALIDATION_ERROR_0f2004c6 = 0x0f2004c6, - VALIDATION_ERROR_0f200801 = 0x0f200801, - VALIDATION_ERROR_0f200afc = 0x0f200afc, - VALIDATION_ERROR_0f200afe = 0x0f200afe, - VALIDATION_ERROR_0f200b00 = 0x0f200b00, - VALIDATION_ERROR_0f200b02 = 0x0f200b02, - VALIDATION_ERROR_0f200b04 = 0x0f200b04, - VALIDATION_ERROR_0f202001 = 0x0f202001, - VALIDATION_ERROR_0f202201 = 0x0f202201, - VALIDATION_ERROR_0f206a01 = 0x0f206a01, - VALIDATION_ERROR_0f207001 = 0x0f207001, - VALIDATION_ERROR_0f22c601 = 0x0f22c601, - VALIDATION_ERROR_0f22cc01 = 0x0f22cc01, - VALIDATION_ERROR_0f4004ba = 0x0f4004ba, - VALIDATION_ERROR_0f4004bc = 0x0f4004bc, - VALIDATION_ERROR_0f4004be = 0x0f4004be, - VALIDATION_ERROR_0f409005 = 0x0f409005, - VALIDATION_ERROR_0f40f201 = 0x0f40f201, - VALIDATION_ERROR_0f41c40d = 0x0f41c40d, - VALIDATION_ERROR_0f42b00b = 0x0f42b00b, - VALIDATION_ERROR_0f6004ac = 0x0f6004ac, - VALIDATION_ERROR_0f601201 = 0x0f601201, - VALIDATION_ERROR_0f604001 = 0x0f604001, - VALIDATION_ERROR_0f609005 = 0x0f609005, - VALIDATION_ERROR_0f609601 = 0x0f609601, - VALIDATION_ERROR_0f61c40d = 0x0f61c40d, - VALIDATION_ERROR_0f62b00b = 0x0f62b00b, - VALIDATION_ERROR_0f80048c = 0x0f80048c, - VALIDATION_ERROR_0f805e01 = 0x0f805e01, - VALIDATION_ERROR_0f809005 = 0x0f809005, - VALIDATION_ERROR_0f82b00b = 0x0f82b00b, - VALIDATION_ERROR_0fa00b44 = 0x0fa00b44, - VALIDATION_ERROR_0fa07c1b = 0x0fa07c1b, - VALIDATION_ERROR_0fa09005 = 0x0fa09005, - VALIDATION_ERROR_0fa15801 = 0x0fa15801, - VALIDATION_ERROR_0fa1c40d = 0x0fa1c40d, - VALIDATION_ERROR_0fa2b00b = 0x0fa2b00b, - VALIDATION_ERROR_0fc00358 = 0x0fc00358, - VALIDATION_ERROR_0fc0035a = 0x0fc0035a, - VALIDATION_ERROR_0fc0035c = 0x0fc0035c, - VALIDATION_ERROR_0fc09005 = 0x0fc09005, - VALIDATION_ERROR_0fc1c40d = 0x0fc1c40d, - VALIDATION_ERROR_0fc2b00b = 0x0fc2b00b, - VALIDATION_ERROR_0fc30001 = 0x0fc30001, - VALIDATION_ERROR_0fe0023c = 0x0fe0023c, - VALIDATION_ERROR_0fe0023e = 0x0fe0023e, - VALIDATION_ERROR_0fe00240 = 0x0fe00240, - VALIDATION_ERROR_0fe00242 = 0x0fe00242, - VALIDATION_ERROR_0fe00244 = 0x0fe00244, - VALIDATION_ERROR_0fe00246 = 0x0fe00246, - VALIDATION_ERROR_0fe00248 = 0x0fe00248, - VALIDATION_ERROR_0fe0024a = 0x0fe0024a, - VALIDATION_ERROR_0fe00d18 = 0x0fe00d18, - VALIDATION_ERROR_0fe00d1a = 0x0fe00d1a, - VALIDATION_ERROR_0fe00d1c = 0x0fe00d1c, - VALIDATION_ERROR_0fe00d1e = 0x0fe00d1e, - VALIDATION_ERROR_0fe00d20 = 0x0fe00d20, - VALIDATION_ERROR_0fe00d22 = 0x0fe00d22, - VALIDATION_ERROR_0fe00d24 = 0x0fe00d24, - VALIDATION_ERROR_0fe00d26 = 0x0fe00d26, - VALIDATION_ERROR_0fe00d28 = 0x0fe00d28, - VALIDATION_ERROR_0fe01790 = 0x0fe01790, - VALIDATION_ERROR_0fe01792 = 0x0fe01792, - VALIDATION_ERROR_0fe01794 = 0x0fe01794, - VALIDATION_ERROR_0fe01796 = 0x0fe01796, - VALIDATION_ERROR_0fe01798 = 0x0fe01798, - VALIDATION_ERROR_0fe0179a = 0x0fe0179a, - VALIDATION_ERROR_0fe0179c = 0x0fe0179c, - VALIDATION_ERROR_0fe0179e = 0x0fe0179e, - VALIDATION_ERROR_0fe017a0 = 0x0fe017a0, - VALIDATION_ERROR_0fe017a2 = 0x0fe017a2, - VALIDATION_ERROR_0fe017a4 = 0x0fe017a4, - VALIDATION_ERROR_0fe017a6 = 0x0fe017a6, - VALIDATION_ERROR_0fe017a8 = 0x0fe017a8, - VALIDATION_ERROR_0fe017aa = 0x0fe017aa, - VALIDATION_ERROR_0fe017ac = 0x0fe017ac, - VALIDATION_ERROR_0fe017ae = 0x0fe017ae, - VALIDATION_ERROR_0fe017b0 = 0x0fe017b0, - VALIDATION_ERROR_0fe017b2 = 0x0fe017b2, - VALIDATION_ERROR_0fe017b4 = 0x0fe017b4, - VALIDATION_ERROR_0fe017b6 = 0x0fe017b6, - VALIDATION_ERROR_0fe017b8 = 0x0fe017b8, - VALIDATION_ERROR_0fe017ba = 0x0fe017ba, - VALIDATION_ERROR_0fe017bc = 0x0fe017bc, - VALIDATION_ERROR_0fe017be = 0x0fe017be, - VALIDATION_ERROR_0fe017c0 = 0x0fe017c0, - VALIDATION_ERROR_0fe017c2 = 0x0fe017c2, - VALIDATION_ERROR_0fe017c4 = 0x0fe017c4, - VALIDATION_ERROR_0fe017c6 = 0x0fe017c6, - VALIDATION_ERROR_0fe09005 = 0x0fe09005, - VALIDATION_ERROR_0fe1c40d = 0x0fe1c40d, - VALIDATION_ERROR_0fe1f801 = 0x0fe1f801, - VALIDATION_ERROR_0fe22c01 = 0x0fe22c01, - VALIDATION_ERROR_0fe2b00b = 0x0fe2b00b, - VALIDATION_ERROR_10000620 = 0x10000620, - VALIDATION_ERROR_10000622 = 0x10000622, - VALIDATION_ERROR_10000624 = 0x10000624, - VALIDATION_ERROR_10000b0e = 0x10000b0e, - VALIDATION_ERROR_10009005 = 0x10009005, - VALIDATION_ERROR_1001c40d = 0x1001c40d, - VALIDATION_ERROR_10022201 = 0x10022201, - VALIDATION_ERROR_1002a801 = 0x1002a801, - VALIDATION_ERROR_1002b00b = 0x1002b00b, - VALIDATION_ERROR_1002b00f = 0x1002b00f, - VALIDATION_ERROR_1020061c = 0x1020061c, - VALIDATION_ERROR_10200b0a = 0x10200b0a, - VALIDATION_ERROR_10200b0c = 0x10200b0c, - VALIDATION_ERROR_10200bc6 = 0x10200bc6, - VALIDATION_ERROR_10203a01 = 0x10203a01, - VALIDATION_ERROR_10209005 = 0x10209005, - VALIDATION_ERROR_10209801 = 0x10209801, - VALIDATION_ERROR_1021c40d = 0x1021c40d, - VALIDATION_ERROR_10228601 = 0x10228601, - VALIDATION_ERROR_1022b00b = 0x1022b00b, - VALIDATION_ERROR_1022b00f = 0x1022b00f, - VALIDATION_ERROR_1042a601 = 0x1042a601, - VALIDATION_ERROR_1042b00b = 0x1042b00b, - VALIDATION_ERROR_10600580 = 0x10600580, - VALIDATION_ERROR_10600582 = 0x10600582, - VALIDATION_ERROR_10600584 = 0x10600584, - VALIDATION_ERROR_10600586 = 0x10600586, - VALIDATION_ERROR_10600588 = 0x10600588, - VALIDATION_ERROR_1060058a = 0x1060058a, - VALIDATION_ERROR_1060058c = 0x1060058c, - VALIDATION_ERROR_1060058e = 0x1060058e, - VALIDATION_ERROR_10600590 = 0x10600590, - VALIDATION_ERROR_10600592 = 0x10600592, - VALIDATION_ERROR_10600594 = 0x10600594, - VALIDATION_ERROR_10600596 = 0x10600596, - VALIDATION_ERROR_10600598 = 0x10600598, - VALIDATION_ERROR_1060059a = 0x1060059a, - VALIDATION_ERROR_1060059c = 0x1060059c, - VALIDATION_ERROR_1060059e = 0x1060059e, - VALIDATION_ERROR_10600bce = 0x10600bce, - VALIDATION_ERROR_10609005 = 0x10609005, - VALIDATION_ERROR_1060d201 = 0x1060d201, - VALIDATION_ERROR_1061c001 = 0x1061c001, - VALIDATION_ERROR_1061c40d = 0x1061c40d, - VALIDATION_ERROR_10623a01 = 0x10623a01, - VALIDATION_ERROR_1062b00b = 0x1062b00b, - VALIDATION_ERROR_1062d801 = 0x1062d801, - VALIDATION_ERROR_1080097c = 0x1080097c, - VALIDATION_ERROR_10809005 = 0x10809005, - VALIDATION_ERROR_1081c40d = 0x1081c40d, - VALIDATION_ERROR_1082b00b = 0x1082b00b, - VALIDATION_ERROR_10a004ca = 0x10a004ca, - VALIDATION_ERROR_10a004cc = 0x10a004cc, - VALIDATION_ERROR_10a004ce = 0x10a004ce, - VALIDATION_ERROR_10a004d0 = 0x10a004d0, - VALIDATION_ERROR_10a004d2 = 0x10a004d2, - VALIDATION_ERROR_10a09005 = 0x10a09005, - VALIDATION_ERROR_10a1c40d = 0x10a1c40d, - VALIDATION_ERROR_10a26401 = 0x10a26401, - VALIDATION_ERROR_10a26601 = 0x10a26601, - VALIDATION_ERROR_10a2b00b = 0x10a2b00b, - VALIDATION_ERROR_10c00980 = 0x10c00980, - VALIDATION_ERROR_10c00982 = 0x10c00982, - VALIDATION_ERROR_10c00984 = 0x10c00984, - VALIDATION_ERROR_10c00986 = 0x10c00986, - VALIDATION_ERROR_10c00988 = 0x10c00988, - VALIDATION_ERROR_10c00d7c = 0x10c00d7c, - VALIDATION_ERROR_10c09005 = 0x10c09005, - VALIDATION_ERROR_10c1c40d = 0x10c1c40d, - VALIDATION_ERROR_10c2b00b = 0x10c2b00b, - VALIDATION_ERROR_10c2b00f = 0x10c2b00f, - VALIDATION_ERROR_10c2b61b = 0x10c2b61b, - VALIDATION_ERROR_10c30a1b = 0x10c30a1b, - VALIDATION_ERROR_10e0097e = 0x10e0097e, - VALIDATION_ERROR_10e09005 = 0x10e09005, - VALIDATION_ERROR_10e2b00b = 0x10e2b00b, - VALIDATION_ERROR_10e30a1b = 0x10e30a1b, - VALIDATION_ERROR_1102b00b = 0x1102b00b, - VALIDATION_ERROR_11030a1b = 0x11030a1b, - VALIDATION_ERROR_11200009 = 0x11200009, - VALIDATION_ERROR_11200a20 = 0x11200a20, - VALIDATION_ERROR_11200b2c = 0x11200b2c, - VALIDATION_ERROR_11218801 = 0x11218801, - VALIDATION_ERROR_1121c40d = 0x1121c40d, - VALIDATION_ERROR_11221e01 = 0x11221e01, - VALIDATION_ERROR_11225801 = 0x11225801, - VALIDATION_ERROR_11227601 = 0x11227601, - VALIDATION_ERROR_1122b00b = 0x1122b00b, - VALIDATION_ERROR_1122b00f = 0x1122b00f, - VALIDATION_ERROR_1122f21b = 0x1122f21b, - VALIDATION_ERROR_11420c01 = 0x11420c01, - VALIDATION_ERROR_116009d8 = 0x116009d8, - VALIDATION_ERROR_11621001 = 0x11621001, - VALIDATION_ERROR_1162b00b = 0x1162b00b, - VALIDATION_ERROR_1162f21b = 0x1162f21b, - VALIDATION_ERROR_118009be = 0x118009be, - VALIDATION_ERROR_11825e01 = 0x11825e01, - VALIDATION_ERROR_1182b00b = 0x1182b00b, - VALIDATION_ERROR_1182f21b = 0x1182f21b, - VALIDATION_ERROR_11a0024c = 0x11a0024c, - VALIDATION_ERROR_11a0024e = 0x11a0024e, - VALIDATION_ERROR_11a00250 = 0x11a00250, - VALIDATION_ERROR_11a00252 = 0x11a00252, - VALIDATION_ERROR_11a00254 = 0x11a00254, - VALIDATION_ERROR_11a2dc01 = 0x11a2dc01, - VALIDATION_ERROR_11a2dc03 = 0x11a2dc03, - VALIDATION_ERROR_11c0062e = 0x11c0062e, - VALIDATION_ERROR_11c00630 = 0x11c00630, - VALIDATION_ERROR_11c09005 = 0x11c09005, - VALIDATION_ERROR_11c1c40d = 0x11c1c40d, - VALIDATION_ERROR_11c29a01 = 0x11c29a01, - VALIDATION_ERROR_11c2b00b = 0x11c2b00b, - VALIDATION_ERROR_11e009da = 0x11e009da, - VALIDATION_ERROR_11e009dc = 0x11e009dc, - VALIDATION_ERROR_12000009 = 0x12000009, - VALIDATION_ERROR_1200070c = 0x1200070c, - VALIDATION_ERROR_1200070e = 0x1200070e, - VALIDATION_ERROR_12000710 = 0x12000710, - VALIDATION_ERROR_12009401 = 0x12009401, - VALIDATION_ERROR_1201c40d = 0x1201c40d, - VALIDATION_ERROR_1202ae01 = 0x1202ae01, - VALIDATION_ERROR_1202b00b = 0x1202b00b, - VALIDATION_ERROR_1202b00f = 0x1202b00f, - VALIDATION_ERROR_12200680 = 0x12200680, - VALIDATION_ERROR_12200682 = 0x12200682, - VALIDATION_ERROR_12200684 = 0x12200684, - VALIDATION_ERROR_12200686 = 0x12200686, - VALIDATION_ERROR_12200688 = 0x12200688, - VALIDATION_ERROR_1220068a = 0x1220068a, - VALIDATION_ERROR_1220068c = 0x1220068c, - VALIDATION_ERROR_12200c3c = 0x12200c3c, - VALIDATION_ERROR_12200c3e = 0x12200c3e, - VALIDATION_ERROR_12200f0c = 0x12200f0c, - VALIDATION_ERROR_12200f0e = 0x12200f0e, - VALIDATION_ERROR_12200f10 = 0x12200f10, - VALIDATION_ERROR_12200f12 = 0x12200f12, - VALIDATION_ERROR_12200f14 = 0x12200f14, - VALIDATION_ERROR_12209005 = 0x12209005, - VALIDATION_ERROR_1220f201 = 0x1220f201, - VALIDATION_ERROR_12212601 = 0x12212601, - VALIDATION_ERROR_1221c40d = 0x1221c40d, - VALIDATION_ERROR_12224201 = 0x12224201, - VALIDATION_ERROR_1222b00b = 0x1222b00b, - VALIDATION_ERROR_1222b00f = 0x1222b00f, - VALIDATION_ERROR_1222e61b = 0x1222e61b, - VALIDATION_ERROR_12400692 = 0x12400692, - VALIDATION_ERROR_12411a01 = 0x12411a01, - VALIDATION_ERROR_12426c01 = 0x12426c01, - VALIDATION_ERROR_12426e01 = 0x12426e01, - VALIDATION_ERROR_1242b00b = 0x1242b00b, - VALIDATION_ERROR_12600201 = 0x12600201, - VALIDATION_ERROR_12600401 = 0x12600401, - VALIDATION_ERROR_12600601 = 0x12600601, - VALIDATION_ERROR_1260085a = 0x1260085a, - VALIDATION_ERROR_1260085c = 0x1260085c, - VALIDATION_ERROR_1260085e = 0x1260085e, - VALIDATION_ERROR_12600860 = 0x12600860, - VALIDATION_ERROR_12600862 = 0x12600862, - VALIDATION_ERROR_12600864 = 0x12600864, - VALIDATION_ERROR_12600866 = 0x12600866, - VALIDATION_ERROR_12600868 = 0x12600868, - VALIDATION_ERROR_1260086a = 0x1260086a, - VALIDATION_ERROR_1260086c = 0x1260086c, - VALIDATION_ERROR_1260086e = 0x1260086e, - VALIDATION_ERROR_12600870 = 0x12600870, - VALIDATION_ERROR_12600872 = 0x12600872, - VALIDATION_ERROR_12600b1c = 0x12600b1c, - VALIDATION_ERROR_12600b1e = 0x12600b1e, - VALIDATION_ERROR_12600cda = 0x12600cda, - VALIDATION_ERROR_12600cdc = 0x12600cdc, - VALIDATION_ERROR_12600cde = 0x12600cde, - VALIDATION_ERROR_12609005 = 0x12609005, - VALIDATION_ERROR_1260c401 = 0x1260c401, - VALIDATION_ERROR_1260ca01 = 0x1260ca01, - VALIDATION_ERROR_1260cc01 = 0x1260cc01, - VALIDATION_ERROR_1261c40d = 0x1261c40d, - VALIDATION_ERROR_1262b00b = 0x1262b00b, - VALIDATION_ERROR_1262b00f = 0x1262b00f, - VALIDATION_ERROR_12809005 = 0x12809005, - VALIDATION_ERROR_1281c40d = 0x1281c40d, - VALIDATION_ERROR_1282b00b = 0x1282b00b, - VALIDATION_ERROR_1282b00f = 0x1282b00f, - VALIDATION_ERROR_12a0087a = 0x12a0087a, - VALIDATION_ERROR_12a0087c = 0x12a0087c, - VALIDATION_ERROR_12a0087e = 0x12a0087e, - VALIDATION_ERROR_12a00880 = 0x12a00880, - VALIDATION_ERROR_12a00882 = 0x12a00882, - VALIDATION_ERROR_12a00884 = 0x12a00884, - VALIDATION_ERROR_12a00886 = 0x12a00886, - VALIDATION_ERROR_12a00ac0 = 0x12a00ac0, - VALIDATION_ERROR_12a00ac2 = 0x12a00ac2, - VALIDATION_ERROR_12a00ac4 = 0x12a00ac4, - VALIDATION_ERROR_12a00ac6 = 0x12a00ac6, - VALIDATION_ERROR_12a09005 = 0x12a09005, - VALIDATION_ERROR_12a10c01 = 0x12a10c01, - VALIDATION_ERROR_12a1c40d = 0x12a1c40d, - VALIDATION_ERROR_12a2b00b = 0x12a2b00b, - VALIDATION_ERROR_12c0141b = 0x12c0141b, - VALIDATION_ERROR_12c01a01 = 0x12c01a01, - VALIDATION_ERROR_12c0fe01 = 0x12c0fe01, - VALIDATION_ERROR_12e008a0 = 0x12e008a0, - VALIDATION_ERROR_12e008a2 = 0x12e008a2, - VALIDATION_ERROR_12e008a4 = 0x12e008a4, - VALIDATION_ERROR_12e008a6 = 0x12e008a6, - VALIDATION_ERROR_12e008a8 = 0x12e008a8, - VALIDATION_ERROR_12e008aa = 0x12e008aa, - VALIDATION_ERROR_12e008ac = 0x12e008ac, - VALIDATION_ERROR_12e008ae = 0x12e008ae, - VALIDATION_ERROR_12e008b0 = 0x12e008b0, - VALIDATION_ERROR_12e09001 = 0x12e09001, - VALIDATION_ERROR_12e0c601 = 0x12e0c601, - VALIDATION_ERROR_12e2e801 = 0x12e2e801, - VALIDATION_ERROR_13000d74 = 0x13000d74, - VALIDATION_ERROR_13000d76 = 0x13000d76, - VALIDATION_ERROR_1300141b = 0x1300141b, - VALIDATION_ERROR_1300a001 = 0x1300a001, - VALIDATION_ERROR_1300fe01 = 0x1300fe01, - VALIDATION_ERROR_1320089e = 0x1320089e, - VALIDATION_ERROR_1320141b = 0x1320141b, - VALIDATION_ERROR_1320a001 = 0x1320a001, - VALIDATION_ERROR_1320fe01 = 0x1320fe01, - VALIDATION_ERROR_13400890 = 0x13400890, - VALIDATION_ERROR_13400892 = 0x13400892, - VALIDATION_ERROR_13400894 = 0x13400894, - VALIDATION_ERROR_13400896 = 0x13400896, - VALIDATION_ERROR_13400898 = 0x13400898, - VALIDATION_ERROR_1340089a = 0x1340089a, - VALIDATION_ERROR_1340089c = 0x1340089c, - VALIDATION_ERROR_13409001 = 0x13409001, - VALIDATION_ERROR_1340c601 = 0x1340c601, - VALIDATION_ERROR_1360060a = 0x1360060a, - VALIDATION_ERROR_1360060c = 0x1360060c, - VALIDATION_ERROR_1360060e = 0x1360060e, - VALIDATION_ERROR_13612201 = 0x13612201, - VALIDATION_ERROR_13800610 = 0x13800610, - VALIDATION_ERROR_13a02a01 = 0x13a02a01, - VALIDATION_ERROR_13a04201 = 0x13a04201, - VALIDATION_ERROR_13a08601 = 0x13a08601, - VALIDATION_ERROR_13a27801 = 0x13a27801, - VALIDATION_ERROR_13c00009 = 0x13c00009, - VALIDATION_ERROR_13c00096 = 0x13c00096, - VALIDATION_ERROR_13c00098 = 0x13c00098, - VALIDATION_ERROR_13c0009a = 0x13c0009a, - VALIDATION_ERROR_13c0009c = 0x13c0009c, - VALIDATION_ERROR_13c11401 = 0x13c11401, - VALIDATION_ERROR_13c1c40d = 0x13c1c40d, - VALIDATION_ERROR_13c23401 = 0x13c23401, - VALIDATION_ERROR_13c27001 = 0x13c27001, - VALIDATION_ERROR_13c27003 = 0x13c27003, - VALIDATION_ERROR_13c27601 = 0x13c27601, - VALIDATION_ERROR_13c2b00b = 0x13c2b00b, - VALIDATION_ERROR_13c2b00f = 0x13c2b00f, - VALIDATION_ERROR_13e006b4 = 0x13e006b4, - VALIDATION_ERROR_13e006b6 = 0x13e006b6, - VALIDATION_ERROR_13e006b8 = 0x13e006b8, - VALIDATION_ERROR_13e006ba = 0x13e006ba, - VALIDATION_ERROR_13e006bc = 0x13e006bc, - VALIDATION_ERROR_13e006be = 0x13e006be, - VALIDATION_ERROR_13e006c0 = 0x13e006c0, - VALIDATION_ERROR_13e006c2 = 0x13e006c2, - VALIDATION_ERROR_13e006c4 = 0x13e006c4, - VALIDATION_ERROR_13e006c6 = 0x13e006c6, - VALIDATION_ERROR_13e006c8 = 0x13e006c8, - VALIDATION_ERROR_13e006ca = 0x13e006ca, - VALIDATION_ERROR_13e006cc = 0x13e006cc, - VALIDATION_ERROR_13e006ce = 0x13e006ce, - VALIDATION_ERROR_13e006d0 = 0x13e006d0, - VALIDATION_ERROR_13e03e01 = 0x13e03e01, - VALIDATION_ERROR_13e06801 = 0x13e06801, - VALIDATION_ERROR_13e07801 = 0x13e07801, - VALIDATION_ERROR_13e07803 = 0x13e07803, - VALIDATION_ERROR_13e2c401 = 0x13e2c401, - VALIDATION_ERROR_13e2d401 = 0x13e2d401, - VALIDATION_ERROR_13e2d403 = 0x13e2d403, - VALIDATION_ERROR_14000698 = 0x14000698, - VALIDATION_ERROR_1400069a = 0x1400069a, - VALIDATION_ERROR_1400069c = 0x1400069c, - VALIDATION_ERROR_1400069e = 0x1400069e, - VALIDATION_ERROR_140006a0 = 0x140006a0, - VALIDATION_ERROR_140006a2 = 0x140006a2, - VALIDATION_ERROR_140006a4 = 0x140006a4, - VALIDATION_ERROR_140006a8 = 0x140006a8, - VALIDATION_ERROR_140006aa = 0x140006aa, - VALIDATION_ERROR_140006ac = 0x140006ac, - VALIDATION_ERROR_140006ae = 0x140006ae, - VALIDATION_ERROR_140006b0 = 0x140006b0, - VALIDATION_ERROR_14000b12 = 0x14000b12, - VALIDATION_ERROR_14000b14 = 0x14000b14, - VALIDATION_ERROR_14000bc4 = 0x14000bc4, - VALIDATION_ERROR_14009001 = 0x14009001, - VALIDATION_ERROR_14011001 = 0x14011001, - VALIDATION_ERROR_14012a01 = 0x14012a01, - VALIDATION_ERROR_14019a01 = 0x14019a01, - VALIDATION_ERROR_1401f001 = 0x1401f001, - VALIDATION_ERROR_14021c01 = 0x14021c01, - VALIDATION_ERROR_14027e01 = 0x14027e01, - VALIDATION_ERROR_142009bc = 0x142009bc, - VALIDATION_ERROR_1421c40d = 0x1421c40d, - VALIDATION_ERROR_1422b00b = 0x1422b00b, - VALIDATION_ERROR_144009b8 = 0x144009b8, - VALIDATION_ERROR_1442b00b = 0x1442b00b, - VALIDATION_ERROR_1442ee01 = 0x1442ee01, - VALIDATION_ERROR_14600009 = 0x14600009, - VALIDATION_ERROR_146009ec = 0x146009ec, - VALIDATION_ERROR_146009ee = 0x146009ee, - VALIDATION_ERROR_146009f0 = 0x146009f0, - VALIDATION_ERROR_146009f2 = 0x146009f2, - VALIDATION_ERROR_146009f4 = 0x146009f4, - VALIDATION_ERROR_146009f6 = 0x146009f6, - VALIDATION_ERROR_146009f8 = 0x146009f8, - VALIDATION_ERROR_146009fa = 0x146009fa, - VALIDATION_ERROR_146009fc = 0x146009fc, - VALIDATION_ERROR_146009fe = 0x146009fe, - VALIDATION_ERROR_14600a00 = 0x14600a00, - VALIDATION_ERROR_14600a02 = 0x14600a02, - VALIDATION_ERROR_14600ace = 0x14600ace, - VALIDATION_ERROR_14600ad0 = 0x14600ad0, - VALIDATION_ERROR_14600ae2 = 0x14600ae2, - VALIDATION_ERROR_14600b26 = 0x14600b26, - VALIDATION_ERROR_14600b28 = 0x14600b28, - VALIDATION_ERROR_14600b2a = 0x14600b2a, - VALIDATION_ERROR_14600d32 = 0x14600d32, - VALIDATION_ERROR_14600de4 = 0x14600de4, - VALIDATION_ERROR_14600f1a = 0x14600f1a, - VALIDATION_ERROR_14602e01 = 0x14602e01, - VALIDATION_ERROR_14609001 = 0x14609001, - VALIDATION_ERROR_1460a201 = 0x1460a201, - VALIDATION_ERROR_1460a401 = 0x1460a401, - VALIDATION_ERROR_1460a801 = 0x1460a801, - VALIDATION_ERROR_1460ae01 = 0x1460ae01, - VALIDATION_ERROR_1460ae03 = 0x1460ae03, - VALIDATION_ERROR_1460de01 = 0x1460de01, - VALIDATION_ERROR_1460de07 = 0x1460de07, - VALIDATION_ERROR_1461c40d = 0x1461c40d, - VALIDATION_ERROR_14629401 = 0x14629401, - VALIDATION_ERROR_14629601 = 0x14629601, - VALIDATION_ERROR_1462b00b = 0x1462b00b, - VALIDATION_ERROR_1462b00f = 0x1462b00f, - VALIDATION_ERROR_1462ec01 = 0x1462ec01, - VALIDATION_ERROR_14805a1b = 0x14805a1b, - VALIDATION_ERROR_14814401 = 0x14814401, - VALIDATION_ERROR_1482b00b = 0x1482b00b, - VALIDATION_ERROR_14a004d8 = 0x14a004d8, - VALIDATION_ERROR_14a004da = 0x14a004da, - VALIDATION_ERROR_14a004dc = 0x14a004dc, - VALIDATION_ERROR_14a004de = 0x14a004de, - VALIDATION_ERROR_14a09201 = 0x14a09201, - VALIDATION_ERROR_14c004d4 = 0x14c004d4, - VALIDATION_ERROR_14c004d6 = 0x14c004d6, - VALIDATION_ERROR_14c0ba01 = 0x14c0ba01, - VALIDATION_ERROR_14e00a4c = 0x14e00a4c, - VALIDATION_ERROR_14e09005 = 0x14e09005, - VALIDATION_ERROR_14e1c40d = 0x14e1c40d, - VALIDATION_ERROR_14e2b00b = 0x14e2b00b, - VALIDATION_ERROR_150009a0 = 0x150009a0, - VALIDATION_ERROR_150009a2 = 0x150009a2, - VALIDATION_ERROR_150009a4 = 0x150009a4, - VALIDATION_ERROR_150009a6 = 0x150009a6, - VALIDATION_ERROR_15000dd4 = 0x15000dd4, - VALIDATION_ERROR_15000dd6 = 0x15000dd6, - VALIDATION_ERROR_15000dd8 = 0x15000dd8, - VALIDATION_ERROR_15000dda = 0x15000dda, - VALIDATION_ERROR_15000ddc = 0x15000ddc, - VALIDATION_ERROR_15000dde = 0x15000dde, - VALIDATION_ERROR_15000de0 = 0x15000de0, - VALIDATION_ERROR_15000de2 = 0x15000de2, - VALIDATION_ERROR_15230c01 = 0x15230c01, - VALIDATION_ERROR_15231001 = 0x15231001, - VALIDATION_ERROR_15231201 = 0x15231201, - VALIDATION_ERROR_15231401 = 0x15231401, - VALIDATION_ERROR_15400a30 = 0x15400a30, - VALIDATION_ERROR_15400a32 = 0x15400a32, - VALIDATION_ERROR_15409005 = 0x15409005, - VALIDATION_ERROR_1541c40d = 0x1541c40d, - VALIDATION_ERROR_1542b00b = 0x1542b00b, - VALIDATION_ERROR_15600009 = 0x15600009, - VALIDATION_ERROR_156000a2 = 0x156000a2, - VALIDATION_ERROR_1560e201 = 0x1560e201, - VALIDATION_ERROR_1560e401 = 0x1560e401, - VALIDATION_ERROR_1560e801 = 0x1560e801, - VALIDATION_ERROR_15621201 = 0x15621201, - VALIDATION_ERROR_15621401 = 0x15621401, - VALIDATION_ERROR_1562b00b = 0x1562b00b, - VALIDATION_ERROR_15800009 = 0x15800009, - VALIDATION_ERROR_1580e201 = 0x1580e201, - VALIDATION_ERROR_1580e401 = 0x1580e401, - VALIDATION_ERROR_1580e601 = 0x1580e601, - VALIDATION_ERROR_15821201 = 0x15821201, - VALIDATION_ERROR_15821401 = 0x15821401, - VALIDATION_ERROR_1582b00b = 0x1582b00b, - VALIDATION_ERROR_15a00a36 = 0x15a00a36, - VALIDATION_ERROR_15a00a38 = 0x15a00a38, - VALIDATION_ERROR_15a09005 = 0x15a09005, - VALIDATION_ERROR_15a1c40d = 0x15a1c40d, - VALIDATION_ERROR_15a2b00b = 0x15a2b00b, - VALIDATION_ERROR_15c00009 = 0x15c00009, - VALIDATION_ERROR_15c00276 = 0x15c00276, - VALIDATION_ERROR_15c00278 = 0x15c00278, - VALIDATION_ERROR_15c0027a = 0x15c0027a, - VALIDATION_ERROR_15c0027c = 0x15c0027c, - VALIDATION_ERROR_15c0027e = 0x15c0027e, - VALIDATION_ERROR_15c00280 = 0x15c00280, - VALIDATION_ERROR_15c00282 = 0x15c00282, - VALIDATION_ERROR_15c00284 = 0x15c00284, - VALIDATION_ERROR_15c00286 = 0x15c00286, - VALIDATION_ERROR_15c00288 = 0x15c00288, - VALIDATION_ERROR_15c0028a = 0x15c0028a, - VALIDATION_ERROR_15c0028c = 0x15c0028c, - VALIDATION_ERROR_15c0028e = 0x15c0028e, - VALIDATION_ERROR_15c00290 = 0x15c00290, - VALIDATION_ERROR_15c00292 = 0x15c00292, - VALIDATION_ERROR_15c00294 = 0x15c00294, - VALIDATION_ERROR_15c00296 = 0x15c00296, - VALIDATION_ERROR_15c00298 = 0x15c00298, - VALIDATION_ERROR_15c0029a = 0x15c0029a, - VALIDATION_ERROR_15c0029c = 0x15c0029c, - VALIDATION_ERROR_15c0029e = 0x15c0029e, - VALIDATION_ERROR_15c002a0 = 0x15c002a0, - VALIDATION_ERROR_15c002a2 = 0x15c002a2, - VALIDATION_ERROR_15c002a4 = 0x15c002a4, - VALIDATION_ERROR_15c002a6 = 0x15c002a6, - VALIDATION_ERROR_15c00af4 = 0x15c00af4, - VALIDATION_ERROR_15c00af6 = 0x15c00af6, - VALIDATION_ERROR_15c017d0 = 0x15c017d0, - VALIDATION_ERROR_15c0441b = 0x15c0441b, - VALIDATION_ERROR_15c04e01 = 0x15c04e01, - VALIDATION_ERROR_15c1c40d = 0x15c1c40d, - VALIDATION_ERROR_15c2b00b = 0x15c2b00b, - VALIDATION_ERROR_15e00a3c = 0x15e00a3c, - VALIDATION_ERROR_15e00a3e = 0x15e00a3e, - VALIDATION_ERROR_15e09005 = 0x15e09005, - VALIDATION_ERROR_15e1c40d = 0x15e1c40d, - VALIDATION_ERROR_15e2b00b = 0x15e2b00b, - VALIDATION_ERROR_16000a42 = 0x16000a42, - VALIDATION_ERROR_16000a44 = 0x16000a44, - VALIDATION_ERROR_16009005 = 0x16009005, - VALIDATION_ERROR_1601c40d = 0x1601c40d, - VALIDATION_ERROR_1602b00b = 0x1602b00b, - VALIDATION_ERROR_16200e16 = 0x16200e16, - VALIDATION_ERROR_16205601 = 0x16205601, - VALIDATION_ERROR_1620e001 = 0x1620e001, - VALIDATION_ERROR_16218601 = 0x16218601, - VALIDATION_ERROR_16400009 = 0x16400009, - VALIDATION_ERROR_16400a0a = 0x16400a0a, - VALIDATION_ERROR_16400a0c = 0x16400a0c, - VALIDATION_ERROR_16400a0e = 0x16400a0e, - VALIDATION_ERROR_16400de6 = 0x16400de6, - VALIDATION_ERROR_16400de8 = 0x16400de8, - VALIDATION_ERROR_16400e14 = 0x16400e14, - VALIDATION_ERROR_16405601 = 0x16405601, - VALIDATION_ERROR_16408801 = 0x16408801, - VALIDATION_ERROR_16408807 = 0x16408807, - VALIDATION_ERROR_16418601 = 0x16418601, - VALIDATION_ERROR_1642b801 = 0x1642b801, - VALIDATION_ERROR_1642b807 = 0x1642b807, - VALIDATION_ERROR_1642f001 = 0x1642f001, - VALIDATION_ERROR_16606001 = 0x16606001, - VALIDATION_ERROR_16606601 = 0x16606601, - VALIDATION_ERROR_16627a01 = 0x16627a01, - VALIDATION_ERROR_16805601 = 0x16805601, - VALIDATION_ERROR_1680ea01 = 0x1680ea01, - VALIDATION_ERROR_16811401 = 0x16811401, - VALIDATION_ERROR_16a05601 = 0x16a05601, - VALIDATION_ERROR_16a0ea01 = 0x16a0ea01, - VALIDATION_ERROR_16a13001 = 0x16a13001, - VALIDATION_ERROR_16c00d62 = 0x16c00d62, - VALIDATION_ERROR_16c00d64 = 0x16c00d64, - VALIDATION_ERROR_16c05601 = 0x16c05601, - VALIDATION_ERROR_16c0ea01 = 0x16c0ea01, - VALIDATION_ERROR_16c0ec01 = 0x16c0ec01, - VALIDATION_ERROR_16c1aa01 = 0x16c1aa01, - VALIDATION_ERROR_16e00062 = 0x16e00062, - VALIDATION_ERROR_16e00064 = 0x16e00064, - VALIDATION_ERROR_16e00066 = 0x16e00066, - VALIDATION_ERROR_16e00068 = 0x16e00068, - VALIDATION_ERROR_16e02401 = 0x16e02401, - VALIDATION_ERROR_16e0f601 = 0x16e0f601, - VALIDATION_ERROR_1700080a = 0x1700080a, - VALIDATION_ERROR_1700080c = 0x1700080c, - VALIDATION_ERROR_1700080e = 0x1700080e, - VALIDATION_ERROR_17000810 = 0x17000810, - VALIDATION_ERROR_17000812 = 0x17000812, - VALIDATION_ERROR_17000814 = 0x17000814, - VALIDATION_ERROR_17000816 = 0x17000816, - VALIDATION_ERROR_17000818 = 0x17000818, - VALIDATION_ERROR_1700081a = 0x1700081a, - VALIDATION_ERROR_1700081c = 0x1700081c, - VALIDATION_ERROR_1700081e = 0x1700081e, - VALIDATION_ERROR_17000b48 = 0x17000b48, - VALIDATION_ERROR_17000bc8 = 0x17000bc8, - VALIDATION_ERROR_17000ed4 = 0x17000ed4, - VALIDATION_ERROR_17000ed6 = 0x17000ed6, - VALIDATION_ERROR_17001a01 = 0x17001a01, - VALIDATION_ERROR_17001a07 = 0x17001a07, - VALIDATION_ERROR_17005601 = 0x17005601, - VALIDATION_ERROR_1700c601 = 0x1700c601, - VALIDATION_ERROR_1700c607 = 0x1700c607, - VALIDATION_ERROR_1720161b = 0x1720161b, - VALIDATION_ERROR_17205601 = 0x17205601, - VALIDATION_ERROR_1720fa01 = 0x1720fa01, - VALIDATION_ERROR_17400828 = 0x17400828, - VALIDATION_ERROR_1740082a = 0x1740082a, - VALIDATION_ERROR_1740082c = 0x1740082c, - VALIDATION_ERROR_1740082e = 0x1740082e, - VALIDATION_ERROR_17400830 = 0x17400830, - VALIDATION_ERROR_17400832 = 0x17400832, - VALIDATION_ERROR_17400834 = 0x17400834, - VALIDATION_ERROR_17400836 = 0x17400836, - VALIDATION_ERROR_17400b4a = 0x17400b4a, - VALIDATION_ERROR_17400bca = 0x17400bca, - VALIDATION_ERROR_17400c90 = 0x17400c90, - VALIDATION_ERROR_17400eda = 0x17400eda, - VALIDATION_ERROR_17400edc = 0x17400edc, - VALIDATION_ERROR_17405601 = 0x17405601, - VALIDATION_ERROR_1740a001 = 0x1740a001, - VALIDATION_ERROR_1740a007 = 0x1740a007, - VALIDATION_ERROR_1740c601 = 0x1740c601, - VALIDATION_ERROR_1740c607 = 0x1740c607, - VALIDATION_ERROR_1760161b = 0x1760161b, - VALIDATION_ERROR_17605601 = 0x17605601, - VALIDATION_ERROR_1760fa01 = 0x1760fa01, - VALIDATION_ERROR_17800009 = 0x17800009, - VALIDATION_ERROR_17800640 = 0x17800640, - VALIDATION_ERROR_17800644 = 0x17800644, - VALIDATION_ERROR_17800646 = 0x17800646, - VALIDATION_ERROR_17800648 = 0x17800648, - VALIDATION_ERROR_1780064a = 0x1780064a, - VALIDATION_ERROR_1780064e = 0x1780064e, - VALIDATION_ERROR_17800650 = 0x17800650, - VALIDATION_ERROR_17800eba = 0x17800eba, - VALIDATION_ERROR_17800f04 = 0x17800f04, - VALIDATION_ERROR_17802401 = 0x17802401, - VALIDATION_ERROR_17802413 = 0x17802413, - VALIDATION_ERROR_17802415 = 0x17802415, - VALIDATION_ERROR_17809001 = 0x17809001, - VALIDATION_ERROR_17829801 = 0x17829801, - VALIDATION_ERROR_17a00017 = 0x17a00017, - VALIDATION_ERROR_17a00019 = 0x17a00019, - VALIDATION_ERROR_17a006fe = 0x17a006fe, - VALIDATION_ERROR_17a00700 = 0x17a00700, - VALIDATION_ERROR_17a00702 = 0x17a00702, - VALIDATION_ERROR_17a00704 = 0x17a00704, - VALIDATION_ERROR_17a00706 = 0x17a00706, - VALIDATION_ERROR_17a00708 = 0x17a00708, - VALIDATION_ERROR_17a0070a = 0x17a0070a, - VALIDATION_ERROR_17a00dbc = 0x17a00dbc, - VALIDATION_ERROR_17a02401 = 0x17a02401, - VALIDATION_ERROR_17a02413 = 0x17a02413, - VALIDATION_ERROR_17a02415 = 0x17a02415, - VALIDATION_ERROR_17a03201 = 0x17a03201, - VALIDATION_ERROR_17a21801 = 0x17a21801, - VALIDATION_ERROR_17c00009 = 0x17c00009, - VALIDATION_ERROR_17c002cc = 0x17c002cc, - VALIDATION_ERROR_17c002ce = 0x17c002ce, - VALIDATION_ERROR_17c002d0 = 0x17c002d0, - VALIDATION_ERROR_17c002d2 = 0x17c002d2, - VALIDATION_ERROR_17c002d4 = 0x17c002d4, - VALIDATION_ERROR_17c02401 = 0x17c02401, - VALIDATION_ERROR_17c02413 = 0x17c02413, - VALIDATION_ERROR_17c02415 = 0x17c02415, - VALIDATION_ERROR_17c04a1b = 0x17c04a1b, - VALIDATION_ERROR_17c0be01 = 0x17c0be01, - VALIDATION_ERROR_17c13001 = 0x17c13001, - VALIDATION_ERROR_17c15401 = 0x17c15401, - VALIDATION_ERROR_17c27e01 = 0x17c27e01, - VALIDATION_ERROR_17e00009 = 0x17e00009, - VALIDATION_ERROR_17e0035e = 0x17e0035e, - VALIDATION_ERROR_17e00360 = 0x17e00360, - VALIDATION_ERROR_17e00362 = 0x17e00362, - VALIDATION_ERROR_17e00364 = 0x17e00364, - VALIDATION_ERROR_17e01a01 = 0x17e01a01, - VALIDATION_ERROR_17e02401 = 0x17e02401, - VALIDATION_ERROR_17e02413 = 0x17e02413, - VALIDATION_ERROR_17e02415 = 0x17e02415, - VALIDATION_ERROR_17e0b201 = 0x17e0b201, - VALIDATION_ERROR_18000009 = 0x18000009, - VALIDATION_ERROR_18000612 = 0x18000612, - VALIDATION_ERROR_18000614 = 0x18000614, - VALIDATION_ERROR_18000616 = 0x18000616, - VALIDATION_ERROR_18000618 = 0x18000618, - VALIDATION_ERROR_1800061a = 0x1800061a, - VALIDATION_ERROR_18000bea = 0x18000bea, - VALIDATION_ERROR_18002401 = 0x18002401, - VALIDATION_ERROR_18002413 = 0x18002413, - VALIDATION_ERROR_18002415 = 0x18002415, - VALIDATION_ERROR_18027c01 = 0x18027c01, - VALIDATION_ERROR_18027e01 = 0x18027e01, - VALIDATION_ERROR_18200009 = 0x18200009, - VALIDATION_ERROR_182004e0 = 0x182004e0, - VALIDATION_ERROR_182004e2 = 0x182004e2, - VALIDATION_ERROR_182004e4 = 0x182004e4, - VALIDATION_ERROR_182004e6 = 0x182004e6, - VALIDATION_ERROR_182004e8 = 0x182004e8, - VALIDATION_ERROR_1820181b = 0x1820181b, - VALIDATION_ERROR_18202401 = 0x18202401, - VALIDATION_ERROR_18202413 = 0x18202413, - VALIDATION_ERROR_18202415 = 0x18202415, - VALIDATION_ERROR_18210601 = 0x18210601, - VALIDATION_ERROR_1821d201 = 0x1821d201, - VALIDATION_ERROR_18400009 = 0x18400009, - VALIDATION_ERROR_18400017 = 0x18400017, - VALIDATION_ERROR_184001ae = 0x184001ae, - VALIDATION_ERROR_184001b0 = 0x184001b0, - VALIDATION_ERROR_184001b2 = 0x184001b2, - VALIDATION_ERROR_184001b4 = 0x184001b4, - VALIDATION_ERROR_184001b6 = 0x184001b6, - VALIDATION_ERROR_184001b8 = 0x184001b8, - VALIDATION_ERROR_184001ba = 0x184001ba, - VALIDATION_ERROR_184001bc = 0x184001bc, - VALIDATION_ERROR_184001be = 0x184001be, - VALIDATION_ERROR_184001c0 = 0x184001c0, - VALIDATION_ERROR_184001c2 = 0x184001c2, - VALIDATION_ERROR_184001c4 = 0x184001c4, - VALIDATION_ERROR_184001c6 = 0x184001c6, - VALIDATION_ERROR_184001c8 = 0x184001c8, - VALIDATION_ERROR_184001ca = 0x184001ca, - VALIDATION_ERROR_184001cc = 0x184001cc, - VALIDATION_ERROR_184001ce = 0x184001ce, - VALIDATION_ERROR_184001d0 = 0x184001d0, - VALIDATION_ERROR_184001d2 = 0x184001d2, - VALIDATION_ERROR_184001d4 = 0x184001d4, - VALIDATION_ERROR_184001d6 = 0x184001d6, - VALIDATION_ERROR_184001d8 = 0x184001d8, - VALIDATION_ERROR_184001da = 0x184001da, - VALIDATION_ERROR_18400aec = 0x18400aec, - VALIDATION_ERROR_18400aee = 0x18400aee, - VALIDATION_ERROR_18400c32 = 0x18400c32, - VALIDATION_ERROR_18400c34 = 0x18400c34, - VALIDATION_ERROR_18400d52 = 0x18400d52, - VALIDATION_ERROR_18400d54 = 0x18400d54, - VALIDATION_ERROR_18400d56 = 0x18400d56, - VALIDATION_ERROR_18400d58 = 0x18400d58, - VALIDATION_ERROR_18400e54 = 0x18400e54, - VALIDATION_ERROR_18400e56 = 0x18400e56, - VALIDATION_ERROR_18400e58 = 0x18400e58, - VALIDATION_ERROR_18402401 = 0x18402401, - VALIDATION_ERROR_18402413 = 0x18402413, - VALIDATION_ERROR_18402415 = 0x18402415, - VALIDATION_ERROR_18407201 = 0x18407201, - VALIDATION_ERROR_18407401 = 0x18407401, - VALIDATION_ERROR_18408c01 = 0x18408c01, - VALIDATION_ERROR_18421001 = 0x18421001, - VALIDATION_ERROR_1842ac1b = 0x1842ac1b, - VALIDATION_ERROR_1842ce01 = 0x1842ce01, - VALIDATION_ERROR_1842d001 = 0x1842d001, - VALIDATION_ERROR_18600017 = 0x18600017, - VALIDATION_ERROR_1860001e = 0x1860001e, - VALIDATION_ERROR_18600020 = 0x18600020, - VALIDATION_ERROR_18600022 = 0x18600022, - VALIDATION_ERROR_18600024 = 0x18600024, - VALIDATION_ERROR_18600e1b = 0x18600e1b, - VALIDATION_ERROR_18600f1c = 0x18600f1c, - VALIDATION_ERROR_18602401 = 0x18602401, - VALIDATION_ERROR_18602413 = 0x18602413, - VALIDATION_ERROR_18602415 = 0x18602415, - VALIDATION_ERROR_1860f201 = 0x1860f201, - VALIDATION_ERROR_18620e01 = 0x18620e01, - VALIDATION_ERROR_1862aa1b = 0x1862aa1b, - VALIDATION_ERROR_18800002 = 0x18800002, - VALIDATION_ERROR_18800004 = 0x18800004, - VALIDATION_ERROR_18800006 = 0x18800006, - VALIDATION_ERROR_18800008 = 0x18800008, - VALIDATION_ERROR_18800009 = 0x18800009, - VALIDATION_ERROR_1880000a = 0x1880000a, - VALIDATION_ERROR_1880000e = 0x1880000e, - VALIDATION_ERROR_18800017 = 0x18800017, - VALIDATION_ERROR_18800ae4 = 0x18800ae4, - VALIDATION_ERROR_18800b7c = 0x18800b7c, - VALIDATION_ERROR_18800b80 = 0x18800b80, - VALIDATION_ERROR_18800c12 = 0x18800c12, - VALIDATION_ERROR_18800d38 = 0x18800d38, - VALIDATION_ERROR_18800d3a = 0x18800d3a, - VALIDATION_ERROR_18800e1a = 0x18800e1a, - VALIDATION_ERROR_18800e1c = 0x18800e1c, - VALIDATION_ERROR_18802401 = 0x18802401, - VALIDATION_ERROR_18802413 = 0x18802413, - VALIDATION_ERROR_18802415 = 0x18802415, - VALIDATION_ERROR_1880a001 = 0x1880a001, - VALIDATION_ERROR_1880a601 = 0x1880a601, - VALIDATION_ERROR_18810e01 = 0x18810e01, - VALIDATION_ERROR_18820601 = 0x18820601, - VALIDATION_ERROR_1882a41b = 0x1882a41b, - VALIDATION_ERROR_18a00009 = 0x18a00009, - VALIDATION_ERROR_18a00010 = 0x18a00010, - VALIDATION_ERROR_18a00012 = 0x18a00012, - VALIDATION_ERROR_18a00014 = 0x18a00014, - VALIDATION_ERROR_18a00016 = 0x18a00016, - VALIDATION_ERROR_18a00017 = 0x18a00017, - VALIDATION_ERROR_18a00018 = 0x18a00018, - VALIDATION_ERROR_18a0001c = 0x18a0001c, - VALIDATION_ERROR_18a00b84 = 0x18a00b84, - VALIDATION_ERROR_18a00b88 = 0x18a00b88, - VALIDATION_ERROR_18a00d3c = 0x18a00d3c, - VALIDATION_ERROR_18a00d3e = 0x18a00d3e, - VALIDATION_ERROR_18a00e1e = 0x18a00e1e, - VALIDATION_ERROR_18a00e20 = 0x18a00e20, - VALIDATION_ERROR_18a02401 = 0x18a02401, - VALIDATION_ERROR_18a02413 = 0x18a02413, - VALIDATION_ERROR_18a02415 = 0x18a02415, - VALIDATION_ERROR_18a0a001 = 0x18a0a001, - VALIDATION_ERROR_18a0a601 = 0x18a0a601, - VALIDATION_ERROR_18a12801 = 0x18a12801, - VALIDATION_ERROR_18a20601 = 0x18a20601, - VALIDATION_ERROR_18a2a41b = 0x18a2a41b, - VALIDATION_ERROR_18c00009 = 0x18c00009, - VALIDATION_ERROR_18c00017 = 0x18c00017, - VALIDATION_ERROR_18c000e0 = 0x18c000e0, - VALIDATION_ERROR_18c000e2 = 0x18c000e2, - VALIDATION_ERROR_18c000e4 = 0x18c000e4, - VALIDATION_ERROR_18c000e6 = 0x18c000e6, - VALIDATION_ERROR_18c000e8 = 0x18c000e8, - VALIDATION_ERROR_18c000ea = 0x18c000ea, - VALIDATION_ERROR_18c000ec = 0x18c000ec, - VALIDATION_ERROR_18c000ee = 0x18c000ee, - VALIDATION_ERROR_18c000f0 = 0x18c000f0, - VALIDATION_ERROR_18c000f2 = 0x18c000f2, - VALIDATION_ERROR_18c00e3c = 0x18c00e3c, - VALIDATION_ERROR_18c00e3e = 0x18c00e3e, - VALIDATION_ERROR_18c00e40 = 0x18c00e40, - VALIDATION_ERROR_18c02401 = 0x18c02401, - VALIDATION_ERROR_18c02413 = 0x18c02413, - VALIDATION_ERROR_18c02415 = 0x18c02415, - VALIDATION_ERROR_18c06c01 = 0x18c06c01, - VALIDATION_ERROR_18c21001 = 0x18c21001, - VALIDATION_ERROR_18c2ac1b = 0x18c2ac1b, - VALIDATION_ERROR_18c2c801 = 0x18c2c801, - VALIDATION_ERROR_18e00009 = 0x18e00009, - VALIDATION_ERROR_18e00017 = 0x18e00017, - VALIDATION_ERROR_18e00156 = 0x18e00156, - VALIDATION_ERROR_18e00158 = 0x18e00158, - VALIDATION_ERROR_18e0015a = 0x18e0015a, - VALIDATION_ERROR_18e0015c = 0x18e0015c, - VALIDATION_ERROR_18e0015e = 0x18e0015e, - VALIDATION_ERROR_18e00160 = 0x18e00160, - VALIDATION_ERROR_18e00162 = 0x18e00162, - VALIDATION_ERROR_18e00164 = 0x18e00164, - VALIDATION_ERROR_18e00166 = 0x18e00166, - VALIDATION_ERROR_18e00168 = 0x18e00168, - VALIDATION_ERROR_18e0016a = 0x18e0016a, - VALIDATION_ERROR_18e00ae8 = 0x18e00ae8, - VALIDATION_ERROR_18e00d4a = 0x18e00d4a, - VALIDATION_ERROR_18e00d4c = 0x18e00d4c, - VALIDATION_ERROR_18e00e02 = 0x18e00e02, - VALIDATION_ERROR_18e00e48 = 0x18e00e48, - VALIDATION_ERROR_18e00e4a = 0x18e00e4a, - VALIDATION_ERROR_18e00e4c = 0x18e00e4c, - VALIDATION_ERROR_18e02401 = 0x18e02401, - VALIDATION_ERROR_18e02413 = 0x18e02413, - VALIDATION_ERROR_18e02415 = 0x18e02415, - VALIDATION_ERROR_18e07201 = 0x18e07201, - VALIDATION_ERROR_18e07401 = 0x18e07401, - VALIDATION_ERROR_18e21001 = 0x18e21001, - VALIDATION_ERROR_18e2ac1b = 0x18e2ac1b, - VALIDATION_ERROR_18e2c801 = 0x18e2c801, - VALIDATION_ERROR_19000009 = 0x19000009, - VALIDATION_ERROR_19000017 = 0x19000017, - VALIDATION_ERROR_190000f4 = 0x190000f4, - VALIDATION_ERROR_190000f6 = 0x190000f6, - VALIDATION_ERROR_190000f8 = 0x190000f8, - VALIDATION_ERROR_190000fa = 0x190000fa, - VALIDATION_ERROR_190000fc = 0x190000fc, - VALIDATION_ERROR_190000fe = 0x190000fe, - VALIDATION_ERROR_19000100 = 0x19000100, - VALIDATION_ERROR_19000102 = 0x19000102, - VALIDATION_ERROR_19000104 = 0x19000104, - VALIDATION_ERROR_19000106 = 0x19000106, - VALIDATION_ERROR_19000108 = 0x19000108, - VALIDATION_ERROR_1900010a = 0x1900010a, - VALIDATION_ERROR_1900010c = 0x1900010c, - VALIDATION_ERROR_1900010e = 0x1900010e, - VALIDATION_ERROR_19000110 = 0x19000110, - VALIDATION_ERROR_19000ae6 = 0x19000ae6, - VALIDATION_ERROR_19000c14 = 0x19000c14, - VALIDATION_ERROR_19000c16 = 0x19000c16, - VALIDATION_ERROR_19000c18 = 0x19000c18, - VALIDATION_ERROR_19000c1a = 0x19000c1a, - VALIDATION_ERROR_19000c1c = 0x19000c1c, - VALIDATION_ERROR_19000d40 = 0x19000d40, - VALIDATION_ERROR_19000d42 = 0x19000d42, - VALIDATION_ERROR_19000d44 = 0x19000d44, - VALIDATION_ERROR_19000d46 = 0x19000d46, - VALIDATION_ERROR_19000dee = 0x19000dee, - VALIDATION_ERROR_19000df0 = 0x19000df0, - VALIDATION_ERROR_19000e42 = 0x19000e42, - VALIDATION_ERROR_19000e44 = 0x19000e44, - VALIDATION_ERROR_19000e46 = 0x19000e46, - VALIDATION_ERROR_19000efa = 0x19000efa, - VALIDATION_ERROR_19002401 = 0x19002401, - VALIDATION_ERROR_19002413 = 0x19002413, - VALIDATION_ERROR_19002415 = 0x19002415, - VALIDATION_ERROR_19007201 = 0x19007201, - VALIDATION_ERROR_19007401 = 0x19007401, - VALIDATION_ERROR_19021001 = 0x19021001, - VALIDATION_ERROR_1902ac1b = 0x1902ac1b, - VALIDATION_ERROR_1902ce01 = 0x1902ce01, - VALIDATION_ERROR_1902d001 = 0x1902d001, - VALIDATION_ERROR_19200009 = 0x19200009, - VALIDATION_ERROR_19200017 = 0x19200017, - VALIDATION_ERROR_1920016c = 0x1920016c, - VALIDATION_ERROR_1920016e = 0x1920016e, - VALIDATION_ERROR_19200170 = 0x19200170, - VALIDATION_ERROR_19200172 = 0x19200172, - VALIDATION_ERROR_19200174 = 0x19200174, - VALIDATION_ERROR_19200176 = 0x19200176, - VALIDATION_ERROR_19200178 = 0x19200178, - VALIDATION_ERROR_1920017a = 0x1920017a, - VALIDATION_ERROR_1920017c = 0x1920017c, - VALIDATION_ERROR_1920017e = 0x1920017e, - VALIDATION_ERROR_19200180 = 0x19200180, - VALIDATION_ERROR_19200aea = 0x19200aea, - VALIDATION_ERROR_19200d4e = 0x19200d4e, - VALIDATION_ERROR_19200d50 = 0x19200d50, - VALIDATION_ERROR_19200e04 = 0x19200e04, - VALIDATION_ERROR_19200e4e = 0x19200e4e, - VALIDATION_ERROR_19200e50 = 0x19200e50, - VALIDATION_ERROR_19200e52 = 0x19200e52, - VALIDATION_ERROR_19202401 = 0x19202401, - VALIDATION_ERROR_19202413 = 0x19202413, - VALIDATION_ERROR_19202415 = 0x19202415, - VALIDATION_ERROR_19206c01 = 0x19206c01, - VALIDATION_ERROR_19221001 = 0x19221001, - VALIDATION_ERROR_1922ac1b = 0x1922ac1b, - VALIDATION_ERROR_1922ce01 = 0x1922ce01, - VALIDATION_ERROR_1922d001 = 0x1922d001, - VALIDATION_ERROR_19400009 = 0x19400009, - VALIDATION_ERROR_19400017 = 0x19400017, - VALIDATION_ERROR_19400666 = 0x19400666, - VALIDATION_ERROR_19400668 = 0x19400668, - VALIDATION_ERROR_1940066a = 0x1940066a, - VALIDATION_ERROR_1940066c = 0x1940066c, - VALIDATION_ERROR_1940066e = 0x1940066e, - VALIDATION_ERROR_19400670 = 0x19400670, - VALIDATION_ERROR_19400672 = 0x19400672, - VALIDATION_ERROR_19400674 = 0x19400674, - VALIDATION_ERROR_19400676 = 0x19400676, - VALIDATION_ERROR_19402401 = 0x19402401, - VALIDATION_ERROR_19402413 = 0x19402413, - VALIDATION_ERROR_19402415 = 0x19402415, - VALIDATION_ERROR_19406c01 = 0x19406c01, - VALIDATION_ERROR_19409001 = 0x19409001, - VALIDATION_ERROR_19429801 = 0x19429801, - VALIDATION_ERROR_19602401 = 0x19602401, - VALIDATION_ERROR_19602413 = 0x19602413, - VALIDATION_ERROR_19602415 = 0x19602415, - VALIDATION_ERROR_1961a601 = 0x1961a601, - VALIDATION_ERROR_198009ae = 0x198009ae, - VALIDATION_ERROR_198009b0 = 0x198009b0, - VALIDATION_ERROR_19802401 = 0x19802401, - VALIDATION_ERROR_19802413 = 0x19802413, - VALIDATION_ERROR_19802415 = 0x19802415, - VALIDATION_ERROR_19a02401 = 0x19a02401, - VALIDATION_ERROR_19a02413 = 0x19a02413, - VALIDATION_ERROR_19a02415 = 0x19a02415, - VALIDATION_ERROR_19a1a601 = 0x19a1a601, - VALIDATION_ERROR_19c00017 = 0x19c00017, - VALIDATION_ERROR_19c00304 = 0x19c00304, - VALIDATION_ERROR_19c00306 = 0x19c00306, - VALIDATION_ERROR_19c00308 = 0x19c00308, - VALIDATION_ERROR_19c0030a = 0x19c0030a, - VALIDATION_ERROR_19c0030c = 0x19c0030c, - VALIDATION_ERROR_19c0030e = 0x19c0030e, - VALIDATION_ERROR_19c00310 = 0x19c00310, - VALIDATION_ERROR_19c00312 = 0x19c00312, - VALIDATION_ERROR_19c00314 = 0x19c00314, - VALIDATION_ERROR_19c00316 = 0x19c00316, - VALIDATION_ERROR_19c00318 = 0x19c00318, - VALIDATION_ERROR_19c0031a = 0x19c0031a, - VALIDATION_ERROR_19c0031c = 0x19c0031c, - VALIDATION_ERROR_19c0031e = 0x19c0031e, - VALIDATION_ERROR_19c00320 = 0x19c00320, - VALIDATION_ERROR_19c00e68 = 0x19c00e68, - VALIDATION_ERROR_19c00e6a = 0x19c00e6a, - VALIDATION_ERROR_19c00e6c = 0x19c00e6c, - VALIDATION_ERROR_19c02401 = 0x19c02401, - VALIDATION_ERROR_19c02413 = 0x19c02413, - VALIDATION_ERROR_19c02415 = 0x19c02415, - VALIDATION_ERROR_19e00017 = 0x19e00017, - VALIDATION_ERROR_19e00348 = 0x19e00348, - VALIDATION_ERROR_19e0034a = 0x19e0034a, - VALIDATION_ERROR_19e0034c = 0x19e0034c, - VALIDATION_ERROR_19e0034e = 0x19e0034e, - VALIDATION_ERROR_19e00350 = 0x19e00350, - VALIDATION_ERROR_19e00352 = 0x19e00352, - VALIDATION_ERROR_19e00354 = 0x19e00354, - VALIDATION_ERROR_19e00356 = 0x19e00356, - VALIDATION_ERROR_19e02401 = 0x19e02401, - VALIDATION_ERROR_19e02413 = 0x19e02413, - VALIDATION_ERROR_19e02415 = 0x19e02415, - VALIDATION_ERROR_1a000009 = 0x1a000009, - VALIDATION_ERROR_1a000017 = 0x1a000017, - VALIDATION_ERROR_1a000322 = 0x1a000322, - VALIDATION_ERROR_1a000324 = 0x1a000324, - VALIDATION_ERROR_1a000326 = 0x1a000326, - VALIDATION_ERROR_1a000328 = 0x1a000328, - VALIDATION_ERROR_1a00032a = 0x1a00032a, - VALIDATION_ERROR_1a00032c = 0x1a00032c, - VALIDATION_ERROR_1a00032e = 0x1a00032e, - VALIDATION_ERROR_1a000330 = 0x1a000330, - VALIDATION_ERROR_1a000332 = 0x1a000332, - VALIDATION_ERROR_1a000334 = 0x1a000334, - VALIDATION_ERROR_1a000336 = 0x1a000336, - VALIDATION_ERROR_1a000338 = 0x1a000338, - VALIDATION_ERROR_1a00033a = 0x1a00033a, - VALIDATION_ERROR_1a00033c = 0x1a00033c, - VALIDATION_ERROR_1a00033e = 0x1a00033e, - VALIDATION_ERROR_1a000340 = 0x1a000340, - VALIDATION_ERROR_1a000e6e = 0x1a000e6e, - VALIDATION_ERROR_1a000e70 = 0x1a000e70, - VALIDATION_ERROR_1a000e72 = 0x1a000e72, - VALIDATION_ERROR_1a001a01 = 0x1a001a01, - VALIDATION_ERROR_1a002401 = 0x1a002401, - VALIDATION_ERROR_1a002413 = 0x1a002413, - VALIDATION_ERROR_1a002415 = 0x1a002415, - VALIDATION_ERROR_1a200017 = 0x1a200017, - VALIDATION_ERROR_1a200366 = 0x1a200366, - VALIDATION_ERROR_1a200368 = 0x1a200368, - VALIDATION_ERROR_1a20036a = 0x1a20036a, - VALIDATION_ERROR_1a20036c = 0x1a20036c, - VALIDATION_ERROR_1a20036e = 0x1a20036e, - VALIDATION_ERROR_1a200370 = 0x1a200370, - VALIDATION_ERROR_1a200372 = 0x1a200372, - VALIDATION_ERROR_1a200374 = 0x1a200374, - VALIDATION_ERROR_1a200376 = 0x1a200376, - VALIDATION_ERROR_1a200378 = 0x1a200378, - VALIDATION_ERROR_1a20037a = 0x1a20037a, - VALIDATION_ERROR_1a20037c = 0x1a20037c, - VALIDATION_ERROR_1a20037e = 0x1a20037e, - VALIDATION_ERROR_1a200380 = 0x1a200380, - VALIDATION_ERROR_1a200382 = 0x1a200382, - VALIDATION_ERROR_1a200384 = 0x1a200384, - VALIDATION_ERROR_1a200386 = 0x1a200386, - VALIDATION_ERROR_1a200388 = 0x1a200388, - VALIDATION_ERROR_1a20038a = 0x1a20038a, - VALIDATION_ERROR_1a200bb6 = 0x1a200bb6, - VALIDATION_ERROR_1a200bd0 = 0x1a200bd0, - VALIDATION_ERROR_1a200e74 = 0x1a200e74, - VALIDATION_ERROR_1a200e76 = 0x1a200e76, - VALIDATION_ERROR_1a200e78 = 0x1a200e78, - VALIDATION_ERROR_1a202401 = 0x1a202401, - VALIDATION_ERROR_1a202413 = 0x1a202413, - VALIDATION_ERROR_1a202415 = 0x1a202415, - VALIDATION_ERROR_1a400017 = 0x1a400017, - VALIDATION_ERROR_1a40038c = 0x1a40038c, - VALIDATION_ERROR_1a40038e = 0x1a40038e, - VALIDATION_ERROR_1a400390 = 0x1a400390, - VALIDATION_ERROR_1a400392 = 0x1a400392, - VALIDATION_ERROR_1a400394 = 0x1a400394, - VALIDATION_ERROR_1a400396 = 0x1a400396, - VALIDATION_ERROR_1a400398 = 0x1a400398, - VALIDATION_ERROR_1a40039a = 0x1a40039a, - VALIDATION_ERROR_1a40039c = 0x1a40039c, - VALIDATION_ERROR_1a40039e = 0x1a40039e, - VALIDATION_ERROR_1a4003a0 = 0x1a4003a0, - VALIDATION_ERROR_1a4003a2 = 0x1a4003a2, - VALIDATION_ERROR_1a4003a4 = 0x1a4003a4, - VALIDATION_ERROR_1a4003a6 = 0x1a4003a6, - VALIDATION_ERROR_1a4003a8 = 0x1a4003a8, - VALIDATION_ERROR_1a4003aa = 0x1a4003aa, - VALIDATION_ERROR_1a4003ac = 0x1a4003ac, - VALIDATION_ERROR_1a4003ae = 0x1a4003ae, - VALIDATION_ERROR_1a4003b0 = 0x1a4003b0, - VALIDATION_ERROR_1a4003b2 = 0x1a4003b2, - VALIDATION_ERROR_1a400bb8 = 0x1a400bb8, - VALIDATION_ERROR_1a400bd2 = 0x1a400bd2, - VALIDATION_ERROR_1a400e7a = 0x1a400e7a, - VALIDATION_ERROR_1a400e7c = 0x1a400e7c, - VALIDATION_ERROR_1a400e7e = 0x1a400e7e, - VALIDATION_ERROR_1a402401 = 0x1a402401, - VALIDATION_ERROR_1a402413 = 0x1a402413, - VALIDATION_ERROR_1a402415 = 0x1a402415, - VALIDATION_ERROR_1a600009 = 0x1a600009, - VALIDATION_ERROR_1a600017 = 0x1a600017, - VALIDATION_ERROR_1a60041c = 0x1a60041c, - VALIDATION_ERROR_1a60041e = 0x1a60041e, - VALIDATION_ERROR_1a600420 = 0x1a600420, - VALIDATION_ERROR_1a600422 = 0x1a600422, - VALIDATION_ERROR_1a600424 = 0x1a600424, - VALIDATION_ERROR_1a600426 = 0x1a600426, - VALIDATION_ERROR_1a600428 = 0x1a600428, - VALIDATION_ERROR_1a60042a = 0x1a60042a, - VALIDATION_ERROR_1a60042c = 0x1a60042c, - VALIDATION_ERROR_1a60042e = 0x1a60042e, - VALIDATION_ERROR_1a600430 = 0x1a600430, - VALIDATION_ERROR_1a600432 = 0x1a600432, - VALIDATION_ERROR_1a600434 = 0x1a600434, - VALIDATION_ERROR_1a600436 = 0x1a600436, - VALIDATION_ERROR_1a600438 = 0x1a600438, - VALIDATION_ERROR_1a60043a = 0x1a60043a, - VALIDATION_ERROR_1a60043c = 0x1a60043c, - VALIDATION_ERROR_1a60043e = 0x1a60043e, - VALIDATION_ERROR_1a600440 = 0x1a600440, - VALIDATION_ERROR_1a600442 = 0x1a600442, - VALIDATION_ERROR_1a600444 = 0x1a600444, - VALIDATION_ERROR_1a600446 = 0x1a600446, - VALIDATION_ERROR_1a600448 = 0x1a600448, - VALIDATION_ERROR_1a60044a = 0x1a60044a, - VALIDATION_ERROR_1a60044c = 0x1a60044c, - VALIDATION_ERROR_1a60044e = 0x1a60044e, - VALIDATION_ERROR_1a600bbe = 0x1a600bbe, - VALIDATION_ERROR_1a600bd8 = 0x1a600bd8, - VALIDATION_ERROR_1a600d02 = 0x1a600d02, - VALIDATION_ERROR_1a600e8c = 0x1a600e8c, - VALIDATION_ERROR_1a600e8e = 0x1a600e8e, - VALIDATION_ERROR_1a600e90 = 0x1a600e90, - VALIDATION_ERROR_1a601a01 = 0x1a601a01, - VALIDATION_ERROR_1a602401 = 0x1a602401, - VALIDATION_ERROR_1a602413 = 0x1a602413, - VALIDATION_ERROR_1a602415 = 0x1a602415, - VALIDATION_ERROR_1a800009 = 0x1a800009, - VALIDATION_ERROR_1a800017 = 0x1a800017, - VALIDATION_ERROR_1a800456 = 0x1a800456, - VALIDATION_ERROR_1a800458 = 0x1a800458, - VALIDATION_ERROR_1a80045a = 0x1a80045a, - VALIDATION_ERROR_1a80045c = 0x1a80045c, - VALIDATION_ERROR_1a80045e = 0x1a80045e, - VALIDATION_ERROR_1a800460 = 0x1a800460, - VALIDATION_ERROR_1a800462 = 0x1a800462, - VALIDATION_ERROR_1a800464 = 0x1a800464, - VALIDATION_ERROR_1a800466 = 0x1a800466, - VALIDATION_ERROR_1a800468 = 0x1a800468, - VALIDATION_ERROR_1a80046a = 0x1a80046a, - VALIDATION_ERROR_1a80046c = 0x1a80046c, - VALIDATION_ERROR_1a80046e = 0x1a80046e, - VALIDATION_ERROR_1a800470 = 0x1a800470, - VALIDATION_ERROR_1a800472 = 0x1a800472, - VALIDATION_ERROR_1a800474 = 0x1a800474, - VALIDATION_ERROR_1a800476 = 0x1a800476, - VALIDATION_ERROR_1a800478 = 0x1a800478, - VALIDATION_ERROR_1a80047a = 0x1a80047a, - VALIDATION_ERROR_1a80047c = 0x1a80047c, - VALIDATION_ERROR_1a80047e = 0x1a80047e, - VALIDATION_ERROR_1a800480 = 0x1a800480, - VALIDATION_ERROR_1a800482 = 0x1a800482, - VALIDATION_ERROR_1a800484 = 0x1a800484, - VALIDATION_ERROR_1a800bc0 = 0x1a800bc0, - VALIDATION_ERROR_1a800bda = 0x1a800bda, - VALIDATION_ERROR_1a800d04 = 0x1a800d04, - VALIDATION_ERROR_1a800d06 = 0x1a800d06, - VALIDATION_ERROR_1a800d08 = 0x1a800d08, - VALIDATION_ERROR_1a800d0a = 0x1a800d0a, - VALIDATION_ERROR_1a800e92 = 0x1a800e92, - VALIDATION_ERROR_1a800e94 = 0x1a800e94, - VALIDATION_ERROR_1a800e96 = 0x1a800e96, - VALIDATION_ERROR_1a801a01 = 0x1a801a01, - VALIDATION_ERROR_1a802401 = 0x1a802401, - VALIDATION_ERROR_1a802413 = 0x1a802413, - VALIDATION_ERROR_1a802415 = 0x1a802415, - VALIDATION_ERROR_1a803401 = 0x1a803401, - VALIDATION_ERROR_1aa00009 = 0x1aa00009, - VALIDATION_ERROR_1aa00017 = 0x1aa00017, - VALIDATION_ERROR_1aa003b4 = 0x1aa003b4, - VALIDATION_ERROR_1aa003b6 = 0x1aa003b6, - VALIDATION_ERROR_1aa003b8 = 0x1aa003b8, - VALIDATION_ERROR_1aa003ba = 0x1aa003ba, - VALIDATION_ERROR_1aa003bc = 0x1aa003bc, - VALIDATION_ERROR_1aa003be = 0x1aa003be, - VALIDATION_ERROR_1aa003c0 = 0x1aa003c0, - VALIDATION_ERROR_1aa003c2 = 0x1aa003c2, - VALIDATION_ERROR_1aa003c4 = 0x1aa003c4, - VALIDATION_ERROR_1aa003c6 = 0x1aa003c6, - VALIDATION_ERROR_1aa003c8 = 0x1aa003c8, - VALIDATION_ERROR_1aa003ca = 0x1aa003ca, - VALIDATION_ERROR_1aa003cc = 0x1aa003cc, - VALIDATION_ERROR_1aa003ce = 0x1aa003ce, - VALIDATION_ERROR_1aa003d0 = 0x1aa003d0, - VALIDATION_ERROR_1aa003d2 = 0x1aa003d2, - VALIDATION_ERROR_1aa003d4 = 0x1aa003d4, - VALIDATION_ERROR_1aa003d6 = 0x1aa003d6, - VALIDATION_ERROR_1aa003d8 = 0x1aa003d8, - VALIDATION_ERROR_1aa003da = 0x1aa003da, - VALIDATION_ERROR_1aa003dc = 0x1aa003dc, - VALIDATION_ERROR_1aa003de = 0x1aa003de, - VALIDATION_ERROR_1aa003e0 = 0x1aa003e0, - VALIDATION_ERROR_1aa003e2 = 0x1aa003e2, - VALIDATION_ERROR_1aa003e4 = 0x1aa003e4, - VALIDATION_ERROR_1aa003e6 = 0x1aa003e6, - VALIDATION_ERROR_1aa00bba = 0x1aa00bba, - VALIDATION_ERROR_1aa00bd4 = 0x1aa00bd4, - VALIDATION_ERROR_1aa00cf8 = 0x1aa00cf8, - VALIDATION_ERROR_1aa00e80 = 0x1aa00e80, - VALIDATION_ERROR_1aa00e82 = 0x1aa00e82, - VALIDATION_ERROR_1aa00e84 = 0x1aa00e84, - VALIDATION_ERROR_1aa01a01 = 0x1aa01a01, - VALIDATION_ERROR_1aa02401 = 0x1aa02401, - VALIDATION_ERROR_1aa02413 = 0x1aa02413, - VALIDATION_ERROR_1aa02415 = 0x1aa02415, - VALIDATION_ERROR_1ac00009 = 0x1ac00009, - VALIDATION_ERROR_1ac00017 = 0x1ac00017, - VALIDATION_ERROR_1ac003ec = 0x1ac003ec, - VALIDATION_ERROR_1ac003ee = 0x1ac003ee, - VALIDATION_ERROR_1ac003f0 = 0x1ac003f0, - VALIDATION_ERROR_1ac003f2 = 0x1ac003f2, - VALIDATION_ERROR_1ac003f4 = 0x1ac003f4, - VALIDATION_ERROR_1ac003f6 = 0x1ac003f6, - VALIDATION_ERROR_1ac003f8 = 0x1ac003f8, - VALIDATION_ERROR_1ac003fa = 0x1ac003fa, - VALIDATION_ERROR_1ac003fc = 0x1ac003fc, - VALIDATION_ERROR_1ac003fe = 0x1ac003fe, - VALIDATION_ERROR_1ac00400 = 0x1ac00400, - VALIDATION_ERROR_1ac00402 = 0x1ac00402, - VALIDATION_ERROR_1ac00404 = 0x1ac00404, - VALIDATION_ERROR_1ac00406 = 0x1ac00406, - VALIDATION_ERROR_1ac00408 = 0x1ac00408, - VALIDATION_ERROR_1ac0040a = 0x1ac0040a, - VALIDATION_ERROR_1ac0040c = 0x1ac0040c, - VALIDATION_ERROR_1ac0040e = 0x1ac0040e, - VALIDATION_ERROR_1ac00410 = 0x1ac00410, - VALIDATION_ERROR_1ac00412 = 0x1ac00412, - VALIDATION_ERROR_1ac00414 = 0x1ac00414, - VALIDATION_ERROR_1ac00416 = 0x1ac00416, - VALIDATION_ERROR_1ac00418 = 0x1ac00418, - VALIDATION_ERROR_1ac0041a = 0x1ac0041a, - VALIDATION_ERROR_1ac00bbc = 0x1ac00bbc, - VALIDATION_ERROR_1ac00bd6 = 0x1ac00bd6, - VALIDATION_ERROR_1ac00cfa = 0x1ac00cfa, - VALIDATION_ERROR_1ac00cfc = 0x1ac00cfc, - VALIDATION_ERROR_1ac00cfe = 0x1ac00cfe, - VALIDATION_ERROR_1ac00d00 = 0x1ac00d00, - VALIDATION_ERROR_1ac00e86 = 0x1ac00e86, - VALIDATION_ERROR_1ac00e88 = 0x1ac00e88, - VALIDATION_ERROR_1ac00e8a = 0x1ac00e8a, - VALIDATION_ERROR_1ac01a01 = 0x1ac01a01, - VALIDATION_ERROR_1ac02401 = 0x1ac02401, - VALIDATION_ERROR_1ac02413 = 0x1ac02413, - VALIDATION_ERROR_1ac02415 = 0x1ac02415, - VALIDATION_ERROR_1ac03401 = 0x1ac03401, - VALIDATION_ERROR_1ae00009 = 0x1ae00009, - VALIDATION_ERROR_1ae00654 = 0x1ae00654, - VALIDATION_ERROR_1ae00658 = 0x1ae00658, - VALIDATION_ERROR_1ae00ebc = 0x1ae00ebc, - VALIDATION_ERROR_1ae00f06 = 0x1ae00f06, - VALIDATION_ERROR_1ae02401 = 0x1ae02401, - VALIDATION_ERROR_1ae02413 = 0x1ae02413, - VALIDATION_ERROR_1ae02415 = 0x1ae02415, - VALIDATION_ERROR_1ae29801 = 0x1ae29801, - VALIDATION_ERROR_1b000017 = 0x1b000017, - VALIDATION_ERROR_1b000019 = 0x1b000019, - VALIDATION_ERROR_1b00071c = 0x1b00071c, - VALIDATION_ERROR_1b002401 = 0x1b002401, - VALIDATION_ERROR_1b002413 = 0x1b002413, - VALIDATION_ERROR_1b002415 = 0x1b002415, - VALIDATION_ERROR_1b200009 = 0x1b200009, - VALIDATION_ERROR_1b200019 = 0x1b200019, - VALIDATION_ERROR_1b2000ae = 0x1b2000ae, - VALIDATION_ERROR_1b2000b0 = 0x1b2000b0, - VALIDATION_ERROR_1b2000b2 = 0x1b2000b2, - VALIDATION_ERROR_1b2000b4 = 0x1b2000b4, - VALIDATION_ERROR_1b2000b6 = 0x1b2000b6, - VALIDATION_ERROR_1b2000b8 = 0x1b2000b8, - VALIDATION_ERROR_1b2000ba = 0x1b2000ba, - VALIDATION_ERROR_1b2000bc = 0x1b2000bc, - VALIDATION_ERROR_1b2000be = 0x1b2000be, - VALIDATION_ERROR_1b2000c0 = 0x1b2000c0, - VALIDATION_ERROR_1b2000c2 = 0x1b2000c2, - VALIDATION_ERROR_1b2000c4 = 0x1b2000c4, - VALIDATION_ERROR_1b2000c6 = 0x1b2000c6, - VALIDATION_ERROR_1b2000c8 = 0x1b2000c8, - VALIDATION_ERROR_1b2000ca = 0x1b2000ca, - VALIDATION_ERROR_1b2000cc = 0x1b2000cc, - VALIDATION_ERROR_1b2000ce = 0x1b2000ce, - VALIDATION_ERROR_1b2000d0 = 0x1b2000d0, - VALIDATION_ERROR_1b2000d2 = 0x1b2000d2, - VALIDATION_ERROR_1b200e38 = 0x1b200e38, - VALIDATION_ERROR_1b200e3a = 0x1b200e3a, - VALIDATION_ERROR_1b202401 = 0x1b202401, - VALIDATION_ERROR_1b202413 = 0x1b202413, - VALIDATION_ERROR_1b202415 = 0x1b202415, - VALIDATION_ERROR_1b20261b = 0x1b20261b, - VALIDATION_ERROR_1b211401 = 0x1b211401, - VALIDATION_ERROR_1b400009 = 0x1b400009, - VALIDATION_ERROR_1b400017 = 0x1b400017, - VALIDATION_ERROR_1b400030 = 0x1b400030, - VALIDATION_ERROR_1b400032 = 0x1b400032, - VALIDATION_ERROR_1b400034 = 0x1b400034, - VALIDATION_ERROR_1b400036 = 0x1b400036, - VALIDATION_ERROR_1b400038 = 0x1b400038, - VALIDATION_ERROR_1b40003a = 0x1b40003a, - VALIDATION_ERROR_1b40003c = 0x1b40003c, - VALIDATION_ERROR_1b40003e = 0x1b40003e, - VALIDATION_ERROR_1b400e26 = 0x1b400e26, - VALIDATION_ERROR_1b400e28 = 0x1b400e28, - VALIDATION_ERROR_1b402401 = 0x1b402401, - VALIDATION_ERROR_1b402413 = 0x1b402413, - VALIDATION_ERROR_1b402415 = 0x1b402415, - VALIDATION_ERROR_1b406c01 = 0x1b406c01, - VALIDATION_ERROR_1b600017 = 0x1b600017, - VALIDATION_ERROR_1b600019 = 0x1b600019, - VALIDATION_ERROR_1b60071a = 0x1b60071a, - VALIDATION_ERROR_1b602401 = 0x1b602401, - VALIDATION_ERROR_1b602413 = 0x1b602413, - VALIDATION_ERROR_1b602415 = 0x1b602415, - VALIDATION_ERROR_1b603201 = 0x1b603201, - VALIDATION_ERROR_1b800920 = 0x1b800920, - VALIDATION_ERROR_1b800922 = 0x1b800922, - VALIDATION_ERROR_1b800924 = 0x1b800924, - VALIDATION_ERROR_1b800926 = 0x1b800926, - VALIDATION_ERROR_1b800928 = 0x1b800928, - VALIDATION_ERROR_1b80092a = 0x1b80092a, - VALIDATION_ERROR_1b80092c = 0x1b80092c, - VALIDATION_ERROR_1b80092e = 0x1b80092e, - VALIDATION_ERROR_1b800930 = 0x1b800930, - VALIDATION_ERROR_1b800932 = 0x1b800932, - VALIDATION_ERROR_1b800934 = 0x1b800934, - VALIDATION_ERROR_1b800936 = 0x1b800936, - VALIDATION_ERROR_1b800938 = 0x1b800938, - VALIDATION_ERROR_1b80093a = 0x1b80093a, - VALIDATION_ERROR_1b80093c = 0x1b80093c, - VALIDATION_ERROR_1b80093e = 0x1b80093e, - VALIDATION_ERROR_1b800940 = 0x1b800940, - VALIDATION_ERROR_1b800942 = 0x1b800942, - VALIDATION_ERROR_1b800944 = 0x1b800944, - VALIDATION_ERROR_1b802401 = 0x1b802401, - VALIDATION_ERROR_1b802413 = 0x1b802413, - VALIDATION_ERROR_1b802415 = 0x1b802415, - VALIDATION_ERROR_1b803e01 = 0x1b803e01, - VALIDATION_ERROR_1b807801 = 0x1b807801, - VALIDATION_ERROR_1b807803 = 0x1b807803, - VALIDATION_ERROR_1b810401 = 0x1b810401, - VALIDATION_ERROR_1b818a01 = 0x1b818a01, - VALIDATION_ERROR_1b81ac01 = 0x1b81ac01, - VALIDATION_ERROR_1b82d401 = 0x1b82d401, - VALIDATION_ERROR_1b82d403 = 0x1b82d403, - VALIDATION_ERROR_1ba00017 = 0x1ba00017, - VALIDATION_ERROR_1ba02401 = 0x1ba02401, - VALIDATION_ERROR_1ba02413 = 0x1ba02413, - VALIDATION_ERROR_1ba02415 = 0x1ba02415, - VALIDATION_ERROR_1ba1f201 = 0x1ba1f201, - VALIDATION_ERROR_1bc00009 = 0x1bc00009, - VALIDATION_ERROR_1bc002e0 = 0x1bc002e0, - VALIDATION_ERROR_1bc002e2 = 0x1bc002e2, - VALIDATION_ERROR_1bc002e4 = 0x1bc002e4, - VALIDATION_ERROR_1bc002e6 = 0x1bc002e6, - VALIDATION_ERROR_1bc00e06 = 0x1bc00e06, - VALIDATION_ERROR_1bc00e08 = 0x1bc00e08, - VALIDATION_ERROR_1bc02401 = 0x1bc02401, - VALIDATION_ERROR_1bc02413 = 0x1bc02413, - VALIDATION_ERROR_1bc02415 = 0x1bc02415, - VALIDATION_ERROR_1bc0be01 = 0x1bc0be01, - VALIDATION_ERROR_1bc26201 = 0x1bc26201, - VALIDATION_ERROR_1bc2c21b = 0x1bc2c21b, - VALIDATION_ERROR_1bc2dc01 = 0x1bc2dc01, - VALIDATION_ERROR_1bc2dc03 = 0x1bc2dc03, - VALIDATION_ERROR_1be00009 = 0x1be00009, - VALIDATION_ERROR_1be002d6 = 0x1be002d6, - VALIDATION_ERROR_1be002d8 = 0x1be002d8, - VALIDATION_ERROR_1be002da = 0x1be002da, - VALIDATION_ERROR_1be02401 = 0x1be02401, - VALIDATION_ERROR_1be02413 = 0x1be02413, - VALIDATION_ERROR_1be02415 = 0x1be02415, - VALIDATION_ERROR_1be0541b = 0x1be0541b, - VALIDATION_ERROR_1be0be01 = 0x1be0be01, - VALIDATION_ERROR_1be13601 = 0x1be13601, - VALIDATION_ERROR_1be27e01 = 0x1be27e01, - VALIDATION_ERROR_1c000009 = 0x1c000009, - VALIDATION_ERROR_1c0002dc = 0x1c0002dc, - VALIDATION_ERROR_1c000d2c = 0x1c000d2c, - VALIDATION_ERROR_1c002401 = 0x1c002401, - VALIDATION_ERROR_1c002413 = 0x1c002413, - VALIDATION_ERROR_1c002415 = 0x1c002415, - VALIDATION_ERROR_1c005201 = 0x1c005201, - VALIDATION_ERROR_1c00be01 = 0x1c00be01, - VALIDATION_ERROR_1c200017 = 0x1c200017, - VALIDATION_ERROR_1c200019 = 0x1c200019, - VALIDATION_ERROR_1c200a62 = 0x1c200a62, - VALIDATION_ERROR_1c200a64 = 0x1c200a64, - VALIDATION_ERROR_1c202401 = 0x1c202401, - VALIDATION_ERROR_1c202413 = 0x1c202413, - VALIDATION_ERROR_1c202415 = 0x1c202415, - VALIDATION_ERROR_1c221a01 = 0x1c221a01, - VALIDATION_ERROR_1c400009 = 0x1c400009, - VALIDATION_ERROR_1c400017 = 0x1c400017, - VALIDATION_ERROR_1c400902 = 0x1c400902, - VALIDATION_ERROR_1c400904 = 0x1c400904, - VALIDATION_ERROR_1c400906 = 0x1c400906, - VALIDATION_ERROR_1c400908 = 0x1c400908, - VALIDATION_ERROR_1c40090a = 0x1c40090a, - VALIDATION_ERROR_1c402401 = 0x1c402401, - VALIDATION_ERROR_1c402413 = 0x1c402413, - VALIDATION_ERROR_1c402415 = 0x1c402415, - VALIDATION_ERROR_1c407e01 = 0x1c407e01, - VALIDATION_ERROR_1c42de01 = 0x1c42de01, - VALIDATION_ERROR_1c42de03 = 0x1c42de03, - VALIDATION_ERROR_1c600009 = 0x1c600009, - VALIDATION_ERROR_1c600017 = 0x1c600017, - VALIDATION_ERROR_1c600638 = 0x1c600638, - VALIDATION_ERROR_1c60063a = 0x1c60063a, - VALIDATION_ERROR_1c602401 = 0x1c602401, - VALIDATION_ERROR_1c602413 = 0x1c602413, - VALIDATION_ERROR_1c602415 = 0x1c602415, - VALIDATION_ERROR_1c629801 = 0x1c629801, - VALIDATION_ERROR_1c800009 = 0x1c800009, - VALIDATION_ERROR_1c800017 = 0x1c800017, - VALIDATION_ERROR_1c8001fa = 0x1c8001fa, - VALIDATION_ERROR_1c8001fc = 0x1c8001fc, - VALIDATION_ERROR_1c8001fe = 0x1c8001fe, - VALIDATION_ERROR_1c800200 = 0x1c800200, - VALIDATION_ERROR_1c800202 = 0x1c800202, - VALIDATION_ERROR_1c800204 = 0x1c800204, - VALIDATION_ERROR_1c800206 = 0x1c800206, - VALIDATION_ERROR_1c800208 = 0x1c800208, - VALIDATION_ERROR_1c80020a = 0x1c80020a, - VALIDATION_ERROR_1c80020c = 0x1c80020c, - VALIDATION_ERROR_1c80020e = 0x1c80020e, - VALIDATION_ERROR_1c800210 = 0x1c800210, - VALIDATION_ERROR_1c800212 = 0x1c800212, - VALIDATION_ERROR_1c800ad4 = 0x1c800ad4, - VALIDATION_ERROR_1c800af0 = 0x1c800af0, - VALIDATION_ERROR_1c800af2 = 0x1c800af2, - VALIDATION_ERROR_1c800d5a = 0x1c800d5a, - VALIDATION_ERROR_1c800d5c = 0x1c800d5c, - VALIDATION_ERROR_1c800d5e = 0x1c800d5e, - VALIDATION_ERROR_1c800d60 = 0x1c800d60, - VALIDATION_ERROR_1c800e5a = 0x1c800e5a, - VALIDATION_ERROR_1c800e5c = 0x1c800e5c, - VALIDATION_ERROR_1c800e5e = 0x1c800e5e, - VALIDATION_ERROR_1c802401 = 0x1c802401, - VALIDATION_ERROR_1c802413 = 0x1c802413, - VALIDATION_ERROR_1c802415 = 0x1c802415, - VALIDATION_ERROR_1c807201 = 0x1c807201, - VALIDATION_ERROR_1c807401 = 0x1c807401, - VALIDATION_ERROR_1c821001 = 0x1c821001, - VALIDATION_ERROR_1c82ac1b = 0x1c82ac1b, - VALIDATION_ERROR_1c82ce01 = 0x1c82ce01, - VALIDATION_ERROR_1c82d001 = 0x1c82d001, - VALIDATION_ERROR_1ca004c8 = 0x1ca004c8, - VALIDATION_ERROR_1ca02401 = 0x1ca02401, - VALIDATION_ERROR_1ca02413 = 0x1ca02413, - VALIDATION_ERROR_1ca02415 = 0x1ca02415, - VALIDATION_ERROR_1cc0062a = 0x1cc0062a, - VALIDATION_ERROR_1cc0062c = 0x1cc0062c, - VALIDATION_ERROR_1cc02401 = 0x1cc02401, - VALIDATION_ERROR_1cc02413 = 0x1cc02413, - VALIDATION_ERROR_1cc02415 = 0x1cc02415, - VALIDATION_ERROR_1ce004ae = 0x1ce004ae, - VALIDATION_ERROR_1ce004b0 = 0x1ce004b0, - VALIDATION_ERROR_1ce004b2 = 0x1ce004b2, - VALIDATION_ERROR_1ce02401 = 0x1ce02401, - VALIDATION_ERROR_1ce02413 = 0x1ce02413, - VALIDATION_ERROR_1ce02415 = 0x1ce02415, - VALIDATION_ERROR_1d0000d8 = 0x1d0000d8, - VALIDATION_ERROR_1d0000da = 0x1d0000da, - VALIDATION_ERROR_1d0000dc = 0x1d0000dc, - VALIDATION_ERROR_1d0000de = 0x1d0000de, - VALIDATION_ERROR_1d002401 = 0x1d002401, - VALIDATION_ERROR_1d002413 = 0x1d002413, - VALIDATION_ERROR_1d002415 = 0x1d002415, - VALIDATION_ERROR_1d20048e = 0x1d20048e, - VALIDATION_ERROR_1d200492 = 0x1d200492, - VALIDATION_ERROR_1d200496 = 0x1d200496, - VALIDATION_ERROR_1d200498 = 0x1d200498, - VALIDATION_ERROR_1d20049a = 0x1d20049a, - VALIDATION_ERROR_1d202401 = 0x1d202401, - VALIDATION_ERROR_1d202413 = 0x1d202413, - VALIDATION_ERROR_1d202415 = 0x1d202415, - VALIDATION_ERROR_1d205c1b = 0x1d205c1b, - VALIDATION_ERROR_1d214601 = 0x1d214601, - VALIDATION_ERROR_1d400009 = 0x1d400009, - VALIDATION_ERROR_1d400017 = 0x1d400017, - VALIDATION_ERROR_1d4008fa = 0x1d4008fa, - VALIDATION_ERROR_1d4008fc = 0x1d4008fc, - VALIDATION_ERROR_1d4008fe = 0x1d4008fe, - VALIDATION_ERROR_1d400900 = 0x1d400900, - VALIDATION_ERROR_1d402401 = 0x1d402401, - VALIDATION_ERROR_1d402413 = 0x1d402413, - VALIDATION_ERROR_1d402415 = 0x1d402415, - VALIDATION_ERROR_1d407e01 = 0x1d407e01, - VALIDATION_ERROR_1d42de01 = 0x1d42de01, - VALIDATION_ERROR_1d42de03 = 0x1d42de03, - VALIDATION_ERROR_1d600626 = 0x1d600626, - VALIDATION_ERROR_1d600628 = 0x1d600628, - VALIDATION_ERROR_1d602401 = 0x1d602401, - VALIDATION_ERROR_1d602413 = 0x1d602413, - VALIDATION_ERROR_1d602415 = 0x1d602415, - VALIDATION_ERROR_1d80049c = 0x1d80049c, - VALIDATION_ERROR_1d80049e = 0x1d80049e, - VALIDATION_ERROR_1d8004a0 = 0x1d8004a0, - VALIDATION_ERROR_1d8004a2 = 0x1d8004a2, - VALIDATION_ERROR_1d8004a4 = 0x1d8004a4, - VALIDATION_ERROR_1d8004a6 = 0x1d8004a6, - VALIDATION_ERROR_1d8004a8 = 0x1d8004a8, - VALIDATION_ERROR_1d8004aa = 0x1d8004aa, - VALIDATION_ERROR_1d802401 = 0x1d802401, - VALIDATION_ERROR_1d802413 = 0x1d802413, - VALIDATION_ERROR_1d802415 = 0x1d802415, - VALIDATION_ERROR_1d822601 = 0x1d822601, - VALIDATION_ERROR_1d82b61b = 0x1d82b61b, - VALIDATION_ERROR_1da004b4 = 0x1da004b4, - VALIDATION_ERROR_1da02401 = 0x1da02401, - VALIDATION_ERROR_1da02413 = 0x1da02413, - VALIDATION_ERROR_1da02415 = 0x1da02415, - VALIDATION_ERROR_1da08401 = 0x1da08401, - VALIDATION_ERROR_1da08403 = 0x1da08403, - VALIDATION_ERROR_1dc004b8 = 0x1dc004b8, - VALIDATION_ERROR_1dc02401 = 0x1dc02401, - VALIDATION_ERROR_1dc02413 = 0x1dc02413, - VALIDATION_ERROR_1dc02415 = 0x1dc02415, - VALIDATION_ERROR_1dc08401 = 0x1dc08401, - VALIDATION_ERROR_1dc08403 = 0x1dc08403, - VALIDATION_ERROR_1de004b6 = 0x1de004b6, - VALIDATION_ERROR_1de02401 = 0x1de02401, - VALIDATION_ERROR_1de02413 = 0x1de02413, - VALIDATION_ERROR_1de02415 = 0x1de02415, - VALIDATION_ERROR_1de08401 = 0x1de08401, - VALIDATION_ERROR_1de08403 = 0x1de08403, - VALIDATION_ERROR_1e00098a = 0x1e00098a, - VALIDATION_ERROR_1e00098c = 0x1e00098c, - VALIDATION_ERROR_1e00098e = 0x1e00098e, - VALIDATION_ERROR_1e000990 = 0x1e000990, - VALIDATION_ERROR_1e000992 = 0x1e000992, - VALIDATION_ERROR_1e002401 = 0x1e002401, - VALIDATION_ERROR_1e002413 = 0x1e002413, - VALIDATION_ERROR_1e002415 = 0x1e002415, - VALIDATION_ERROR_1e030a1b = 0x1e030a1b, - VALIDATION_ERROR_1e03fa01 = 0x1e03fa01, - VALIDATION_ERROR_1e200a54 = 0x1e200a54, - VALIDATION_ERROR_1e200a56 = 0x1e200a56, - VALIDATION_ERROR_1e200a58 = 0x1e200a58, - VALIDATION_ERROR_1e202401 = 0x1e202401, - VALIDATION_ERROR_1e202413 = 0x1e202413, - VALIDATION_ERROR_1e202415 = 0x1e202415, - VALIDATION_ERROR_1e230a1b = 0x1e230a1b, - VALIDATION_ERROR_1e23fc01 = 0x1e23fc01, - VALIDATION_ERROR_1e400009 = 0x1e400009, - VALIDATION_ERROR_1e400017 = 0x1e400017, - VALIDATION_ERROR_1e400040 = 0x1e400040, - VALIDATION_ERROR_1e400042 = 0x1e400042, - VALIDATION_ERROR_1e400044 = 0x1e400044, - VALIDATION_ERROR_1e400046 = 0x1e400046, - VALIDATION_ERROR_1e400048 = 0x1e400048, - VALIDATION_ERROR_1e40004a = 0x1e40004a, - VALIDATION_ERROR_1e40004c = 0x1e40004c, - VALIDATION_ERROR_1e400e2a = 0x1e400e2a, - VALIDATION_ERROR_1e400e2c = 0x1e400e2c, - VALIDATION_ERROR_1e402401 = 0x1e402401, - VALIDATION_ERROR_1e402413 = 0x1e402413, - VALIDATION_ERROR_1e402415 = 0x1e402415, - VALIDATION_ERROR_1e403c1b = 0x1e403c1b, - VALIDATION_ERROR_1e406c01 = 0x1e406c01, - VALIDATION_ERROR_1e412201 = 0x1e412201, - VALIDATION_ERROR_1e600009 = 0x1e600009, - VALIDATION_ERROR_1e60090c = 0x1e60090c, - VALIDATION_ERROR_1e60090e = 0x1e60090e, - VALIDATION_ERROR_1e600910 = 0x1e600910, - VALIDATION_ERROR_1e600912 = 0x1e600912, - VALIDATION_ERROR_1e600914 = 0x1e600914, - VALIDATION_ERROR_1e600916 = 0x1e600916, - VALIDATION_ERROR_1e600918 = 0x1e600918, - VALIDATION_ERROR_1e60091a = 0x1e60091a, - VALIDATION_ERROR_1e60091c = 0x1e60091c, - VALIDATION_ERROR_1e60091e = 0x1e60091e, - VALIDATION_ERROR_1e602401 = 0x1e602401, - VALIDATION_ERROR_1e602413 = 0x1e602413, - VALIDATION_ERROR_1e602415 = 0x1e602415, - VALIDATION_ERROR_1e607801 = 0x1e607801, - VALIDATION_ERROR_1e607803 = 0x1e607803, - VALIDATION_ERROR_1e60801b = 0x1e60801b, - VALIDATION_ERROR_1e610401 = 0x1e610401, - VALIDATION_ERROR_1e616001 = 0x1e616001, - VALIDATION_ERROR_1e618a01 = 0x1e618a01, - VALIDATION_ERROR_1e61ac01 = 0x1e61ac01, - VALIDATION_ERROR_1e62d401 = 0x1e62d401, - VALIDATION_ERROR_1e62d403 = 0x1e62d403, - VALIDATION_ERROR_1e800009 = 0x1e800009, - VALIDATION_ERROR_1e800678 = 0x1e800678, - VALIDATION_ERROR_1e80067a = 0x1e80067a, - VALIDATION_ERROR_1e80067c = 0x1e80067c, - VALIDATION_ERROR_1e80067e = 0x1e80067e, - VALIDATION_ERROR_1e800b10 = 0x1e800b10, - VALIDATION_ERROR_1e802401 = 0x1e802401, - VALIDATION_ERROR_1e802413 = 0x1e802413, - VALIDATION_ERROR_1e802415 = 0x1e802415, - VALIDATION_ERROR_1e828401 = 0x1e828401, - VALIDATION_ERROR_1e829801 = 0x1e829801, - VALIDATION_ERROR_1ea0bc01 = 0x1ea0bc01, - VALIDATION_ERROR_1ea0ec01 = 0x1ea0ec01, - VALIDATION_ERROR_1ea11e01 = 0x1ea11e01, - VALIDATION_ERROR_1ea24801 = 0x1ea24801, - VALIDATION_ERROR_1ec0071e = 0x1ec0071e, - VALIDATION_ERROR_1ec05601 = 0x1ec05601, - VALIDATION_ERROR_1ec0ec01 = 0x1ec0ec01, - VALIDATION_ERROR_1ec10001 = 0x1ec10001, - VALIDATION_ERROR_1ec11e01 = 0x1ec11e01, - VALIDATION_ERROR_1ee05601 = 0x1ee05601, - VALIDATION_ERROR_1ee0ec01 = 0x1ee0ec01, - VALIDATION_ERROR_1ee11e01 = 0x1ee11e01, - VALIDATION_ERROR_1ee26a01 = 0x1ee26a01, - VALIDATION_ERROR_1f005601 = 0x1f005601, - VALIDATION_ERROR_1f00ec01 = 0x1f00ec01, - VALIDATION_ERROR_1f011601 = 0x1f011601, - VALIDATION_ERROR_1f011e01 = 0x1f011e01, - VALIDATION_ERROR_1f20056e = 0x1f20056e, - VALIDATION_ERROR_1f200570 = 0x1f200570, - VALIDATION_ERROR_1f20381b = 0x1f20381b, - VALIDATION_ERROR_1f205601 = 0x1f205601, - VALIDATION_ERROR_1f20ec01 = 0x1f20ec01, - VALIDATION_ERROR_1f212001 = 0x1f212001, - VALIDATION_ERROR_1f21e201 = 0x1f21e201, - VALIDATION_ERROR_1f228001 = 0x1f228001, - VALIDATION_ERROR_1f228007 = 0x1f228007, - VALIDATION_ERROR_1f40bc01 = 0x1f40bc01, - VALIDATION_ERROR_1f40ec01 = 0x1f40ec01, - VALIDATION_ERROR_1f410801 = 0x1f410801, - VALIDATION_ERROR_1f411e01 = 0x1f411e01, - VALIDATION_ERROR_1f605601 = 0x1f605601, - VALIDATION_ERROR_1f60ec01 = 0x1f60ec01, - VALIDATION_ERROR_1f611e01 = 0x1f611e01, - VALIDATION_ERROR_1f612e01 = 0x1f612e01, - VALIDATION_ERROR_1f805601 = 0x1f805601, - VALIDATION_ERROR_1f80ec01 = 0x1f80ec01, - VALIDATION_ERROR_1f811e01 = 0x1f811e01, - VALIDATION_ERROR_1f822a01 = 0x1f822a01, - VALIDATION_ERROR_1fa05601 = 0x1fa05601, - VALIDATION_ERROR_1fa0ec01 = 0x1fa0ec01, - VALIDATION_ERROR_1fa11e01 = 0x1fa11e01, - VALIDATION_ERROR_1fa13401 = 0x1fa13401, - VALIDATION_ERROR_1fc00ad6 = 0x1fc00ad6, - VALIDATION_ERROR_1fc0ec01 = 0x1fc0ec01, - VALIDATION_ERROR_1fc11e01 = 0x1fc11e01, - VALIDATION_ERROR_1fc13801 = 0x1fc13801, - VALIDATION_ERROR_1fc27a01 = 0x1fc27a01, - VALIDATION_ERROR_1fe06001 = 0x1fe06001, - VALIDATION_ERROR_1fe0ec01 = 0x1fe0ec01, - VALIDATION_ERROR_1fe11e01 = 0x1fe11e01, - VALIDATION_ERROR_1fe1bc01 = 0x1fe1bc01, - VALIDATION_ERROR_1fe27a01 = 0x1fe27a01, - VALIDATION_ERROR_2000bc01 = 0x2000bc01, - VALIDATION_ERROR_2000ec01 = 0x2000ec01, - VALIDATION_ERROR_20011e01 = 0x20011e01, - VALIDATION_ERROR_20024801 = 0x20024801, - VALIDATION_ERROR_20205601 = 0x20205601, - VALIDATION_ERROR_2020ec01 = 0x2020ec01, - VALIDATION_ERROR_20211e01 = 0x20211e01, - VALIDATION_ERROR_20215e01 = 0x20215e01, - VALIDATION_ERROR_20405601 = 0x20405601, - VALIDATION_ERROR_2040ec01 = 0x2040ec01, - VALIDATION_ERROR_20411e01 = 0x20411e01, - VALIDATION_ERROR_20417001 = 0x20417001, - VALIDATION_ERROR_20605601 = 0x20605601, - VALIDATION_ERROR_2060ec01 = 0x2060ec01, - VALIDATION_ERROR_20611e01 = 0x20611e01, - VALIDATION_ERROR_20617801 = 0x20617801, - VALIDATION_ERROR_208005a0 = 0x208005a0, - VALIDATION_ERROR_208005a2 = 0x208005a2, - VALIDATION_ERROR_2080381b = 0x2080381b, - VALIDATION_ERROR_20805601 = 0x20805601, - VALIDATION_ERROR_2080ec01 = 0x2080ec01, - VALIDATION_ERROR_20812001 = 0x20812001, - VALIDATION_ERROR_2081e201 = 0x2081e201, - VALIDATION_ERROR_20828001 = 0x20828001, - VALIDATION_ERROR_20828007 = 0x20828007, - VALIDATION_ERROR_20a0bc01 = 0x20a0bc01, - VALIDATION_ERROR_20a0ec01 = 0x20a0ec01, - VALIDATION_ERROR_20a11e01 = 0x20a11e01, - VALIDATION_ERROR_20a24801 = 0x20a24801, - VALIDATION_ERROR_20c00756 = 0x20c00756, - VALIDATION_ERROR_20c05601 = 0x20c05601, - VALIDATION_ERROR_20c0ec01 = 0x20c0ec01, - VALIDATION_ERROR_20c11e01 = 0x20c11e01, - VALIDATION_ERROR_20c17e01 = 0x20c17e01, - VALIDATION_ERROR_20e05601 = 0x20e05601, - VALIDATION_ERROR_20e0ec01 = 0x20e0ec01, - VALIDATION_ERROR_20e11e01 = 0x20e11e01, - VALIDATION_ERROR_20e26a01 = 0x20e26a01, - VALIDATION_ERROR_21005601 = 0x21005601, - VALIDATION_ERROR_2100ec01 = 0x2100ec01, - VALIDATION_ERROR_21011e01 = 0x21011e01, - VALIDATION_ERROR_21019201 = 0x21019201, - VALIDATION_ERROR_21200ad8 = 0x21200ad8, - VALIDATION_ERROR_2120ec01 = 0x2120ec01, - VALIDATION_ERROR_21211e01 = 0x21211e01, - VALIDATION_ERROR_21219c01 = 0x21219c01, - VALIDATION_ERROR_2140bc01 = 0x2140bc01, - VALIDATION_ERROR_2140ec01 = 0x2140ec01, - VALIDATION_ERROR_21411e01 = 0x21411e01, - VALIDATION_ERROR_21424801 = 0x21424801, - VALIDATION_ERROR_2160bc01 = 0x2160bc01, - VALIDATION_ERROR_2160ec01 = 0x2160ec01, - VALIDATION_ERROR_21611e01 = 0x21611e01, - VALIDATION_ERROR_21624801 = 0x21624801, - VALIDATION_ERROR_21805601 = 0x21805601, - VALIDATION_ERROR_2180ec01 = 0x2180ec01, - VALIDATION_ERROR_21811e01 = 0x21811e01, - VALIDATION_ERROR_2181d001 = 0x2181d001, - VALIDATION_ERROR_21a05601 = 0x21a05601, - VALIDATION_ERROR_21a0ec01 = 0x21a0ec01, - VALIDATION_ERROR_21a11e01 = 0x21a11e01, - VALIDATION_ERROR_21a1de01 = 0x21a1de01, - VALIDATION_ERROR_21c05601 = 0x21c05601, - VALIDATION_ERROR_21c0ec01 = 0x21c0ec01, - VALIDATION_ERROR_21c11e01 = 0x21c11e01, - VALIDATION_ERROR_21c1e001 = 0x21c1e001, - VALIDATION_ERROR_21e05601 = 0x21e05601, - VALIDATION_ERROR_21e0ec01 = 0x21e0ec01, - VALIDATION_ERROR_21e11e01 = 0x21e11e01, - VALIDATION_ERROR_21e1fa01 = 0x21e1fa01, - VALIDATION_ERROR_22005601 = 0x22005601, - VALIDATION_ERROR_2200ec01 = 0x2200ec01, - VALIDATION_ERROR_22011e01 = 0x22011e01, - VALIDATION_ERROR_22021601 = 0x22021601, - VALIDATION_ERROR_22205601 = 0x22205601, - VALIDATION_ERROR_2220ec01 = 0x2220ec01, - VALIDATION_ERROR_22211e01 = 0x22211e01, - VALIDATION_ERROR_22222401 = 0x22222401, - VALIDATION_ERROR_22405601 = 0x22405601, - VALIDATION_ERROR_2240ec01 = 0x2240ec01, - VALIDATION_ERROR_22411e01 = 0x22411e01, - VALIDATION_ERROR_22422801 = 0x22422801, - VALIDATION_ERROR_22605601 = 0x22605601, - VALIDATION_ERROR_2260ec01 = 0x2260ec01, - VALIDATION_ERROR_22611e01 = 0x22611e01, - VALIDATION_ERROR_22622e01 = 0x22622e01, - VALIDATION_ERROR_22805601 = 0x22805601, - VALIDATION_ERROR_2280ec01 = 0x2280ec01, - VALIDATION_ERROR_22812001 = 0x22812001, - VALIDATION_ERROR_22825801 = 0x22825801, - VALIDATION_ERROR_2282f21b = 0x2282f21b, - VALIDATION_ERROR_22a05601 = 0x22a05601, - VALIDATION_ERROR_22a0ec01 = 0x22a0ec01, - VALIDATION_ERROR_22a11e01 = 0x22a11e01, - VALIDATION_ERROR_22a25201 = 0x22a25201, - VALIDATION_ERROR_22c0bc01 = 0x22c0bc01, - VALIDATION_ERROR_22c0ec01 = 0x22c0ec01, - VALIDATION_ERROR_22c11e01 = 0x22c11e01, - VALIDATION_ERROR_22c24801 = 0x22c24801, - VALIDATION_ERROR_22e0bc01 = 0x22e0bc01, - VALIDATION_ERROR_22e0ec01 = 0x22e0ec01, - VALIDATION_ERROR_22e11e01 = 0x22e11e01, - VALIDATION_ERROR_22e24801 = 0x22e24801, - VALIDATION_ERROR_2300bc01 = 0x2300bc01, - VALIDATION_ERROR_2300ec01 = 0x2300ec01, - VALIDATION_ERROR_23011e01 = 0x23011e01, - VALIDATION_ERROR_23024801 = 0x23024801, - VALIDATION_ERROR_2320bc01 = 0x2320bc01, - VALIDATION_ERROR_2320ec01 = 0x2320ec01, - VALIDATION_ERROR_23211e01 = 0x23211e01, - VALIDATION_ERROR_23224801 = 0x23224801, - VALIDATION_ERROR_2340bc01 = 0x2340bc01, - VALIDATION_ERROR_2340ec01 = 0x2340ec01, - VALIDATION_ERROR_23411e01 = 0x23411e01, - VALIDATION_ERROR_23424801 = 0x23424801, - VALIDATION_ERROR_23605601 = 0x23605601, - VALIDATION_ERROR_2361c201 = 0x2361c201, - VALIDATION_ERROR_23805601 = 0x23805601, - VALIDATION_ERROR_23825c01 = 0x23825c01, - VALIDATION_ERROR_23a009b2 = 0x23a009b2, - VALIDATION_ERROR_23a00bb4 = 0x23a00bb4, - VALIDATION_ERROR_23a09001 = 0x23a09001, - VALIDATION_ERROR_23a09003 = 0x23a09003, - VALIDATION_ERROR_23a0bc01 = 0x23a0bc01, - VALIDATION_ERROR_23a0da01 = 0x23a0da01, - VALIDATION_ERROR_23a1a001 = 0x23a1a001, - VALIDATION_ERROR_23a1b801 = 0x23a1b801, - VALIDATION_ERROR_23c00734 = 0x23c00734, - VALIDATION_ERROR_23c00736 = 0x23c00736, - VALIDATION_ERROR_23c00738 = 0x23c00738, - VALIDATION_ERROR_23c01a01 = 0x23c01a01, - VALIDATION_ERROR_23c01a07 = 0x23c01a07, - VALIDATION_ERROR_23c05601 = 0x23c05601, - VALIDATION_ERROR_23c0ec01 = 0x23c0ec01, - VALIDATION_ERROR_23e00750 = 0x23e00750, - VALIDATION_ERROR_23e00752 = 0x23e00752, - VALIDATION_ERROR_23e00754 = 0x23e00754, - VALIDATION_ERROR_23e01c01 = 0x23e01c01, - VALIDATION_ERROR_23e01c07 = 0x23e01c07, - VALIDATION_ERROR_23e05601 = 0x23e05601, - VALIDATION_ERROR_23e0ec01 = 0x23e0ec01, - VALIDATION_ERROR_24000052 = 0x24000052, - VALIDATION_ERROR_24000054 = 0x24000054, - VALIDATION_ERROR_24000056 = 0x24000056, - VALIDATION_ERROR_24002801 = 0x24002801, - VALIDATION_ERROR_24002807 = 0x24002807, - VALIDATION_ERROR_24005601 = 0x24005601, - VALIDATION_ERROR_2400ec01 = 0x2400ec01, - VALIDATION_ERROR_242009b4 = 0x242009b4, - VALIDATION_ERROR_242009b6 = 0x242009b6, - VALIDATION_ERROR_24201e01 = 0x24201e01, - VALIDATION_ERROR_24201e07 = 0x24201e07, - VALIDATION_ERROR_2420bc01 = 0x2420bc01, - VALIDATION_ERROR_2420ec01 = 0x2420ec01, - VALIDATION_ERROR_2440025e = 0x2440025e, - VALIDATION_ERROR_24400260 = 0x24400260, - VALIDATION_ERROR_24400262 = 0x24400262, - VALIDATION_ERROR_24404601 = 0x24404601, - VALIDATION_ERROR_24404607 = 0x24404607, - VALIDATION_ERROR_24405601 = 0x24405601, - VALIDATION_ERROR_2440ec01 = 0x2440ec01, - VALIDATION_ERROR_24600238 = 0x24600238, - VALIDATION_ERROR_2460023a = 0x2460023a, - VALIDATION_ERROR_24604c01 = 0x24604c01, - VALIDATION_ERROR_24604c07 = 0x24604c07, - VALIDATION_ERROR_24605601 = 0x24605601, - VALIDATION_ERROR_2460ec01 = 0x2460ec01, - VALIDATION_ERROR_248002c8 = 0x248002c8, - VALIDATION_ERROR_248002ca = 0x248002ca, - VALIDATION_ERROR_24805201 = 0x24805201, - VALIDATION_ERROR_24805207 = 0x24805207, - VALIDATION_ERROR_24805601 = 0x24805601, - VALIDATION_ERROR_2480ec01 = 0x2480ec01, - VALIDATION_ERROR_24a002f4 = 0x24a002f4, - VALIDATION_ERROR_24a002f6 = 0x24a002f6, - VALIDATION_ERROR_24a002f8 = 0x24a002f8, - VALIDATION_ERROR_24a05601 = 0x24a05601, - VALIDATION_ERROR_24a0ec01 = 0x24a0ec01, - VALIDATION_ERROR_24c008f2 = 0x24c008f2, - VALIDATION_ERROR_24c008f4 = 0x24c008f4, - VALIDATION_ERROR_24c008f6 = 0x24c008f6, - VALIDATION_ERROR_24c05601 = 0x24c05601, - VALIDATION_ERROR_24c07e01 = 0x24c07e01, - VALIDATION_ERROR_24c07e07 = 0x24c07e07, - VALIDATION_ERROR_24c0ec01 = 0x24c0ec01, - VALIDATION_ERROR_24e008c0 = 0x24e008c0, - VALIDATION_ERROR_24e008c2 = 0x24e008c2, - VALIDATION_ERROR_24e008c4 = 0x24e008c4, - VALIDATION_ERROR_24e05601 = 0x24e05601, - VALIDATION_ERROR_24e08801 = 0x24e08801, - VALIDATION_ERROR_24e08807 = 0x24e08807, - VALIDATION_ERROR_24e0ec01 = 0x24e0ec01, - VALIDATION_ERROR_250006f8 = 0x250006f8, - VALIDATION_ERROR_250006fa = 0x250006fa, - VALIDATION_ERROR_250006fc = 0x250006fc, - VALIDATION_ERROR_25005601 = 0x25005601, - VALIDATION_ERROR_25009401 = 0x25009401, - VALIDATION_ERROR_25009407 = 0x25009407, - VALIDATION_ERROR_2500ec01 = 0x2500ec01, - VALIDATION_ERROR_252007d0 = 0x252007d0, - VALIDATION_ERROR_252007d2 = 0x252007d2, - VALIDATION_ERROR_252007d4 = 0x252007d4, - VALIDATION_ERROR_25205601 = 0x25205601, - VALIDATION_ERROR_2520a001 = 0x2520a001, - VALIDATION_ERROR_2520a007 = 0x2520a007, - VALIDATION_ERROR_2520ec01 = 0x2520ec01, - VALIDATION_ERROR_25400804 = 0x25400804, - VALIDATION_ERROR_25400806 = 0x25400806, - VALIDATION_ERROR_25400808 = 0x25400808, - VALIDATION_ERROR_25405601 = 0x25405601, - VALIDATION_ERROR_2540b001 = 0x2540b001, - VALIDATION_ERROR_2540b007 = 0x2540b007, - VALIDATION_ERROR_2540ec01 = 0x2540ec01, - VALIDATION_ERROR_25600a90 = 0x25600a90, - VALIDATION_ERROR_25600a92 = 0x25600a92, - VALIDATION_ERROR_25600a94 = 0x25600a94, - VALIDATION_ERROR_25605601 = 0x25605601, - VALIDATION_ERROR_2560b401 = 0x2560b401, - VALIDATION_ERROR_2560b407 = 0x2560b407, - VALIDATION_ERROR_2560ec01 = 0x2560ec01, - VALIDATION_ERROR_258004ea = 0x258004ea, - VALIDATION_ERROR_258004ec = 0x258004ec, - VALIDATION_ERROR_258004ee = 0x258004ee, - VALIDATION_ERROR_2580bc01 = 0x2580bc01, - VALIDATION_ERROR_2580ec01 = 0x2580ec01, - VALIDATION_ERROR_25a00aa2 = 0x25a00aa2, - VALIDATION_ERROR_25a00aa4 = 0x25a00aa4, - VALIDATION_ERROR_25a00aa6 = 0x25a00aa6, - VALIDATION_ERROR_25a05601 = 0x25a05601, - VALIDATION_ERROR_25a0d801 = 0x25a0d801, - VALIDATION_ERROR_25a0d807 = 0x25a0d807, - VALIDATION_ERROR_25a0ec01 = 0x25a0ec01, - VALIDATION_ERROR_25c005fa = 0x25c005fa, - VALIDATION_ERROR_25c005fc = 0x25c005fc, - VALIDATION_ERROR_25c005fe = 0x25c005fe, - VALIDATION_ERROR_25c05601 = 0x25c05601, - VALIDATION_ERROR_25c0ec01 = 0x25c0ec01, - VALIDATION_ERROR_25c27c01 = 0x25c27c01, - VALIDATION_ERROR_25c27c07 = 0x25c27c07, - VALIDATION_ERROR_25e00606 = 0x25e00606, - VALIDATION_ERROR_25e00608 = 0x25e00608, - VALIDATION_ERROR_25e05601 = 0x25e05601, - VALIDATION_ERROR_25e0ec01 = 0x25e0ec01, - VALIDATION_ERROR_25e28001 = 0x25e28001, - VALIDATION_ERROR_25e28007 = 0x25e28007, - VALIDATION_ERROR_26000256 = 0x26000256, - VALIDATION_ERROR_26000258 = 0x26000258, - VALIDATION_ERROR_26005601 = 0x26005601, - VALIDATION_ERROR_2600ec01 = 0x2600ec01, - VALIDATION_ERROR_26028201 = 0x26028201, - VALIDATION_ERROR_26028207 = 0x26028207, - VALIDATION_ERROR_26200632 = 0x26200632, - VALIDATION_ERROR_26200634 = 0x26200634, - VALIDATION_ERROR_26200636 = 0x26200636, - VALIDATION_ERROR_26205601 = 0x26205601, - VALIDATION_ERROR_2620ec01 = 0x2620ec01, - VALIDATION_ERROR_26229801 = 0x26229801, - VALIDATION_ERROR_26229807 = 0x26229807, - VALIDATION_ERROR_264006d2 = 0x264006d2, - VALIDATION_ERROR_264006d4 = 0x264006d4, - VALIDATION_ERROR_264006d6 = 0x264006d6, - VALIDATION_ERROR_26405601 = 0x26405601, - VALIDATION_ERROR_2640ec01 = 0x2640ec01, - VALIDATION_ERROR_2642ae01 = 0x2642ae01, - VALIDATION_ERROR_2642ae07 = 0x2642ae07, - VALIDATION_ERROR_26600874 = 0x26600874, - VALIDATION_ERROR_26600876 = 0x26600876, - VALIDATION_ERROR_26600878 = 0x26600878, - VALIDATION_ERROR_26605601 = 0x26605601, - VALIDATION_ERROR_2660ec01 = 0x2660ec01, - VALIDATION_ERROR_2662b201 = 0x2662b201, - VALIDATION_ERROR_2662b207 = 0x2662b207, - VALIDATION_ERROR_268008e2 = 0x268008e2, - VALIDATION_ERROR_268008e4 = 0x268008e4, - VALIDATION_ERROR_268008e6 = 0x268008e6, - VALIDATION_ERROR_26805601 = 0x26805601, - VALIDATION_ERROR_2680ec01 = 0x2680ec01, - VALIDATION_ERROR_2682b801 = 0x2682b801, - VALIDATION_ERROR_2682b807 = 0x2682b807, - VALIDATION_ERROR_26a00888 = 0x26a00888, - VALIDATION_ERROR_26a0088a = 0x26a0088a, - VALIDATION_ERROR_26a05601 = 0x26a05601, - VALIDATION_ERROR_26a0ec01 = 0x26a0ec01, - VALIDATION_ERROR_26a2be01 = 0x26a2be01, - VALIDATION_ERROR_26a2be07 = 0x26a2be07, - VALIDATION_ERROR_26c009e4 = 0x26c009e4, - VALIDATION_ERROR_26c009e6 = 0x26c009e6, - VALIDATION_ERROR_26c009e8 = 0x26c009e8, - VALIDATION_ERROR_26c0bc01 = 0x26c0bc01, - VALIDATION_ERROR_26c0ec01 = 0x26c0ec01, - VALIDATION_ERROR_26c2ec01 = 0x26c2ec01, - VALIDATION_ERROR_26c2ec07 = 0x26c2ec07, - VALIDATION_ERROR_26e00009 = 0x26e00009, - VALIDATION_ERROR_26e00a04 = 0x26e00a04, - VALIDATION_ERROR_26e00a06 = 0x26e00a06, - VALIDATION_ERROR_26e00a08 = 0x26e00a08, - VALIDATION_ERROR_26e05601 = 0x26e05601, - VALIDATION_ERROR_26e0ec01 = 0x26e0ec01, - VALIDATION_ERROR_26e2f001 = 0x26e2f001, - VALIDATION_ERROR_27005601 = 0x27005601, - VALIDATION_ERROR_27205601 = 0x27205601, - VALIDATION_ERROR_27206001 = 0x27206001, - VALIDATION_ERROR_27214e01 = 0x27214e01, - VALIDATION_ERROR_27400076 = 0x27400076, - VALIDATION_ERROR_27400078 = 0x27400078, - VALIDATION_ERROR_2740007a = 0x2740007a, - VALIDATION_ERROR_2740007c = 0x2740007c, - VALIDATION_ERROR_27400e2e = 0x27400e2e, - VALIDATION_ERROR_27402401 = 0x27402401, - VALIDATION_ERROR_27619e01 = 0x27619e01, - VALIDATION_ERROR_2761f401 = 0x2761f401, - VALIDATION_ERROR_2761f601 = 0x2761f601, - VALIDATION_ERROR_27627a01 = 0x27627a01, - VALIDATION_ERROR_2781f401 = 0x2781f401, - VALIDATION_ERROR_2781f601 = 0x2781f601, - VALIDATION_ERROR_27827a01 = 0x27827a01, - VALIDATION_ERROR_27a19e01 = 0x27a19e01, - VALIDATION_ERROR_27a1f401 = 0x27a1f401, - VALIDATION_ERROR_27a1f601 = 0x27a1f601, - VALIDATION_ERROR_27c1f401 = 0x27c1f401, - VALIDATION_ERROR_27c1f601 = 0x27c1f601, - VALIDATION_ERROR_27e0bc01 = 0x27e0bc01, - VALIDATION_ERROR_27e1d801 = 0x27e1d801, - VALIDATION_ERROR_27e1da01 = 0x27e1da01, - VALIDATION_ERROR_2800bc01 = 0x2800bc01, - VALIDATION_ERROR_2801d601 = 0x2801d601, - VALIDATION_ERROR_2801dc01 = 0x2801dc01, - VALIDATION_ERROR_28205601 = 0x28205601, - VALIDATION_ERROR_2820c81b = 0x2820c81b, - VALIDATION_ERROR_2821b201 = 0x2821b201, - VALIDATION_ERROR_2840005e = 0x2840005e, - VALIDATION_ERROR_28400060 = 0x28400060, - VALIDATION_ERROR_2840261b = 0x2840261b, - VALIDATION_ERROR_28402801 = 0x28402801, - VALIDATION_ERROR_28402807 = 0x28402807, - VALIDATION_ERROR_28405601 = 0x28405601, - VALIDATION_ERROR_28411407 = 0x28411407, - VALIDATION_ERROR_2860026a = 0x2860026a, - VALIDATION_ERROR_2860026c = 0x2860026c, - VALIDATION_ERROR_2860026e = 0x2860026e, - VALIDATION_ERROR_28600270 = 0x28600270, - VALIDATION_ERROR_28604601 = 0x28604601, - VALIDATION_ERROR_28604607 = 0x28604607, - VALIDATION_ERROR_28604a1b = 0x28604a1b, - VALIDATION_ERROR_28605601 = 0x28605601, - VALIDATION_ERROR_28613007 = 0x28613007, - VALIDATION_ERROR_2880054a = 0x2880054a, - VALIDATION_ERROR_28805601 = 0x28805601, - VALIDATION_ERROR_2880c601 = 0x2880c601, - VALIDATION_ERROR_2880c607 = 0x2880c607, - VALIDATION_ERROR_2880ec01 = 0x2880ec01, - VALIDATION_ERROR_28a01a01 = 0x28a01a01, - VALIDATION_ERROR_28a01a07 = 0x28a01a07, - VALIDATION_ERROR_28a05601 = 0x28a05601, - VALIDATION_ERROR_28a1b401 = 0x28a1b401, - VALIDATION_ERROR_28c00566 = 0x28c00566, - VALIDATION_ERROR_28c00568 = 0x28c00568, - VALIDATION_ERROR_28c0056a = 0x28c0056a, - VALIDATION_ERROR_28c0056c = 0x28c0056c, - VALIDATION_ERROR_28c05601 = 0x28c05601, - VALIDATION_ERROR_28c1d401 = 0x28c1d401, - VALIDATION_ERROR_28c1d403 = 0x28c1d403, - VALIDATION_ERROR_28e05601 = 0x28e05601, - VALIDATION_ERROR_28e13c01 = 0x28e13c01, - VALIDATION_ERROR_29000009 = 0x29000009, - VALIDATION_ERROR_29005601 = 0x29005601, - VALIDATION_ERROR_2901be01 = 0x2901be01, - VALIDATION_ERROR_2902ec01 = 0x2902ec01, - VALIDATION_ERROR_29200564 = 0x29200564, - VALIDATION_ERROR_29205601 = 0x29205601, - VALIDATION_ERROR_2920c601 = 0x2920c601, - VALIDATION_ERROR_2920c607 = 0x2920c607, - VALIDATION_ERROR_29211801 = 0x29211801, - VALIDATION_ERROR_29405601 = 0x29405601, - VALIDATION_ERROR_2941c001 = 0x2941c001, - VALIDATION_ERROR_29600300 = 0x29600300, - VALIDATION_ERROR_29600302 = 0x29600302, - VALIDATION_ERROR_29600e62 = 0x29600e62, - VALIDATION_ERROR_29605601 = 0x29605601, - VALIDATION_ERROR_2961fc01 = 0x2961fc01, - VALIDATION_ERROR_29806001 = 0x29806001, - VALIDATION_ERROR_2981f401 = 0x2981f401, - VALIDATION_ERROR_2981f601 = 0x2981f601, - VALIDATION_ERROR_29827a01 = 0x29827a01, - VALIDATION_ERROR_29a0ce01 = 0x29a0ce01, - VALIDATION_ERROR_29a10a01 = 0x29a10a01, - VALIDATION_ERROR_29a27a01 = 0x29a27a01, - VALIDATION_ERROR_29c009c2 = 0x29c009c2, - VALIDATION_ERROR_29c14a01 = 0x29c14a01, - VALIDATION_ERROR_29c15201 = 0x29c15201, - VALIDATION_ERROR_29c27a01 = 0x29c27a01, - VALIDATION_ERROR_29e05601 = 0x29e05601, - VALIDATION_ERROR_29e07e01 = 0x29e07e01, - VALIDATION_ERROR_29e07e07 = 0x29e07e07, - VALIDATION_ERROR_2a005601 = 0x2a005601, - VALIDATION_ERROR_2a008801 = 0x2a008801, - VALIDATION_ERROR_2a008807 = 0x2a008807, - VALIDATION_ERROR_2a200c68 = 0x2a200c68, - VALIDATION_ERROR_2a205601 = 0x2a205601, - VALIDATION_ERROR_2a20a001 = 0x2a20a001, - VALIDATION_ERROR_2a20a007 = 0x2a20a007, - VALIDATION_ERROR_2a21b401 = 0x2a21b401, - VALIDATION_ERROR_2a405601 = 0x2a405601, - VALIDATION_ERROR_2a40a001 = 0x2a40a001, - VALIDATION_ERROR_2a40a007 = 0x2a40a007, - VALIDATION_ERROR_2a423601 = 0x2a423601, - VALIDATION_ERROR_2a423801 = 0x2a423801, - VALIDATION_ERROR_2a6007c8 = 0x2a6007c8, - VALIDATION_ERROR_2a6007ca = 0x2a6007ca, - VALIDATION_ERROR_2a600c5a = 0x2a600c5a, - VALIDATION_ERROR_2a600c5c = 0x2a600c5c, - VALIDATION_ERROR_2a600d68 = 0x2a600d68, - VALIDATION_ERROR_2a600d6a = 0x2a600d6a, - VALIDATION_ERROR_2a600ece = 0x2a600ece, - VALIDATION_ERROR_2a605601 = 0x2a605601, - VALIDATION_ERROR_2a60a001 = 0x2a60a001, - VALIDATION_ERROR_2a60a007 = 0x2a60a007, - VALIDATION_ERROR_2a61a201 = 0x2a61a201, - VALIDATION_ERROR_2a624401 = 0x2a624401, - VALIDATION_ERROR_2a80bc01 = 0x2a80bc01, - VALIDATION_ERROR_2a81c001 = 0x2a81c001, - VALIDATION_ERROR_2aa05601 = 0x2aa05601, - VALIDATION_ERROR_2aa16c01 = 0x2aa16c01, - VALIDATION_ERROR_2aa39e01 = 0x2aa39e01, - VALIDATION_ERROR_2ac00542 = 0x2ac00542, - VALIDATION_ERROR_2ac00544 = 0x2ac00544, - VALIDATION_ERROR_2ac05601 = 0x2ac05601, - VALIDATION_ERROR_2ac09c01 = 0x2ac09c01, - VALIDATION_ERROR_2ac1ae01 = 0x2ac1ae01, - VALIDATION_ERROR_2ae05601 = 0x2ae05601, - VALIDATION_ERROR_2ae17c01 = 0x2ae17c01, - VALIDATION_ERROR_2ae3a001 = 0x2ae3a001, - VALIDATION_ERROR_2b000a5c = 0x2b000a5c, - VALIDATION_ERROR_2b005601 = 0x2b005601, - VALIDATION_ERROR_2b009c01 = 0x2b009c01, - VALIDATION_ERROR_2b009c03 = 0x2b009c03, - VALIDATION_ERROR_2b00c601 = 0x2b00c601, - VALIDATION_ERROR_2b00c607 = 0x2b00c607, - VALIDATION_ERROR_2b017c01 = 0x2b017c01, - VALIDATION_ERROR_2b200532 = 0x2b200532, - VALIDATION_ERROR_2b200534 = 0x2b200534, - VALIDATION_ERROR_2b205601 = 0x2b205601, - VALIDATION_ERROR_2b209c01 = 0x2b209c01, - VALIDATION_ERROR_2b21b601 = 0x2b21b601, - VALIDATION_ERROR_2b400009 = 0x2b400009, - VALIDATION_ERROR_2b405601 = 0x2b405601, - VALIDATION_ERROR_2b41ec01 = 0x2b41ec01, - VALIDATION_ERROR_2b41ee01 = 0x2b41ee01, - VALIDATION_ERROR_2b42f001 = 0x2b42f001, - VALIDATION_ERROR_2b61f401 = 0x2b61f401, - VALIDATION_ERROR_2b61f601 = 0x2b61f601, - VALIDATION_ERROR_2b627a01 = 0x2b627a01, - VALIDATION_ERROR_2b81f401 = 0x2b81f401, - VALIDATION_ERROR_2b81f601 = 0x2b81f601, - VALIDATION_ERROR_2b827a01 = 0x2b827a01, - VALIDATION_ERROR_2ba16201 = 0x2ba16201, - VALIDATION_ERROR_2ba16401 = 0x2ba16401, - VALIDATION_ERROR_2ba27a01 = 0x2ba27a01, - VALIDATION_ERROR_2bc08201 = 0x2bc08201, - VALIDATION_ERROR_2bc09001 = 0x2bc09001, - VALIDATION_ERROR_2bc09201 = 0x2bc09201, - VALIDATION_ERROR_2bc16601 = 0x2bc16601, - VALIDATION_ERROR_2bc27a01 = 0x2bc27a01, - VALIDATION_ERROR_2bc2fa01 = 0x2bc2fa01, - VALIDATION_ERROR_2bc30401 = 0x2bc30401, - VALIDATION_ERROR_2bc30601 = 0x2bc30601, - VALIDATION_ERROR_2bc30603 = 0x2bc30603, - VALIDATION_ERROR_2be16801 = 0x2be16801, - VALIDATION_ERROR_2be16a01 = 0x2be16a01, - VALIDATION_ERROR_2be27a01 = 0x2be27a01, - VALIDATION_ERROR_2c016e01 = 0x2c016e01, - VALIDATION_ERROR_2c027a01 = 0x2c027a01, - VALIDATION_ERROR_2c216e01 = 0x2c216e01, - VALIDATION_ERROR_2c227a01 = 0x2c227a01, - VALIDATION_ERROR_2c409201 = 0x2c409201, - VALIDATION_ERROR_2c417601 = 0x2c417601, - VALIDATION_ERROR_2c427a01 = 0x2c427a01, - VALIDATION_ERROR_2c609201 = 0x2c609201, - VALIDATION_ERROR_2c617601 = 0x2c617601, - VALIDATION_ERROR_2c627a01 = 0x2c627a01, - VALIDATION_ERROR_2c816e01 = 0x2c816e01, - VALIDATION_ERROR_2c81a401 = 0x2c81a401, - VALIDATION_ERROR_2c827a01 = 0x2c827a01, - VALIDATION_ERROR_2ca09001 = 0x2ca09001, - VALIDATION_ERROR_2ca09201 = 0x2ca09201, - VALIDATION_ERROR_2ca18401 = 0x2ca18401, - VALIDATION_ERROR_2ca27a01 = 0x2ca27a01, - VALIDATION_ERROR_2ca2fa01 = 0x2ca2fa01, - VALIDATION_ERROR_2ca30401 = 0x2ca30401, - VALIDATION_ERROR_2ca30601 = 0x2ca30601, - VALIDATION_ERROR_2ca30603 = 0x2ca30603, - VALIDATION_ERROR_2cc00e98 = 0x2cc00e98, - VALIDATION_ERROR_2cc18201 = 0x2cc18201, - VALIDATION_ERROR_2cc18401 = 0x2cc18401, - VALIDATION_ERROR_2cc27a01 = 0x2cc27a01, - VALIDATION_ERROR_2ce1b001 = 0x2ce1b001, - VALIDATION_ERROR_2ce27a01 = 0x2ce27a01, - VALIDATION_ERROR_2d01b001 = 0x2d01b001, - VALIDATION_ERROR_2d027a01 = 0x2d027a01, - VALIDATION_ERROR_2d2009e2 = 0x2d2009e2, - VALIDATION_ERROR_2d203001 = 0x2d203001, - VALIDATION_ERROR_2d227a01 = 0x2d227a01, - VALIDATION_ERROR_2d400009 = 0x2d400009, - VALIDATION_ERROR_2d420a01 = 0x2d420a01, - VALIDATION_ERROR_2d420e01 = 0x2d420e01, - VALIDATION_ERROR_2d427a01 = 0x2d427a01, - VALIDATION_ERROR_2d42ec01 = 0x2d42ec01, - VALIDATION_ERROR_2d61f401 = 0x2d61f401, - VALIDATION_ERROR_2d627a01 = 0x2d627a01, - VALIDATION_ERROR_2d81f401 = 0x2d81f401, - VALIDATION_ERROR_2d827a01 = 0x2d827a01, - VALIDATION_ERROR_2da20001 = 0x2da20001, - VALIDATION_ERROR_2da20201 = 0x2da20201, - VALIDATION_ERROR_2da27a01 = 0x2da27a01, - VALIDATION_ERROR_2dc20001 = 0x2dc20001, - VALIDATION_ERROR_2dc20201 = 0x2dc20201, - VALIDATION_ERROR_2dc27a01 = 0x2dc27a01, - VALIDATION_ERROR_2de0088c = 0x2de0088c, - VALIDATION_ERROR_2de09201 = 0x2de09201, - VALIDATION_ERROR_2de1f401 = 0x2de1f401, - VALIDATION_ERROR_2de1f601 = 0x2de1f601, - VALIDATION_ERROR_2de27a01 = 0x2de27a01, - VALIDATION_ERROR_2de2b401 = 0x2de2b401, - VALIDATION_ERROR_2de2fa01 = 0x2de2fa01, - VALIDATION_ERROR_2de30401 = 0x2de30401, - VALIDATION_ERROR_2de30601 = 0x2de30601, - VALIDATION_ERROR_2de30603 = 0x2de30603, - VALIDATION_ERROR_2e017401 = 0x2e017401, - VALIDATION_ERROR_2e01f401 = 0x2e01f401, - VALIDATION_ERROR_2e01f601 = 0x2e01f601, - VALIDATION_ERROR_2e027a01 = 0x2e027a01, - VALIDATION_ERROR_2e200009 = 0x2e200009, - VALIDATION_ERROR_2e224a01 = 0x2e224a01, - VALIDATION_ERROR_2e227a01 = 0x2e227a01, - VALIDATION_ERROR_2e22ec01 = 0x2e22ec01, - VALIDATION_ERROR_2e424a01 = 0x2e424a01, - VALIDATION_ERROR_2e425001 = 0x2e425001, - VALIDATION_ERROR_2e427a01 = 0x2e427a01, - VALIDATION_ERROR_2e600009 = 0x2e600009, - VALIDATION_ERROR_2e624a01 = 0x2e624a01, - VALIDATION_ERROR_2e627a01 = 0x2e627a01, - VALIDATION_ERROR_2e62ec01 = 0x2e62ec01, - VALIDATION_ERROR_2e824c01 = 0x2e824c01, - VALIDATION_ERROR_2e824e01 = 0x2e824e01, - VALIDATION_ERROR_2e825001 = 0x2e825001, - VALIDATION_ERROR_2e827a01 = 0x2e827a01, - VALIDATION_ERROR_2ea00009 = 0x2ea00009, - VALIDATION_ERROR_2ea24c01 = 0x2ea24c01, - VALIDATION_ERROR_2ea24e01 = 0x2ea24e01, - VALIDATION_ERROR_2ea27a01 = 0x2ea27a01, - VALIDATION_ERROR_2ea2ec01 = 0x2ea2ec01, - VALIDATION_ERROR_2ec00009 = 0x2ec00009, - VALIDATION_ERROR_2ec1e801 = 0x2ec1e801, - VALIDATION_ERROR_2ec1ea01 = 0x2ec1ea01, - VALIDATION_ERROR_2ec27a01 = 0x2ec27a01, - VALIDATION_ERROR_2ec2ec01 = 0x2ec2ec01, - VALIDATION_ERROR_2ee00009 = 0x2ee00009, - VALIDATION_ERROR_2ee009ea = 0x2ee009ea, - VALIDATION_ERROR_2ee24601 = 0x2ee24601, - VALIDATION_ERROR_2ee27a01 = 0x2ee27a01, - VALIDATION_ERROR_2ee2ec01 = 0x2ee2ec01, - VALIDATION_ERROR_2f000a34 = 0x2f000a34, - VALIDATION_ERROR_2f006001 = 0x2f006001, - VALIDATION_ERROR_2f027a01 = 0x2f027a01, - VALIDATION_ERROR_2f200a3a = 0x2f200a3a, - VALIDATION_ERROR_2f227a01 = 0x2f227a01, - VALIDATION_ERROR_2f400a40 = 0x2f400a40, - VALIDATION_ERROR_2f403001 = 0x2f403001, - VALIDATION_ERROR_2f427a01 = 0x2f427a01, - VALIDATION_ERROR_2f600a46 = 0x2f600a46, - VALIDATION_ERROR_2f606601 = 0x2f606601, - VALIDATION_ERROR_2f627a01 = 0x2f627a01, - VALIDATION_ERROR_2f805601 = 0x2f805601, - VALIDATION_ERROR_2f812201 = 0x2f812201, - VALIDATION_ERROR_2f812401 = 0x2f812401, - VALIDATION_ERROR_2f828001 = 0x2f828001, - VALIDATION_ERROR_2f828007 = 0x2f828007, - VALIDATION_ERROR_2fa0065a = 0x2fa0065a, - VALIDATION_ERROR_2fa0065c = 0x2fa0065c, - VALIDATION_ERROR_2fa0065e = 0x2fa0065e, - VALIDATION_ERROR_2fa00660 = 0x2fa00660, - VALIDATION_ERROR_2fa00662 = 0x2fa00662, - VALIDATION_ERROR_2fa00664 = 0x2fa00664, - VALIDATION_ERROR_2fa03c1b = 0x2fa03c1b, - VALIDATION_ERROR_2fa05601 = 0x2fa05601, - VALIDATION_ERROR_2fa09001 = 0x2fa09001, - VALIDATION_ERROR_2fa12201 = 0x2fa12201, - VALIDATION_ERROR_2fa29801 = 0x2fa29801, - VALIDATION_ERROR_2fa29807 = 0x2fa29807, - VALIDATION_ERROR_2fc06601 = 0x2fc06601, - VALIDATION_ERROR_2fc14801 = 0x2fc14801, - VALIDATION_ERROR_2fc27a01 = 0x2fc27a01, - VALIDATION_ERROR_2fe00009 = 0x2fe00009, - VALIDATION_ERROR_2fe05601 = 0x2fe05601, - VALIDATION_ERROR_2fe15001 = 0x2fe15001, - VALIDATION_ERROR_2fe2f001 = 0x2fe2f001, - VALIDATION_ERROR_30005601 = 0x30005601, - VALIDATION_ERROR_30017a01 = 0x30017a01, - VALIDATION_ERROR_3002ae01 = 0x3002ae01, - VALIDATION_ERROR_3002ae07 = 0x3002ae07, - VALIDATION_ERROR_30205601 = 0x30205601, - VALIDATION_ERROR_30216c01 = 0x30216c01, - VALIDATION_ERROR_30239e01 = 0x30239e01, - VALIDATION_ERROR_30405601 = 0x30405601, - VALIDATION_ERROR_30417c01 = 0x30417c01, - VALIDATION_ERROR_3043a001 = 0x3043a001, - VALIDATION_ERROR_30600009 = 0x30600009, - VALIDATION_ERROR_306009ba = 0x306009ba, - VALIDATION_ERROR_30603601 = 0x30603601, - VALIDATION_ERROR_30605601 = 0x30605601, - VALIDATION_ERROR_30611c01 = 0x30611c01, - VALIDATION_ERROR_3062f001 = 0x3062f001, - VALIDATION_ERROR_30800009 = 0x30800009, - VALIDATION_ERROR_30805601 = 0x30805601, - VALIDATION_ERROR_30825401 = 0x30825401, - VALIDATION_ERROR_30825601 = 0x30825601, - VALIDATION_ERROR_3082f001 = 0x3082f001, - VALIDATION_ERROR_30a00009 = 0x30a00009, - VALIDATION_ERROR_30a05601 = 0x30a05601, - VALIDATION_ERROR_30a2f001 = 0x30a2f001, - VALIDATION_ERROR_30c008ec = 0x30c008ec, - VALIDATION_ERROR_30c05601 = 0x30c05601, - VALIDATION_ERROR_30c18e01 = 0x30c18e01, - VALIDATION_ERROR_30e05601 = 0x30e05601, - VALIDATION_ERROR_30e19001 = 0x30e19001, - VALIDATION_ERROR_31005601 = 0x31005601, - VALIDATION_ERROR_3100c81b = 0x3100c81b, - VALIDATION_ERROR_3101b201 = 0x3101b201, - VALIDATION_ERROR_3120054c = 0x3120054c, - VALIDATION_ERROR_3120054e = 0x3120054e, - VALIDATION_ERROR_31200550 = 0x31200550, - VALIDATION_ERROR_31200552 = 0x31200552, - VALIDATION_ERROR_31200554 = 0x31200554, - VALIDATION_ERROR_31200556 = 0x31200556, - VALIDATION_ERROR_31205601 = 0x31205601, - VALIDATION_ERROR_31209005 = 0x31209005, - VALIDATION_ERROR_3120c601 = 0x3120c601, - VALIDATION_ERROR_3120c607 = 0x3120c607, - VALIDATION_ERROR_31228c01 = 0x31228c01, - VALIDATION_ERROR_31400604 = 0x31400604, - VALIDATION_ERROR_31405601 = 0x31405601, - VALIDATION_ERROR_31406e01 = 0x31406e01, - VALIDATION_ERROR_31406e07 = 0x31406e07, - VALIDATION_ERROR_31423c01 = 0x31423c01, - VALIDATION_ERROR_31423c07 = 0x31423c07, - VALIDATION_ERROR_3142ca1b = 0x3142ca1b, - VALIDATION_ERROR_31600009 = 0x31600009, - VALIDATION_ERROR_31600011 = 0x31600011, - VALIDATION_ERROR_316008b2 = 0x316008b2, - VALIDATION_ERROR_316008b4 = 0x316008b4, - VALIDATION_ERROR_316008b6 = 0x316008b6, - VALIDATION_ERROR_316008b8 = 0x316008b8, - VALIDATION_ERROR_316008ba = 0x316008ba, - VALIDATION_ERROR_31608801 = 0x31608801, - VALIDATION_ERROR_3160f801 = 0x3160f801, - VALIDATION_ERROR_31629c01 = 0x31629c01, - VALIDATION_ERROR_31800a18 = 0x31800a18, - VALIDATION_ERROR_31800a1a = 0x31800a1a, - VALIDATION_ERROR_31800a1c = 0x31800a1c, - VALIDATION_ERROR_31800a1e = 0x31800a1e, - VALIDATION_ERROR_3181e601 = 0x3181e601, - VALIDATION_ERROR_31829c01 = 0x31829c01, - VALIDATION_ERROR_31a00009 = 0x31a00009, - VALIDATION_ERROR_31a0007e = 0x31a0007e, - VALIDATION_ERROR_31a00080 = 0x31a00080, - VALIDATION_ERROR_31a00082 = 0x31a00082, - VALIDATION_ERROR_31a00084 = 0x31a00084, - VALIDATION_ERROR_31a00086 = 0x31a00086, - VALIDATION_ERROR_31a00088 = 0x31a00088, - VALIDATION_ERROR_31a0008a = 0x31a0008a, - VALIDATION_ERROR_31a0008c = 0x31a0008c, - VALIDATION_ERROR_31a0008e = 0x31a0008e, - VALIDATION_ERROR_31a00090 = 0x31a00090, - VALIDATION_ERROR_31a00092 = 0x31a00092, - VALIDATION_ERROR_31a00094 = 0x31a00094, - VALIDATION_ERROR_31a08801 = 0x31a08801, - VALIDATION_ERROR_31a24001 = 0x31a24001, - VALIDATION_ERROR_31a29c01 = 0x31a29c01, - VALIDATION_ERROR_31c29c01 = 0x31c29c01, - VALIDATION_ERROR_31e05601 = 0x31e05601, - VALIDATION_ERROR_31e0ec01 = 0x31e0ec01, - VALIDATION_ERROR_31e13a01 = 0x31e13a01, - VALIDATION_ERROR_31e17001 = 0x31e17001, - VALIDATION_ERROR_32005601 = 0x32005601, - VALIDATION_ERROR_32006001 = 0x32006001, - VALIDATION_ERROR_3200ec01 = 0x3200ec01, - VALIDATION_ERROR_32014c01 = 0x32014c01, - VALIDATION_ERROR_32017001 = 0x32017001, - VALIDATION_ERROR_32200aa8 = 0x32200aa8, - VALIDATION_ERROR_32200aaa = 0x32200aaa, - VALIDATION_ERROR_32200aac = 0x32200aac, - VALIDATION_ERROR_32205601 = 0x32205601, - VALIDATION_ERROR_3220d61b = 0x3220d61b, - VALIDATION_ERROR_3220d801 = 0x3220d801, - VALIDATION_ERROR_3220d807 = 0x3220d807, - VALIDATION_ERROR_3221cc01 = 0x3221cc01, - VALIDATION_ERROR_32229201 = 0x32229201, - VALIDATION_ERROR_32406001 = 0x32406001, - VALIDATION_ERROR_32427a01 = 0x32427a01, - VALIDATION_ERROR_3260005a = 0x3260005a, - VALIDATION_ERROR_3260005c = 0x3260005c, - VALIDATION_ERROR_32602401 = 0x32602401, - VALIDATION_ERROR_32609001 = 0x32609001, - VALIDATION_ERROR_32800050 = 0x32800050, - VALIDATION_ERROR_32802801 = 0x32802801, - VALIDATION_ERROR_32802807 = 0x32802807, - VALIDATION_ERROR_32805601 = 0x32805601, - VALIDATION_ERROR_32809001 = 0x32809001, - VALIDATION_ERROR_32a00272 = 0x32a00272, - VALIDATION_ERROR_32a04601 = 0x32a04601, - VALIDATION_ERROR_32a04607 = 0x32a04607, - VALIDATION_ERROR_32a05601 = 0x32a05601, - VALIDATION_ERROR_32a09005 = 0x32a09005, - VALIDATION_ERROR_32c008f8 = 0x32c008f8, - VALIDATION_ERROR_32c05601 = 0x32c05601, - VALIDATION_ERROR_32c07e01 = 0x32c07e01, - VALIDATION_ERROR_32c07e07 = 0x32c07e07, - VALIDATION_ERROR_32e008c6 = 0x32e008c6, - VALIDATION_ERROR_32e05601 = 0x32e05601, - VALIDATION_ERROR_32e08a1b = 0x32e08a1b, - VALIDATION_ERROR_32e17201 = 0x32e17201, - VALIDATION_ERROR_32e17207 = 0x32e17207, - VALIDATION_ERROR_33005601 = 0x33005601, - VALIDATION_ERROR_33007e01 = 0x33007e01, - VALIDATION_ERROR_33007e07 = 0x33007e07, - VALIDATION_ERROR_33200009 = 0x33200009, - VALIDATION_ERROR_33205601 = 0x33205601, - VALIDATION_ERROR_3321ba01 = 0x3321ba01, - VALIDATION_ERROR_33225801 = 0x33225801, - VALIDATION_ERROR_3322f21b = 0x3322f21b, - VALIDATION_ERROR_33402801 = 0x33402801, - VALIDATION_ERROR_33402807 = 0x33402807, - VALIDATION_ERROR_33405601 = 0x33405601, - VALIDATION_ERROR_33409005 = 0x33409005, - VALIDATION_ERROR_33600562 = 0x33600562, - VALIDATION_ERROR_33605601 = 0x33605601, - VALIDATION_ERROR_3360c601 = 0x3360c601, - VALIDATION_ERROR_3360c607 = 0x3360c607, - VALIDATION_ERROR_33800aba = 0x33800aba, - VALIDATION_ERROR_33800abc = 0x33800abc, - VALIDATION_ERROR_33800abe = 0x33800abe, - VALIDATION_ERROR_33805601 = 0x33805601, - VALIDATION_ERROR_3380d61b = 0x3380d61b, - VALIDATION_ERROR_3380d801 = 0x3380d801, - VALIDATION_ERROR_3380d807 = 0x3380d807, - VALIDATION_ERROR_3381c801 = 0x3381c801, - VALIDATION_ERROR_3381cc01 = 0x3381cc01, - VALIDATION_ERROR_33a00d2a = 0x33a00d2a, - VALIDATION_ERROR_33a04801 = 0x33a04801, - VALIDATION_ERROR_33a05201 = 0x33a05201, - VALIDATION_ERROR_33a05207 = 0x33a05207, - VALIDATION_ERROR_33a05601 = 0x33a05601, - VALIDATION_ERROR_33c00274 = 0x33c00274, - VALIDATION_ERROR_33c017ce = 0x33c017ce, - VALIDATION_ERROR_33c05601 = 0x33c05601, - VALIDATION_ERROR_33c12c01 = 0x33c12c01, - VALIDATION_ERROR_33c13601 = 0x33c13601, - VALIDATION_ERROR_33e05601 = 0x33e05601, - VALIDATION_ERROR_33e08a1b = 0x33e08a1b, - VALIDATION_ERROR_33e17201 = 0x33e17201, - VALIDATION_ERROR_33e17207 = 0x33e17207, - VALIDATION_ERROR_3401c40d = 0x3401c40d, - VALIDATION_ERROR_3402b00b = 0x3402b00b, - VALIDATION_ERROR_3402b00f = 0x3402b00f, - VALIDATION_ERROR_3421c40d = 0x3421c40d, - VALIDATION_ERROR_3422b00b = 0x3422b00b, - VALIDATION_ERROR_3441c40d = 0x3441c40d, - VALIDATION_ERROR_3442b00b = 0x3442b00b, - VALIDATION_ERROR_3442b00f = 0x3442b00f, - VALIDATION_ERROR_3461c40d = 0x3461c40d, - VALIDATION_ERROR_3462b00b = 0x3462b00b, - VALIDATION_ERROR_3481c40d = 0x3481c40d, - VALIDATION_ERROR_3482b00b = 0x3482b00b, - VALIDATION_ERROR_34a1c40d = 0x34a1c40d, - VALIDATION_ERROR_34a2b00b = 0x34a2b00b, - VALIDATION_ERROR_34c1c40d = 0x34c1c40d, - VALIDATION_ERROR_34c2b00b = 0x34c2b00b, - VALIDATION_ERROR_3521c40d = 0x3521c40d, - VALIDATION_ERROR_3522b00b = 0x3522b00b, - VALIDATION_ERROR_3541c40d = 0x3541c40d, - VALIDATION_ERROR_3542b00b = 0x3542b00b, - VALIDATION_ERROR_3561c40d = 0x3561c40d, - VALIDATION_ERROR_3562b00b = 0x3562b00b, - VALIDATION_ERROR_3581c40d = 0x3581c40d, - VALIDATION_ERROR_3582b00b = 0x3582b00b, - VALIDATION_ERROR_35c2b00b = 0x35c2b00b, - VALIDATION_ERROR_3602b00b = 0x3602b00b, - VALIDATION_ERROR_3622b00b = 0x3622b00b, - VALIDATION_ERROR_3642b00b = 0x3642b00b, - VALIDATION_ERROR_37e2b00b = 0x37e2b00b, - VALIDATION_ERROR_3822b00b = 0x3822b00b, - VALIDATION_ERROR_3842b00b = 0x3842b00b, - VALIDATION_ERROR_3862b00b = 0x3862b00b, - VALIDATION_ERROR_38800b20 = 0x38800b20, - VALIDATION_ERROR_38800b22 = 0x38800b22, - VALIDATION_ERROR_38800b24 = 0x38800b24, - VALIDATION_ERROR_3882b00b = 0x3882b00b, - VALIDATION_ERROR_38834a01 = 0x38834a01, - VALIDATION_ERROR_38a00afa = 0x38a00afa, - VALIDATION_ERROR_38a09005 = 0x38a09005, - VALIDATION_ERROR_38a2b00b = 0x38a2b00b, - VALIDATION_ERROR_38a34c01 = 0x38a34c01, - VALIDATION_ERROR_38a34e1b = 0x38a34e1b, - VALIDATION_ERROR_38c00af8 = 0x38c00af8, - VALIDATION_ERROR_38c09005 = 0x38c09005, - VALIDATION_ERROR_38c2b00b = 0x38c2b00b, - VALIDATION_ERROR_38e2b00b = 0x38e2b00b, - VALIDATION_ERROR_38e35001 = 0x38e35001, - VALIDATION_ERROR_39400b4c = 0x39400b4c, - VALIDATION_ERROR_39409e01 = 0x39409e01, - VALIDATION_ERROR_3942b00b = 0x3942b00b, - VALIDATION_ERROR_39609c01 = 0x39609c01, - VALIDATION_ERROR_3961c40d = 0x3961c40d, - VALIDATION_ERROR_3962b00b = 0x3962b00b, - VALIDATION_ERROR_3981c40d = 0x3981c40d, - VALIDATION_ERROR_3982b00b = 0x3982b00b, - VALIDATION_ERROR_39a27a01 = 0x39a27a01, - VALIDATION_ERROR_39a3a201 = 0x39a3a201, - VALIDATION_ERROR_39a3a401 = 0x39a3a401, - VALIDATION_ERROR_39c00b70 = 0x39c00b70, - VALIDATION_ERROR_39c00c0a = 0x39c00c0a, - VALIDATION_ERROR_39c08801 = 0x39c08801, - VALIDATION_ERROR_39c09001 = 0x39c09001, - VALIDATION_ERROR_39c09c01 = 0x39c09c01, - VALIDATION_ERROR_39c1c40d = 0x39c1c40d, - VALIDATION_ERROR_39c2b00b = 0x39c2b00b, - VALIDATION_ERROR_39e00b5a = 0x39e00b5a, - VALIDATION_ERROR_39e00b5c = 0x39e00b5c, - VALIDATION_ERROR_39e00b5e = 0x39e00b5e, - VALIDATION_ERROR_39e00b60 = 0x39e00b60, - VALIDATION_ERROR_39e08801 = 0x39e08801, - VALIDATION_ERROR_39e09c01 = 0x39e09c01, - VALIDATION_ERROR_39e1c40d = 0x39e1c40d, - VALIDATION_ERROR_39e2b00b = 0x39e2b00b, - VALIDATION_ERROR_3a000b6e = 0x3a000b6e, - VALIDATION_ERROR_3a005601 = 0x3a005601, - VALIDATION_ERROR_3a03a801 = 0x3a03a801, - VALIDATION_ERROR_3a205601 = 0x3a205601, - VALIDATION_ERROR_3a216c01 = 0x3a216c01, - VALIDATION_ERROR_3a239e01 = 0x3a239e01, - VALIDATION_ERROR_3a400b62 = 0x3a400b62, - VALIDATION_ERROR_3a400b66 = 0x3a400b66, - VALIDATION_ERROR_3a400b68 = 0x3a400b68, - VALIDATION_ERROR_3a400b6a = 0x3a400b6a, - VALIDATION_ERROR_3a400b6c = 0x3a400b6c, - VALIDATION_ERROR_3a400c06 = 0x3a400c06, - VALIDATION_ERROR_3a400c08 = 0x3a400c08, - VALIDATION_ERROR_3a408801 = 0x3a408801, - VALIDATION_ERROR_3a409001 = 0x3a409001, - VALIDATION_ERROR_3a409c01 = 0x3a409c01, - VALIDATION_ERROR_3a41c40d = 0x3a41c40d, - VALIDATION_ERROR_3a42b00b = 0x3a42b00b, - VALIDATION_ERROR_3a600b4e = 0x3a600b4e, - VALIDATION_ERROR_3a60f401 = 0x3a60f401, - VALIDATION_ERROR_3a62b00b = 0x3a62b00b, - VALIDATION_ERROR_3a800b50 = 0x3a800b50, - VALIDATION_ERROR_3a800b52 = 0x3a800b52, - VALIDATION_ERROR_3a800b54 = 0x3a800b54, - VALIDATION_ERROR_3a800b56 = 0x3a800b56, - VALIDATION_ERROR_3a800b58 = 0x3a800b58, - VALIDATION_ERROR_3a808801 = 0x3a808801, - VALIDATION_ERROR_3a809c01 = 0x3a809c01, - VALIDATION_ERROR_3a81c40d = 0x3a81c40d, - VALIDATION_ERROR_3a82b00b = 0x3a82b00b, - VALIDATION_ERROR_3aa05601 = 0x3aa05601, - VALIDATION_ERROR_3aa3aa01 = 0x3aa3aa01, - VALIDATION_ERROR_3ac05601 = 0x3ac05601, - VALIDATION_ERROR_3ac17c01 = 0x3ac17c01, - VALIDATION_ERROR_3ac3a001 = 0x3ac3a001, - VALIDATION_ERROR_3ae008d8 = 0x3ae008d8, - VALIDATION_ERROR_3ae008da = 0x3ae008da, - VALIDATION_ERROR_3ae008dc = 0x3ae008dc, - VALIDATION_ERROR_3ae008de = 0x3ae008de, - VALIDATION_ERROR_3ae008e0 = 0x3ae008e0, - VALIDATION_ERROR_3ae09c01 = 0x3ae09c01, - VALIDATION_ERROR_3ae1c40d = 0x3ae1c40d, - VALIDATION_ERROR_3ae2b00b = 0x3ae2b00b, - VALIDATION_ERROR_3ae2b801 = 0x3ae2b801, - VALIDATION_ERROR_3b0008cc = 0x3b0008cc, - VALIDATION_ERROR_3b0008ce = 0x3b0008ce, - VALIDATION_ERROR_3b0008d0 = 0x3b0008d0, - VALIDATION_ERROR_3b0008d2 = 0x3b0008d2, - VALIDATION_ERROR_3b0008d4 = 0x3b0008d4, - VALIDATION_ERROR_3b0008d6 = 0x3b0008d6, - VALIDATION_ERROR_3b009c01 = 0x3b009c01, - VALIDATION_ERROR_3b01c40d = 0x3b01c40d, - VALIDATION_ERROR_3b02b00b = 0x3b02b00b, - VALIDATION_ERROR_3b02b801 = 0x3b02b801, - VALIDATION_ERROR_3b20053e = 0x3b20053e, - VALIDATION_ERROR_3b200540 = 0x3b200540, - VALIDATION_ERROR_3b209c01 = 0x3b209c01, - VALIDATION_ERROR_3b20c601 = 0x3b20c601, - VALIDATION_ERROR_3b21c40d = 0x3b21c40d, - VALIDATION_ERROR_3b22b00b = 0x3b22b00b, - VALIDATION_ERROR_3b40052c = 0x3b40052c, - VALIDATION_ERROR_3b40052e = 0x3b40052e, - VALIDATION_ERROR_3b400530 = 0x3b400530, - VALIDATION_ERROR_3b409c01 = 0x3b409c01, - VALIDATION_ERROR_3b40c601 = 0x3b40c601, - VALIDATION_ERROR_3b41c40d = 0x3b41c40d, - VALIDATION_ERROR_3b42b00b = 0x3b42b00b, - VALIDATION_ERROR_3b62b00b = 0x3b62b00b, - VALIDATION_ERROR_3b800009 = 0x3b800009, - VALIDATION_ERROR_3b800b30 = 0x3b800b30, - VALIDATION_ERROR_3b800b32 = 0x3b800b32, - VALIDATION_ERROR_3b800b34 = 0x3b800b34, - VALIDATION_ERROR_3b800b36 = 0x3b800b36, - VALIDATION_ERROR_3b800b38 = 0x3b800b38, - VALIDATION_ERROR_3b800e0a = 0x3b800e0a, - VALIDATION_ERROR_3b800ea8 = 0x3b800ea8, - VALIDATION_ERROR_3b800eaa = 0x3b800eaa, - VALIDATION_ERROR_3b800eac = 0x3b800eac, - VALIDATION_ERROR_3b800eae = 0x3b800eae, - VALIDATION_ERROR_3b801a01 = 0x3b801a01, - VALIDATION_ERROR_3b80a001 = 0x3b80a001, - VALIDATION_ERROR_3b82b00b = 0x3b82b00b, - VALIDATION_ERROR_3ba01a01 = 0x3ba01a01, - VALIDATION_ERROR_3ba1c40d = 0x3ba1c40d, - VALIDATION_ERROR_3ba2b00b = 0x3ba2b00b, - VALIDATION_ERROR_3bc00c6a = 0x3bc00c6a, - VALIDATION_ERROR_3bc00c6c = 0x3bc00c6c, - VALIDATION_ERROR_3bc00c6e = 0x3bc00c6e, - VALIDATION_ERROR_3bc00ed2 = 0x3bc00ed2, - VALIDATION_ERROR_3bc0a001 = 0x3bc0a001, - VALIDATION_ERROR_3bc1c40d = 0x3bc1c40d, - VALIDATION_ERROR_3bc2b00b = 0x3bc2b00b, - VALIDATION_ERROR_3be0a001 = 0x3be0a001, - VALIDATION_ERROR_3be1c40d = 0x3be1c40d, - VALIDATION_ERROR_3be2b00b = 0x3be2b00b, - VALIDATION_ERROR_3c01c40d = 0x3c01c40d, - VALIDATION_ERROR_3c02b00b = 0x3c02b00b, - VALIDATION_ERROR_3c21c40d = 0x3c21c40d, - VALIDATION_ERROR_3c22b00b = 0x3c22b00b, - VALIDATION_ERROR_3c405601 = 0x3c405601, - VALIDATION_ERROR_3c41b401 = 0x3c41b401, - VALIDATION_ERROR_3c439c01 = 0x3c439c01, - VALIDATION_ERROR_3c605601 = 0x3c605601, - VALIDATION_ERROR_3c61b401 = 0x3c61b401, - VALIDATION_ERROR_3c639c01 = 0x3c639c01, - VALIDATION_ERROR_3c805601 = 0x3c805601, - VALIDATION_ERROR_3c823601 = 0x3c823601, - VALIDATION_ERROR_3c823801 = 0x3c823801, - VALIDATION_ERROR_3c839c01 = 0x3c839c01, - VALIDATION_ERROR_3ca2b00b = 0x3ca2b00b, - VALIDATION_ERROR_3cc00b2e = 0x3cc00b2e, - VALIDATION_ERROR_3cc2b00b = 0x3cc2b00b, - VALIDATION_ERROR_3ce00bec = 0x3ce00bec, - VALIDATION_ERROR_3ce00bee = 0x3ce00bee, - VALIDATION_ERROR_3ce2b00b = 0x3ce2b00b, - VALIDATION_ERROR_3ce3b201 = 0x3ce3b201, - VALIDATION_ERROR_3ce3b41b = 0x3ce3b41b, - VALIDATION_ERROR_3ce3b601 = 0x3ce3b601, - VALIDATION_ERROR_3d02b00b = 0x3d02b00b, - VALIDATION_ERROR_3d03ba01 = 0x3d03ba01, - VALIDATION_ERROR_3d03e801 = 0x3d03e801, - VALIDATION_ERROR_3d22b00b = 0x3d22b00b, - VALIDATION_ERROR_3d23c601 = 0x3d23c601, - VALIDATION_ERROR_3d42b00b = 0x3d42b00b, - VALIDATION_ERROR_3d61c40d = 0x3d61c40d, - VALIDATION_ERROR_3d62b00b = 0x3d62b00b, - VALIDATION_ERROR_3d827a01 = 0x3d827a01, - VALIDATION_ERROR_3d82b401 = 0x3d82b401, - VALIDATION_ERROR_3d83ca01 = 0x3d83ca01, - VALIDATION_ERROR_3da00bfc = 0x3da00bfc, - VALIDATION_ERROR_3da00bfe = 0x3da00bfe, - VALIDATION_ERROR_3da09005 = 0x3da09005, - VALIDATION_ERROR_3da19601 = 0x3da19601, - VALIDATION_ERROR_3da1c40d = 0x3da1c40d, - VALIDATION_ERROR_3da2b00b = 0x3da2b00b, - VALIDATION_ERROR_3dc2b00b = 0x3dc2b00b, - VALIDATION_ERROR_3dc3c401 = 0x3dc3c401, - VALIDATION_ERROR_3de05601 = 0x3de05601, - VALIDATION_ERROR_3de0ec01 = 0x3de0ec01, - VALIDATION_ERROR_3de11e01 = 0x3de11e01, - VALIDATION_ERROR_3de3c201 = 0x3de3c201, - VALIDATION_ERROR_3e005601 = 0x3e005601, - VALIDATION_ERROR_3e012201 = 0x3e012201, - VALIDATION_ERROR_3e012401 = 0x3e012401, - VALIDATION_ERROR_3e03c401 = 0x3e03c401, - VALIDATION_ERROR_3e03c407 = 0x3e03c407, - VALIDATION_ERROR_3e200bf0 = 0x3e200bf0, - VALIDATION_ERROR_3e200bf2 = 0x3e200bf2, - VALIDATION_ERROR_3e200bf4 = 0x3e200bf4, - VALIDATION_ERROR_3e202401 = 0x3e202401, - VALIDATION_ERROR_3e202413 = 0x3e202413, - VALIDATION_ERROR_3e202415 = 0x3e202415, - VALIDATION_ERROR_3e23c801 = 0x3e23c801, - VALIDATION_ERROR_3e400c02 = 0x3e400c02, - VALIDATION_ERROR_3e400c04 = 0x3e400c04, - VALIDATION_ERROR_3e405601 = 0x3e405601, - VALIDATION_ERROR_3e40ec01 = 0x3e40ec01, - VALIDATION_ERROR_3e43c401 = 0x3e43c401, - VALIDATION_ERROR_3e43c407 = 0x3e43c407, - VALIDATION_ERROR_3e600c00 = 0x3e600c00, - VALIDATION_ERROR_3e605601 = 0x3e605601, - VALIDATION_ERROR_3e606e01 = 0x3e606e01, - VALIDATION_ERROR_3e606e07 = 0x3e606e07, - VALIDATION_ERROR_3e623c01 = 0x3e623c01, - VALIDATION_ERROR_3e623c07 = 0x3e623c07, - VALIDATION_ERROR_3e62ca1b = 0x3e62ca1b, - VALIDATION_ERROR_3e800bf6 = 0x3e800bf6, - VALIDATION_ERROR_3e83c601 = 0x3e83c601, - VALIDATION_ERROR_3ea00bf8 = 0x3ea00bf8, - VALIDATION_ERROR_3ea3c601 = 0x3ea3c601, - VALIDATION_ERROR_3ec2b00b = 0x3ec2b00b, - VALIDATION_ERROR_3ee00c01 = 0x3ee00c01, - VALIDATION_ERROR_3ee00c03 = 0x3ee00c03, - VALIDATION_ERROR_3ee00c40 = 0x3ee00c40, - VALIDATION_ERROR_3ee00c42 = 0x3ee00c42, - VALIDATION_ERROR_3ee00c44 = 0x3ee00c44, - VALIDATION_ERROR_3f02b00b = 0x3f02b00b, - VALIDATION_ERROR_3f03ce1b = 0x3f03ce1b, - VALIDATION_ERROR_3f03d001 = 0x3f03d001, - VALIDATION_ERROR_3f200c66 = 0x3f200c66, - VALIDATION_ERROR_3f22b00b = 0x3f22b00b, - VALIDATION_ERROR_3f230601 = 0x3f230601, - VALIDATION_ERROR_3f230603 = 0x3f230603, - VALIDATION_ERROR_3f42b00b = 0x3f42b00b, - VALIDATION_ERROR_3f43d201 = 0x3f43d201, - VALIDATION_ERROR_3f600c54 = 0x3f600c54, - VALIDATION_ERROR_3f600c56 = 0x3f600c56, - VALIDATION_ERROR_3f600c58 = 0x3f600c58, - VALIDATION_ERROR_3f62b00b = 0x3f62b00b, - VALIDATION_ERROR_3f63e401 = 0x3f63e401, - VALIDATION_ERROR_3f800ce2 = 0x3f800ce2, - VALIDATION_ERROR_3f800ce4 = 0x3f800ce4, - VALIDATION_ERROR_3f800ce6 = 0x3f800ce6, - VALIDATION_ERROR_3f800ce8 = 0x3f800ce8, - VALIDATION_ERROR_3f800cea = 0x3f800cea, - VALIDATION_ERROR_3f800cec = 0x3f800cec, - VALIDATION_ERROR_3f800cee = 0x3f800cee, - VALIDATION_ERROR_3f800cf0 = 0x3f800cf0, - VALIDATION_ERROR_3f800cf2 = 0x3f800cf2, - VALIDATION_ERROR_3f800ee0 = 0x3f800ee0, - VALIDATION_ERROR_3f802c01 = 0x3f802c01, - VALIDATION_ERROR_3f809201 = 0x3f809201, - VALIDATION_ERROR_3f81c40d = 0x3f81c40d, - VALIDATION_ERROR_3f82b00b = 0x3f82b00b, - VALIDATION_ERROR_3f83d401 = 0x3f83d401, - VALIDATION_ERROR_3f83d601 = 0x3f83d601, - VALIDATION_ERROR_3f83d801 = 0x3f83d801, - VALIDATION_ERROR_3f83da01 = 0x3f83da01, - VALIDATION_ERROR_3f83dc01 = 0x3f83dc01, - VALIDATION_ERROR_3fa00cd4 = 0x3fa00cd4, - VALIDATION_ERROR_3fa00cd6 = 0x3fa00cd6, - VALIDATION_ERROR_3fa2b00b = 0x3fa2b00b, - VALIDATION_ERROR_3fa3de01 = 0x3fa3de01, - VALIDATION_ERROR_3fc00c70 = 0x3fc00c70, - VALIDATION_ERROR_3fc2b00b = 0x3fc2b00b, - VALIDATION_ERROR_3fc3de01 = 0x3fc3de01, - VALIDATION_ERROR_3fe00ce0 = 0x3fe00ce0, - VALIDATION_ERROR_3fe05601 = 0x3fe05601, - VALIDATION_ERROR_3fe0ec01 = 0x3fe0ec01, - VALIDATION_ERROR_3fe11e01 = 0x3fe11e01, - VALIDATION_ERROR_3fe3e001 = 0x3fe3e001, - VALIDATION_ERROR_40000c8c = 0x40000c8c, - VALIDATION_ERROR_40000c8e = 0x40000c8e, - VALIDATION_ERROR_40013e01 = 0x40013e01, - VALIDATION_ERROR_4002b00b = 0x4002b00b, - VALIDATION_ERROR_40200cc2 = 0x40200cc2, - VALIDATION_ERROR_40200cc4 = 0x40200cc4, - VALIDATION_ERROR_40200cc6 = 0x40200cc6, - VALIDATION_ERROR_40200cc8 = 0x40200cc8, - VALIDATION_ERROR_40200cca = 0x40200cca, - VALIDATION_ERROR_40200ccc = 0x40200ccc, - VALIDATION_ERROR_40200cce = 0x40200cce, - VALIDATION_ERROR_40200cd0 = 0x40200cd0, - VALIDATION_ERROR_40200cd2 = 0x40200cd2, - VALIDATION_ERROR_40213e01 = 0x40213e01, - VALIDATION_ERROR_4022b00b = 0x4022b00b, - VALIDATION_ERROR_4023fe01 = 0x4023fe01, - VALIDATION_ERROR_40405601 = 0x40405601, - VALIDATION_ERROR_4040ec01 = 0x4040ec01, - VALIDATION_ERROR_4043e201 = 0x4043e201, - VALIDATION_ERROR_4043e207 = 0x4043e207, - VALIDATION_ERROR_4062b00b = 0x4062b00b, - VALIDATION_ERROR_4082b00b = 0x4082b00b, - VALIDATION_ERROR_40a2b00b = 0x40a2b00b, - VALIDATION_ERROR_40a3e601 = 0x40a3e601, - VALIDATION_ERROR_40c2b00b = 0x40c2b00b, - VALIDATION_ERROR_40c3ea01 = 0x40c3ea01, - VALIDATION_ERROR_40e05601 = 0x40e05601, - VALIDATION_ERROR_40e27c01 = 0x40e27c01, - VALIDATION_ERROR_40e27c07 = 0x40e27c07, - VALIDATION_ERROR_40e39c01 = 0x40e39c01, - VALIDATION_ERROR_40e3ec01 = 0x40e3ec01, - VALIDATION_ERROR_40e3ee01 = 0x40e3ee01, - VALIDATION_ERROR_40e3f001 = 0x40e3f001, - VALIDATION_ERROR_41200da6 = 0x41200da6, - VALIDATION_ERROR_41200da8 = 0x41200da8, - VALIDATION_ERROR_41200daa = 0x41200daa, - VALIDATION_ERROR_41200dac = 0x41200dac, - VALIDATION_ERROR_41200dae = 0x41200dae, - VALIDATION_ERROR_41209c01 = 0x41209c01, - VALIDATION_ERROR_4122b00b = 0x4122b00b, - VALIDATION_ERROR_4141c40d = 0x4141c40d, - VALIDATION_ERROR_4142b00b = 0x4142b00b, - VALIDATION_ERROR_4162b00b = 0x4162b00b, - VALIDATION_ERROR_41800db0 = 0x41800db0, - VALIDATION_ERROR_41800db2 = 0x41800db2, - VALIDATION_ERROR_41800db4 = 0x41800db4, - VALIDATION_ERROR_41800db6 = 0x41800db6, - VALIDATION_ERROR_41805601 = 0x41805601, - VALIDATION_ERROR_41809c01 = 0x41809c01, - VALIDATION_ERROR_4183f401 = 0x4183f401, - VALIDATION_ERROR_41a2b00b = 0x41a2b00b, - VALIDATION_ERROR_41c00dd2 = 0x41c00dd2, - VALIDATION_ERROR_41c09005 = 0x41c09005, - VALIDATION_ERROR_41c2b00b = 0x41c2b00b, - VALIDATION_ERROR_41c3f801 = 0x41c3f801, - VALIDATION_ERROR_41e00009 = 0x41e00009, - VALIDATION_ERROR_41e00e0c = 0x41e00e0c, - VALIDATION_ERROR_41e00e0e = 0x41e00e0e, - VALIDATION_ERROR_41e00e10 = 0x41e00e10, - VALIDATION_ERROR_41e00e12 = 0x41e00e12, - VALIDATION_ERROR_41e02401 = 0x41e02401, - VALIDATION_ERROR_41e02413 = 0x41e02413, - VALIDATION_ERROR_41e02415 = 0x41e02415, - VALIDATION_ERROR_41e06c01 = 0x41e06c01, - VALIDATION_ERROR_41e28401 = 0x41e28401, - VALIDATION_ERROR_4201c40d = 0x4201c40d, - VALIDATION_ERROR_4202b00b = 0x4202b00b, - VALIDATION_ERROR_42200e64 = 0x42200e64, - VALIDATION_ERROR_42200e66 = 0x42200e66, - VALIDATION_ERROR_42209001 = 0x42209001, - VALIDATION_ERROR_42209003 = 0x42209003, - VALIDATION_ERROR_4221c40d = 0x4221c40d, - VALIDATION_ERROR_4222b00b = 0x4222b00b, - VALIDATION_ERROR_4242b00b = 0x4242b00b, - VALIDATION_ERROR_4262b00b = 0x4262b00b, - VALIDATION_ERROR_4282b00b = 0x4282b00b, - VALIDATION_ERROR_42a2b00b = 0x42a2b00b, - VALIDATION_ERROR_42c2b00b = 0x42c2b00b, - VALIDATION_ERROR_42e00e30 = 0x42e00e30, - VALIDATION_ERROR_42e00e32 = 0x42e00e32, - VALIDATION_ERROR_42e00e34 = 0x42e00e34, - VALIDATION_ERROR_42e00e36 = 0x42e00e36, - VALIDATION_ERROR_42e2b00b = 0x42e2b00b, - VALIDATION_ERROR_43040001 = 0x43040001, - VALIDATION_ERROR_43205601 = 0x43205601, - VALIDATION_ERROR_43211e01 = 0x43211e01, - VALIDATION_ERROR_43240201 = 0x43240201, - VALIDATION_ERROR_43405601 = 0x43405601, - VALIDATION_ERROR_4341fc01 = 0x4341fc01, - VALIDATION_ERROR_43440401 = 0x43440401, - VALIDATION_ERROR_43600ee2 = 0x43600ee2, - VALIDATION_ERROR_43600ee4 = 0x43600ee4, - VALIDATION_ERROR_43600ee6 = 0x43600ee6, - VALIDATION_ERROR_4360da01 = 0x4360da01, - VALIDATION_ERROR_4361c40d = 0x4361c40d, - VALIDATION_ERROR_4361ce01 = 0x4361ce01, - VALIDATION_ERROR_4362b00b = 0x4362b00b, - VALIDATION_ERROR_43800ee8 = 0x43800ee8, - VALIDATION_ERROR_43800eea = 0x43800eea, - VALIDATION_ERROR_43800eec = 0x43800eec, - VALIDATION_ERROR_4380da01 = 0x4380da01, - VALIDATION_ERROR_4381c40d = 0x4381c40d, - VALIDATION_ERROR_43825a01 = 0x43825a01, - VALIDATION_ERROR_4382b00b = 0x4382b00b, - VALIDATION_ERROR_4382f41b = 0x4382f41b, - VALIDATION_ERROR_43a1c40d = 0x43a1c40d, - VALIDATION_ERROR_43a2b00b = 0x43a2b00b, - VALIDATION_ERROR_43a40801 = 0x43a40801, - VALIDATION_ERROR_43c09005 = 0x43c09005, - VALIDATION_ERROR_43c0d61b = 0x43c0d61b, - VALIDATION_ERROR_43c1b801 = 0x43c1b801, - VALIDATION_ERROR_43c1c40d = 0x43c1c40d, - VALIDATION_ERROR_43c2b00b = 0x43c2b00b, - VALIDATION_ERROR_43c42201 = 0x43c42201, - VALIDATION_ERROR_43e00ef4 = 0x43e00ef4, - VALIDATION_ERROR_43e09005 = 0x43e09005, - VALIDATION_ERROR_43e2b00b = 0x43e2b00b, - VALIDATION_ERROR_43e40a01 = 0x43e40a01, - VALIDATION_ERROR_43e40a03 = 0x43e40a03, - VALIDATION_ERROR_43e40c01 = 0x43e40c01, - VALIDATION_ERROR_43e40c03 = 0x43e40c03, - VALIDATION_ERROR_4400bc01 = 0x4400bc01, - VALIDATION_ERROR_4400ec01 = 0x4400ec01, - VALIDATION_ERROR_44011e01 = 0x44011e01, - VALIDATION_ERROR_44041001 = 0x44041001, - VALIDATION_ERROR_4420bc01 = 0x4420bc01, - VALIDATION_ERROR_44240a01 = 0x44240a01, - VALIDATION_ERROR_44241201 = 0x44241201, - VALIDATION_ERROR_44241203 = 0x44241203, - VALIDATION_ERROR_44242801 = 0x44242801, - VALIDATION_ERROR_4442b00b = 0x4442b00b, - VALIDATION_ERROR_4462b00b = 0x4462b00b, - VALIDATION_ERROR_4464141b = 0x4464141b, - VALIDATION_ERROR_44641601 = 0x44641601, - VALIDATION_ERROR_44800ecc = 0x44800ecc, - VALIDATION_ERROR_4482b00b = 0x4482b00b, - VALIDATION_ERROR_44a00eb0 = 0x44a00eb0, - VALIDATION_ERROR_44a00eb2 = 0x44a00eb2, - VALIDATION_ERROR_44a01a01 = 0x44a01a01, - VALIDATION_ERROR_44a2b00b = 0x44a2b00b, - VALIDATION_ERROR_44c00eb4 = 0x44c00eb4, - VALIDATION_ERROR_44c00eb6 = 0x44c00eb6, - VALIDATION_ERROR_44e00ef0 = 0x44e00ef0, - VALIDATION_ERROR_44e00ef2 = 0x44e00ef2, - VALIDATION_ERROR_44e02401 = 0x44e02401, - VALIDATION_ERROR_44e02413 = 0x44e02413, - VALIDATION_ERROR_44e02415 = 0x44e02415, - VALIDATION_ERROR_45000ef6 = 0x45000ef6, - VALIDATION_ERROR_45000ef8 = 0x45000ef8, - VALIDATION_ERROR_4500bc01 = 0x4500bc01, - VALIDATION_ERROR_4500ec01 = 0x4500ec01, - VALIDATION_ERROR_45042601 = 0x45042601, - VALIDATION_ERROR_45042607 = 0x45042607, - VALIDATION_ERROR_45200eb8 = 0x45200eb8, - VALIDATION_ERROR_45201a01 = 0x45201a01, - VALIDATION_ERROR_45205601 = 0x45205601, - VALIDATION_ERROR_4521f401 = 0x4521f401, - VALIDATION_ERROR_45400eee = 0x45400eee, - VALIDATION_ERROR_45429c01 = 0x45429c01, - VALIDATION_ERROR_4562b00b = 0x4562b00b, - VALIDATION_ERROR_45a05601 = 0x45a05601, - VALIDATION_ERROR_45a10001 = 0x45a10001, - VALIDATION_ERROR_45a39c01 = 0x45a39c01, - VALIDATION_ERROR_45c2b00b = 0x45c2b00b, - VALIDATION_ERROR_45e02401 = 0x45e02401, - VALIDATION_ERROR_45e02413 = 0x45e02413, - VALIDATION_ERROR_45e02415 = 0x45e02415, - VALIDATION_ERROR_45e42401 = 0x45e42401, - VALIDATION_ERROR_46002401 = 0x46002401, - VALIDATION_ERROR_46002413 = 0x46002413, - VALIDATION_ERROR_46002415 = 0x46002415, - VALIDATION_ERROR_46042401 = 0x46042401, - VALIDATION_ERROR_46229c01 = 0x46229c01, - VALIDATION_ERROR_46242401 = 0x46242401, - VALIDATION_ERROR_46429c01 = 0x46429c01, - VALIDATION_ERROR_46442401 = 0x46442401, - VALIDATION_ERROR_46605601 = 0x46605601, - VALIDATION_ERROR_4661c201 = 0x4661c201, - VALIDATION_ERROR_46805601 = 0x46805601, - VALIDATION_ERROR_46825c01 = 0x46825c01, - VALIDATION_ERROR_46a01774 = 0x46a01774, - VALIDATION_ERROR_46a01776 = 0x46a01776, - VALIDATION_ERROR_46a01778 = 0x46a01778, - VALIDATION_ERROR_46a0177a = 0x46a0177a, - VALIDATION_ERROR_46a0177c = 0x46a0177c, - VALIDATION_ERROR_46a0177e = 0x46a0177e, - VALIDATION_ERROR_46a01780 = 0x46a01780, - VALIDATION_ERROR_46a01782 = 0x46a01782, - VALIDATION_ERROR_46a01784 = 0x46a01784, - VALIDATION_ERROR_46a01786 = 0x46a01786, - VALIDATION_ERROR_46a01788 = 0x46a01788, - VALIDATION_ERROR_46a0178a = 0x46a0178a, - VALIDATION_ERROR_46a0178c = 0x46a0178c, - VALIDATION_ERROR_46a0178e = 0x46a0178e, - VALIDATION_ERROR_46a2b00b = 0x46a2b00b, - VALIDATION_ERROR_46a42a01 = 0x46a42a01, - VALIDATION_ERROR_46a42a03 = 0x46a42a03, - VALIDATION_ERROR_46c017ca = 0x46c017ca, - VALIDATION_ERROR_46c017cc = 0x46c017cc, - VALIDATION_ERROR_46c2b00b = 0x46c2b00b, - VALIDATION_ERROR_46c42c01 = 0x46c42c01, - VALIDATION_ERROR_46e2b00b = 0x46e2b00b, - VALIDATION_ERROR_4702b00b = 0x4702b00b, - VALIDATION_ERROR_4722b00b = 0x4722b00b, - VALIDATION_ERROR_4742b00b = 0x4742b00b, - VALIDATION_ERROR_47600e9a = 0x47600e9a, - VALIDATION_ERROR_47600e9c = 0x47600e9c, - VALIDATION_ERROR_47600e9e = 0x47600e9e, - VALIDATION_ERROR_MAX_ENUM = 1, -}; - -// Mapping from unique validation error enum to the corresponding spec text -static std::unordered_map validation_error_map{ - {VALIDATION_ERROR_00000009, "The spec valid usage text states 'Each of fence, semaphore, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-commonparent)"}, - {VALIDATION_ERROR_00000a10, "The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01288)"}, - {VALIDATION_ERROR_00000a12, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-fence-01289)"}, - {VALIDATION_ERROR_00000a14, "The spec valid usage text states 'deviceMask must be a valid device mask' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-deviceMask-01290)"}, - {VALIDATION_ERROR_00000a16, "The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-deviceMask-01291)"}, - {VALIDATION_ERROR_00000d16, "The spec valid usage text states 'swapchain must not be in the retired state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-swapchain-01675)"}, - {VALIDATION_ERROR_00000dea, "The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01781)"}, - {VALIDATION_ERROR_00000dec, "The spec valid usage text states 'semaphore and fence must not both be equal to VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01782)"}, - {VALIDATION_ERROR_00000e18, "The spec valid usage text states 'semaphore and fence must not both be equal to VK_NULL_HANDLE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-01804)"}, - {VALIDATION_ERROR_00008801, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-fence-parameter)"}, - {VALIDATION_ERROR_0001c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_0002b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0002b801, "The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-semaphore-parameter)"}, - {VALIDATION_ERROR_0002f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAcquireNextImageInfoKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_002004f0, "The spec valid usage text states 'pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnAllocation-00632)"}, - {VALIDATION_ERROR_002004f2, "The spec valid usage text states 'pfnReallocation must be a valid pointer to a valid user-defined PFN_vkReallocationFunction' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnReallocation-00633)"}, - {VALIDATION_ERROR_002004f4, "The spec valid usage text states 'pfnFree must be a valid pointer to a valid user-defined PFN_vkFreeFunction' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnFree-00634)"}, - {VALIDATION_ERROR_002004f6, "The spec valid usage text states 'If either of pfnInternalAllocation or pfnInternalFree is not NULL, both must be valid callbacks' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAllocationCallbacks-pfnInternalAllocation-00635)"}, - {VALIDATION_ERROR_004009c0, "The spec valid usage text states 'window must point to a valid Android ANativeWindow.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-window-01248)"}, - {VALIDATION_ERROR_00409005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_0041c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_0042b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0060f001, "The spec valid usage text states 'If pApplicationName is not NULL, pApplicationName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-pApplicationName-parameter)"}, - {VALIDATION_ERROR_00615c01, "The spec valid usage text states 'If pEngineName is not NULL, pEngineName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-pEngineName-parameter)"}, - {VALIDATION_ERROR_0061c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0062b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkApplicationInfo-sType-sType)"}, - {VALIDATION_ERROR_00800696, "The spec valid usage text states 'finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-finalLayout-00843)"}, - {VALIDATION_ERROR_00808e01, "The spec valid usage text states 'finalLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-finalLayout-parameter)"}, - {VALIDATION_ERROR_00809001, "The spec valid usage text states 'flags must be a valid combination of VkAttachmentDescriptionFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-flags-parameter)"}, - {VALIDATION_ERROR_00809201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-format-parameter)"}, - {VALIDATION_ERROR_0080b801, "The spec valid usage text states 'initialLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-initialLayout-parameter)"}, - {VALIDATION_ERROR_0080c201, "The spec valid usage text states 'loadOp must be a valid VkAttachmentLoadOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-loadOp-parameter)"}, - {VALIDATION_ERROR_0082b401, "The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-samples-parameter)"}, - {VALIDATION_ERROR_0082e001, "The spec valid usage text states 'stencilLoadOp must be a valid VkAttachmentLoadOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-stencilLoadOp-parameter)"}, - {VALIDATION_ERROR_0082e201, "The spec valid usage text states 'stencilStoreOp must be a valid VkAttachmentStoreOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-stencilStoreOp-parameter)"}, - {VALIDATION_ERROR_0082e401, "The spec valid usage text states 'storeOp must be a valid VkAttachmentStoreOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentDescription-storeOp-parameter)"}, - {VALIDATION_ERROR_00a006b2, "The spec valid usage text states 'layout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentReference-layout-00857)"}, - {VALIDATION_ERROR_00a0be01, "The spec valid usage text states 'layout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkAttachmentReference-layout-parameter)"}, - {VALIDATION_ERROR_00c00009, "The spec valid usage text states 'Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-commonparent)"}, - {VALIDATION_ERROR_00c00c72, "The spec valid usage text states 'buffer must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01593)"}, - {VALIDATION_ERROR_00c00c74, "The spec valid usage text states 'buffer must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01594)"}, - {VALIDATION_ERROR_00c00c76, "The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memoryOffset-01595)"}, - {VALIDATION_ERROR_00c00c78, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01596)"}, - {VALIDATION_ERROR_00c00c7a, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01597)"}, - {VALIDATION_ERROR_00c00c7c, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01598)"}, - {VALIDATION_ERROR_00c00c7e, "The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-01599)"}, - {VALIDATION_ERROR_00c00c80, "The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memoryOffset-01600)"}, - {VALIDATION_ERROR_00c00c82, "The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-size-01601)"}, - {VALIDATION_ERROR_00c00c84, "The spec valid usage text states 'If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01602)"}, - {VALIDATION_ERROR_00c00c86, "The spec valid usage text states 'If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01603)"}, - {VALIDATION_ERROR_00c00c88, "The spec valid usage text states 'If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01604)"}, - {VALIDATION_ERROR_00c00c8a, "The spec valid usage text states 'If the pNext chain includes VkBindBufferMemoryDeviceGroupInfo, all instances of memory specified by VkBindBufferMemoryDeviceGroupInfo::pDeviceIndices must have been allocated' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-pNext-01605)"}, - {VALIDATION_ERROR_00c00ed8, "The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-01900)"}, - {VALIDATION_ERROR_00c01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-parameter)"}, - {VALIDATION_ERROR_00c0c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-parameter)"}, - {VALIDATION_ERROR_00c1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-pNext-pNext)"}, - {VALIDATION_ERROR_00c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-sType-sType)"}, - {VALIDATION_ERROR_00e00009, "The spec valid usage text states 'Both of image, and memory that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-commonparent)"}, - {VALIDATION_ERROR_00e00c92, "The spec valid usage text states 'image must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01609)"}, - {VALIDATION_ERROR_00e00c94, "The spec valid usage text states 'image must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01610)"}, - {VALIDATION_ERROR_00e00c96, "The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memoryOffset-01611)"}, - {VALIDATION_ERROR_00e00c98, "The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01612)"}, - {VALIDATION_ERROR_00e00c9a, "The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memoryOffset-01613)"}, - {VALIDATION_ERROR_00e00c9c, "The spec valid usage text states 'The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01614)"}, - {VALIDATION_ERROR_00e00c9e, "The spec valid usage text states 'If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01615)"}, - {VALIDATION_ERROR_00e00ca0, "The spec valid usage text states 'If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01616)"}, - {VALIDATION_ERROR_00e00ca2, "The spec valid usage text states 'If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01617)"}, - {VALIDATION_ERROR_00e00ca4, "The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, image must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01618)"}, - {VALIDATION_ERROR_00e00ca6, "The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2's pNext chain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01619)"}, - {VALIDATION_ERROR_00e00ca8, "The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2's pNext chain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01620)"}, - {VALIDATION_ERROR_00e00caa, "The spec valid usage text states 'If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2's pNext chain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01621)"}, - {VALIDATION_ERROR_00e00cac, "The spec valid usage text states 'If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01622)"}, - {VALIDATION_ERROR_00e00cae, "The spec valid usage text states 'If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01623)"}, - {VALIDATION_ERROR_00e00cb0, "The spec valid usage text states 'If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01624)"}, - {VALIDATION_ERROR_00e00cb2, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01625)"}, - {VALIDATION_ERROR_00e00cb4, "The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all instances of memory specified by VkBindImageMemoryDeviceGroupInfo::pDeviceIndices must have been allocated' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01626)"}, - {VALIDATION_ERROR_00e00cb6, "The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, and VkBindImageMemoryDeviceGroupInfo::splitInstanceBindRegionCount is not zero, then image must have been created with the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01627)"}, - {VALIDATION_ERROR_00e00cb8, "The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions must be valid rectangles contained within the dimensions of image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01628)"}, - {VALIDATION_ERROR_00e00cba, "The spec valid usage text states 'If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, the union of the areas of all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions that correspond to the same instance of image must cover the entire image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01629)"}, - {VALIDATION_ERROR_00e00cbc, "The spec valid usage text states 'If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01630)"}, - {VALIDATION_ERROR_00e00cbe, "The spec valid usage text states 'If the pNext chain includes an instance of VkBindImageMemorySwapchainInfoKHR, memory must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01631)"}, - {VALIDATION_ERROR_00e00cc0, "The spec valid usage text states 'If the pNext chain does not include an instance of VkBindImageMemorySwapchainInfoKHR, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01632)"}, - {VALIDATION_ERROR_00e00ede, "The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01903)"}, - {VALIDATION_ERROR_00e0a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-parameter)"}, - {VALIDATION_ERROR_00e1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, or VkBindImagePlaneMemoryInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-pNext)"}, - {VALIDATION_ERROR_00e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-sType-sType)"}, - {VALIDATION_ERROR_00e2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-sType-unique)"}, - {VALIDATION_ERROR_01000cd8, "The spec valid usage text states 'imageIndex must be less than the number of images in swapchain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644)"}, - {VALIDATION_ERROR_0102b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0102f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_01200009, "The spec valid usage text states 'Both of the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-commonparent)"}, - {VALIDATION_ERROR_01210201, "The spec valid usage text states 'If bufferBindCount is not 0, pBufferBinds must be a valid pointer to an array of bufferBindCount valid VkSparseBufferMemoryBindInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pBufferBinds-parameter)"}, - {VALIDATION_ERROR_01218001, "The spec valid usage text states 'If imageBindCount is not 0, pImageBinds must be a valid pointer to an array of imageBindCount valid VkSparseImageMemoryBindInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pImageBinds-parameter)"}, - {VALIDATION_ERROR_01218c01, "The spec valid usage text states 'If imageOpaqueBindCount is not 0, pImageOpaqueBinds must be a valid pointer to an array of imageOpaqueBindCount valid VkSparseImageOpaqueMemoryBindInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pImageOpaqueBinds-parameter)"}, - {VALIDATION_ERROR_0121c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDeviceGroupBindSparseInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pNext-pNext)"}, - {VALIDATION_ERROR_01223401, "The spec valid usage text states 'If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pSignalSemaphores-parameter)"}, - {VALIDATION_ERROR_01227601, "The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-pWaitSemaphores-parameter)"}, - {VALIDATION_ERROR_0122b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBindSparseInfo-sType-sType)"}, - {VALIDATION_ERROR_01400720, "The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-size-00912)"}, - {VALIDATION_ERROR_01400722, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-00913)"}, - {VALIDATION_ERROR_01400724, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-00914)"}, - {VALIDATION_ERROR_01400726, "The spec valid usage text states 'If the sparse bindings feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00915)"}, - {VALIDATION_ERROR_01400728, "The spec valid usage text states 'If the sparse buffer residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00916)"}, - {VALIDATION_ERROR_0140072a, "The spec valid usage text states 'If the sparse aliased residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00917)"}, - {VALIDATION_ERROR_0140072c, "The spec valid usage text states 'If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00918)"}, - {VALIDATION_ERROR_01400730, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryBufferCreateInfo, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.pname:compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo-&gt;handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-00920)"}, - {VALIDATION_ERROR_01400ade, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01391)"}, - {VALIDATION_ERROR_01400b16, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01419)"}, - {VALIDATION_ERROR_01400c46, "The spec valid usage text states 'If the pNext chain contains an instance of VkDedicatedAllocationBufferCreateInfoNV, and the dedicatedAllocation member of the chained structure is VK_TRUE, then flags must not include VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-01571)"}, - {VALIDATION_ERROR_01400ebe, "The spec valid usage text states 'If the protected memory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-flags-01887)"}, - {VALIDATION_ERROR_01400ec0, "The spec valid usage text states 'If any of the bits VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT are set, VK_BUFFER_CREATE_PROTECTED_BIT must not also be set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-None-01888)"}, - {VALIDATION_ERROR_01409001, "The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0141c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV or VkExternalMemoryBufferCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0142b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0142b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_0142c001, "The spec valid usage text states 'sharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-parameter)"}, - {VALIDATION_ERROR_01430601, "The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-parameter)"}, - {VALIDATION_ERROR_01430603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-requiredbitmask)"}, - {VALIDATION_ERROR_01600182, "The spec valid usage text states 'If the calling command's VkImage parameter's format is not a depth/stencil format, then bufferOffset must be a multiple of the format's element size' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-00193)"}, - {VALIDATION_ERROR_01600184, "The spec valid usage text states 'bufferOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-00194)"}, - {VALIDATION_ERROR_01600186, "The spec valid usage text states 'bufferRowLength must be 0, or greater than or equal to the width member of imageExtent' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferRowLength-00195)"}, - {VALIDATION_ERROR_01600188, "The spec valid usage text states 'bufferImageHeight must be 0, or greater than or equal to the height member of imageExtent' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferImageHeight-00196)"}, - {VALIDATION_ERROR_0160018a, "The spec valid usage text states 'imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00197)"}, - {VALIDATION_ERROR_0160018c, "The spec valid usage text states 'imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00198)"}, - {VALIDATION_ERROR_0160018e, "The spec valid usage text states 'If the calling command's srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D, then imageOffset.y must be 0 and imageExtent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-srcImage-00199)"}, - {VALIDATION_ERROR_01600190, "The spec valid usage text states 'imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00200)"}, - {VALIDATION_ERROR_01600192, "The spec valid usage text states 'If the calling command's srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then imageOffset.z must be 0 and imageExtent.depth must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-srcImage-00201)"}, - {VALIDATION_ERROR_01600196, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, bufferRowLength must be a multiple of the compressed texel block width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferRowLength-00203)"}, - {VALIDATION_ERROR_01600198, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, bufferImageHeight must be a multiple of the compressed texel block height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferImageHeight-00204)"}, - {VALIDATION_ERROR_0160019a, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageOffset-00205)"}, - {VALIDATION_ERROR_0160019c, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, bufferOffset must be a multiple of the compressed texel block size in bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-00206)"}, - {VALIDATION_ERROR_0160019e, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageExtent-00207)"}, - {VALIDATION_ERROR_016001a0, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageExtent-00208)"}, - {VALIDATION_ERROR_016001a2, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageExtent-00209)"}, - {VALIDATION_ERROR_016001a6, "The spec valid usage text states 'The aspectMask member of imageSubresource must specify aspects present in the calling command's VkImage parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-aspectMask-00211)"}, - {VALIDATION_ERROR_016001a8, "The spec valid usage text states 'The aspectMask member of imageSubresource must only have a single bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-aspectMask-00212)"}, - {VALIDATION_ERROR_016001aa, "The spec valid usage text states 'If the calling command's VkImage parameter is of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of imageSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-baseArrayLayer-00213)"}, - {VALIDATION_ERROR_016001ac, "The spec valid usage text states 'When copying to the depth aspect of an image subresource, the data in the source buffer must be in the range [0,1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-None-00214)"}, - {VALIDATION_ERROR_01600c2c, "The spec valid usage text states 'If the calling command's VkImage parameter's format is not a depth/stencil format or a multi-planar format, then bufferOffset must be a multiple of the format's element size' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-01558)"}, - {VALIDATION_ERROR_01600c2e, "The spec valid usage text states 'If the calling command's VkImage parameter's format is a multi-planar format, then bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in features-formats-compatible-planes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-bufferOffset-01559)"}, - {VALIDATION_ERROR_01600c30, "The spec valid usage text states 'If the calling command's VkImage parameter's format is a multi-planar format, then the aspectMask member of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-aspectMask-01560)"}, - {VALIDATION_ERROR_01600d8e, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, \"_422\" image format, bufferRowLength must be a multiple of the compressed texel block width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01735)"}, - {VALIDATION_ERROR_01600d90, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, \"_422\" image format, bufferImageHeight must be a multiple of the compressed texel block height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01736)"}, - {VALIDATION_ERROR_01600d92, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, \"_422\" image format, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01737)"}, - {VALIDATION_ERROR_01600d94, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, \"_422\" image format, bufferOffset must be a multiple of the compressed texel block size in bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01738)"}, - {VALIDATION_ERROR_01600d96, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, \"_422\" image format, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01739)"}, - {VALIDATION_ERROR_01600d98, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, \"_422\" image format, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01740)"}, - {VALIDATION_ERROR_01600d9a, "The spec valid usage text states 'If the calling command's VkImage parameter is a compressed image, or a single-plane, \"_422\" image format, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferImageCopy-None-01741)"}, - {VALIDATION_ERROR_0160aa01, "The spec valid usage text states 'imageSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferImageCopy-imageSubresource-parameter)"}, - {VALIDATION_ERROR_01800946, "The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-offset-01187)"}, - {VALIDATION_ERROR_01800948, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-size-01188)"}, - {VALIDATION_ERROR_0180094a, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-size-01189)"}, - {VALIDATION_ERROR_0180094c, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01190)"}, - {VALIDATION_ERROR_0180094e, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01191)"}, - {VALIDATION_ERROR_01800950, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see devsandqueues-queueprops)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01192)"}, - {VALIDATION_ERROR_01800952, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01193)"}, - {VALIDATION_ERROR_01800958, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01196)"}, - {VALIDATION_ERROR_01800dc6, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory ownership transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01763)"}, - {VALIDATION_ERROR_01800dc8, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01764)"}, - {VALIDATION_ERROR_01800dca, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01765)"}, - {VALIDATION_ERROR_01800f16, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01931)"}, - {VALIDATION_ERROR_01801a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-parameter)"}, - {VALIDATION_ERROR_01806801, "The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-dstAccessMask-parameter)"}, - {VALIDATION_ERROR_0181c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-pNext-pNext)"}, - {VALIDATION_ERROR_0182b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-sType-sType)"}, - {VALIDATION_ERROR_0182c401, "The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-srcAccessMask-parameter)"}, - {VALIDATION_ERROR_01a0073a, "The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-offset-00925)"}, - {VALIDATION_ERROR_01a0073c, "The spec valid usage text states 'offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-offset-00926)"}, - {VALIDATION_ERROR_01a00740, "The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-range-00928)"}, - {VALIDATION_ERROR_01a00742, "The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be a multiple of the element size of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-range-00929)"}, - {VALIDATION_ERROR_01a00744, "The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-range-00930)"}, - {VALIDATION_ERROR_01a00746, "The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-offset-00931)"}, - {VALIDATION_ERROR_01a00748, "The spec valid usage text states 'buffer must have been created with a usage value containing at least one of VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00932)"}, - {VALIDATION_ERROR_01a0074a, "The spec valid usage text states 'If buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format must be supported for uniform texel buffers, as specified by the VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00933)"}, - {VALIDATION_ERROR_01a0074c, "The spec valid usage text states 'If buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format must be supported for storage texel buffers, as specified by the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00934)"}, - {VALIDATION_ERROR_01a0074e, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-00935)"}, - {VALIDATION_ERROR_01a01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-buffer-parameter)"}, - {VALIDATION_ERROR_01a09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_01a09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-format-parameter)"}, - {VALIDATION_ERROR_01a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_01a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferViewCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_01c00026, "The spec valid usage text states 'If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, it must not include VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-00019)"}, - {VALIDATION_ERROR_01c00028, "The spec valid usage text states 'aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-00020)"}, - {VALIDATION_ERROR_01c0002a, "The spec valid usage text states 'clearValue must be a valid VkClearValue union' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-clearValue-00021)"}, - {VALIDATION_ERROR_01c00c01, "The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-parameter)"}, - {VALIDATION_ERROR_01c00c03, "The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearAttachment-aspectMask-requiredbitmask)"}, - {VALIDATION_ERROR_01c00e22, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then the attachment to be cleared must not be a protected image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkClearAttachment-commandBuffer-01809)"}, - {VALIDATION_ERROR_01c00e24, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then the attachment to be cleared must not be an unprotected image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkClearAttachment-commandBuffer-01810)"}, - {VALIDATION_ERROR_01e0002c, "The spec valid usage text states 'Unless the VK_EXT_depth_range_unrestricted extension is enabled depth must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkClearDepthStencilValue-depth-00022)"}, - {VALIDATION_ERROR_0200002e, "The spec valid usage text states 'depthStencil must be a valid VkClearDepthStencilValue structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkClearValue-depthStencil-00023)"}, - {VALIDATION_ERROR_02200009, "The spec valid usage text states 'Each of indirectCommandsLayout, objectTable, sequencesCountBuffer, sequencesIndexBuffer, and targetCommandBuffer that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-commonparent)"}, - {VALIDATION_ERROR_02200a66, "The spec valid usage text states 'The provided objectTable must include all objects referenced by the generation process.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-objectTable-01331)"}, - {VALIDATION_ERROR_02200a68, "The spec valid usage text states 'indirectCommandsTokenCount must match the indirectCommandsLayout's tokenCount.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-01332)"}, - {VALIDATION_ERROR_02200a6a, "The spec valid usage text states 'The tokenType member of each entry in the pIndirectCommandsTokens array must match the values used at creation time of indirectCommandsLayout' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-tokenType-01333)"}, - {VALIDATION_ERROR_02200a6c, "The spec valid usage text states 'If targetCommandBuffer is provided, it must have reserved command space.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01334)"}, - {VALIDATION_ERROR_02200a6e, "The spec valid usage text states 'If targetCommandBuffer is provided, the objectTable must match the reservation's objectTable and must have had all referenced objects registered at reservation time.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01335)"}, - {VALIDATION_ERROR_02200a70, "The spec valid usage text states 'If targetCommandBuffer is provided, the indirectCommandsLayout must match the reservation's indirectCommandsLayout.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01336)"}, - {VALIDATION_ERROR_02200a72, "The spec valid usage text states 'If targetCommandBuffer is provided, the maxSequencesCount must not exceed the reservation's maxSequencesCount.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01337)"}, - {VALIDATION_ERROR_02200a74, "The spec valid usage text states 'If sequencesCountBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01338)"}, - {VALIDATION_ERROR_02200a76, "The spec valid usage text states 'If sequencesCountBuffer is used, sequencesCountOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceCountBufferOffsetAlignment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01339)"}, - {VALIDATION_ERROR_02200a78, "The spec valid usage text states 'If sequencesIndexBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01340)"}, - {VALIDATION_ERROR_02200a7a, "The spec valid usage text states 'If sequencesIndexBuffer is used, sequencesIndexOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceIndexBufferOffsetAlignment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01341)"}, - {VALIDATION_ERROR_0220b401, "The spec valid usage text states 'indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter)"}, - {VALIDATION_ERROR_0220b61b, "The spec valid usage text states 'indirectCommandsTokenCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-arraylength)"}, - {VALIDATION_ERROR_0220d801, "The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter)"}, - {VALIDATION_ERROR_02219401, "The spec valid usage text states 'pIndirectCommandsTokens must be a valid pointer to an array of indirectCommandsTokenCount valid VkIndirectCommandsTokenNVX structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-pIndirectCommandsTokens-parameter)"}, - {VALIDATION_ERROR_0221c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-pNext-pNext)"}, - {VALIDATION_ERROR_0222b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sType-sType)"}, - {VALIDATION_ERROR_0222ba01, "The spec valid usage text states 'If sequencesCountBuffer is not VK_NULL_HANDLE, sequencesCountBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter)"}, - {VALIDATION_ERROR_0222bc01, "The spec valid usage text states 'If sequencesIndexBuffer is not VK_NULL_HANDLE, sequencesIndexBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter)"}, - {VALIDATION_ERROR_0222f601, "The spec valid usage text states 'If targetCommandBuffer is not NULL, targetCommandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter)"}, - {VALIDATION_ERROR_02400009, "The spec valid usage text states 'Both of indirectCommandsLayout, and objectTable must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent)"}, - {VALIDATION_ERROR_0240b401, "The spec valid usage text states 'indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter)"}, - {VALIDATION_ERROR_0240d801, "The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter)"}, - {VALIDATION_ERROR_0241c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-pNext-pNext)"}, - {VALIDATION_ERROR_0242b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCmdReserveSpaceForCommandsInfoNVX-sType-sType)"}, - {VALIDATION_ERROR_02600058, "The spec valid usage text states 'commandBufferCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044)"}, - {VALIDATION_ERROR_02602801, "The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-commandPool-parameter)"}, - {VALIDATION_ERROR_0260c001, "The spec valid usage text states 'level must be a valid VkCommandBufferLevel value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-level-parameter)"}, - {VALIDATION_ERROR_0261c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0262b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferAllocateInfo-sType-sType)"}, - {VALIDATION_ERROR_0280006a, "The spec valid usage text states 'If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo must be a valid VkRenderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-00053)"}, - {VALIDATION_ERROR_0280006c, "The spec valid usage text states 'If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-00054)"}, - {VALIDATION_ERROR_0280006e, "The spec valid usage text states 'If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-00055)"}, - {VALIDATION_ERROR_02809001, "The spec valid usage text states 'flags must be a valid combination of VkCommandBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-flags-parameter)"}, - {VALIDATION_ERROR_0281c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0282b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferBeginInfo-sType-sType)"}, - {VALIDATION_ERROR_02a00009, "The spec valid usage text states 'Both of framebuffer, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-commonparent)"}, - {VALIDATION_ERROR_02a00070, "The spec valid usage text states 'If the inherited queries feature is not enabled, occlusionQueryEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056)"}, - {VALIDATION_ERROR_02a00072, "The spec valid usage text states 'If the inherited queries feature is enabled, queryFlags must be a valid combination of VkQueryControlFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-queryFlags-00057)"}, - {VALIDATION_ERROR_02a00074, "The spec valid usage text states 'If the pipeline statistics queries feature is not enabled, pipelineStatistics must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058)"}, - {VALIDATION_ERROR_02a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-pNext-pNext)"}, - {VALIDATION_ERROR_02a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-sType-sType)"}, - {VALIDATION_ERROR_02c0004e, "The spec valid usage text states 'queueFamilyIndex must be the index of a queue family available in the calling command's device parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-queueFamilyIndex-00039)"}, - {VALIDATION_ERROR_02c09001, "The spec valid usage text states 'flags must be a valid combination of VkCommandPoolCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_02c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_02c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCommandPoolCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_02e00001, "The spec valid usage text states 'a must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-a-parameter)"}, - {VALIDATION_ERROR_02e01001, "The spec valid usage text states 'b must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-b-parameter)"}, - {VALIDATION_ERROR_02e09a01, "The spec valid usage text states 'g must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-g-parameter)"}, - {VALIDATION_ERROR_02e2a201, "The spec valid usage text states 'r must be a valid VkComponentSwizzle value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComponentMapping-r-parameter)"}, - {VALIDATION_ERROR_03000009, "The spec valid usage text states 'Both of basePipelineHandle, and layout that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-commonparent)"}, - {VALIDATION_ERROR_03000572, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00697)"}, - {VALIDATION_ERROR_03000574, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command's pCreateInfos parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00698)"}, - {VALIDATION_ERROR_03000576, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00699)"}, - {VALIDATION_ERROR_03000578, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-00700)"}, - {VALIDATION_ERROR_0300057a, "The spec valid usage text states 'The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-00701)"}, - {VALIDATION_ERROR_0300057c, "The spec valid usage text states 'The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-00702)"}, - {VALIDATION_ERROR_0300057e, "The spec valid usage text states 'layout must be consistent with the layout of the compute shader specified in stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-00703)"}, - {VALIDATION_ERROR_03000d2e, "The spec valid usage text states 'The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-01687)"}, - {VALIDATION_ERROR_03009001, "The spec valid usage text states 'flags must be a valid combination of VkPipelineCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0300be01, "The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-parameter)"}, - {VALIDATION_ERROR_0301c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0302b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0302d801, "The spec valid usage text states 'stage must be a valid VkPipelineShaderStageCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-parameter)"}, - {VALIDATION_ERROR_03200009, "The spec valid usage text states 'Both of dstSet, and srcSet must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-commonparent)"}, - {VALIDATION_ERROR_032002b2, "The spec valid usage text states 'srcBinding must be a valid binding within srcSet' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcBinding-00345)"}, - {VALIDATION_ERROR_032002b4, "The spec valid usage text states 'The sum of srcArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by srcBinding, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcArrayElement-00346)"}, - {VALIDATION_ERROR_032002b6, "The spec valid usage text states 'dstBinding must be a valid binding within dstSet' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-dstBinding-00347)"}, - {VALIDATION_ERROR_032002b8, "The spec valid usage text states 'The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-dstArrayElement-00348)"}, - {VALIDATION_ERROR_032002ba, "The spec valid usage text states 'If srcSet is equal to dstSet, then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-00349)"}, - {VALIDATION_ERROR_03200efc, "The spec valid usage text states 'If srcSet's layout was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet's layout must also have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01918)"}, - {VALIDATION_ERROR_03200efe, "The spec valid usage text states 'If srcSet's layout was created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet's layout must also have been created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01919)"}, - {VALIDATION_ERROR_03200f00, "The spec valid usage text states 'If the descriptor pool from which srcSet was allocated was created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01920)"}, - {VALIDATION_ERROR_03200f02, "The spec valid usage text states 'If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-01921)"}, - {VALIDATION_ERROR_03207601, "The spec valid usage text states 'dstSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-dstSet-parameter)"}, - {VALIDATION_ERROR_0321c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-pNext-pNext)"}, - {VALIDATION_ERROR_0322b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-sType-sType)"}, - {VALIDATION_ERROR_0322d201, "The spec valid usage text states 'srcSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-parameter)"}, - {VALIDATION_ERROR_0340009e, "The spec valid usage text states 'waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079)"}, - {VALIDATION_ERROR_034000a0, "The spec valid usage text states 'signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080)"}, - {VALIDATION_ERROR_03423201, "The spec valid usage text states 'If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a valid pointer to an array of signalSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter)"}, - {VALIDATION_ERROR_03427401, "The spec valid usage text states 'If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a valid pointer to an array of waitSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter)"}, - {VALIDATION_ERROR_0342b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0361a801, "The spec valid usage text states 'pMarkerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter)"}, - {VALIDATION_ERROR_0361c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_0362b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_03800ba4, "The spec valid usage text states 'objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490)"}, - {VALIDATION_ERROR_03800ba6, "The spec valid usage text states 'object must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-object-01491)"}, - {VALIDATION_ERROR_03800ba8, "The spec valid usage text states 'object must be a Vulkan object of the type associated with objectType as defined in debug-report-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-object-01492)"}, - {VALIDATION_ERROR_0380da01, "The spec valid usage text states 'objectType must be a valid VkDebugReportObjectTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-objectType-parameter)"}, - {VALIDATION_ERROR_0381c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_0381ce01, "The spec valid usage text states 'pObjectName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-pObjectName-parameter)"}, - {VALIDATION_ERROR_0382b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_03a00baa, "The spec valid usage text states 'objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493)"}, - {VALIDATION_ERROR_03a00bac, "The spec valid usage text states 'object must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-object-01494)"}, - {VALIDATION_ERROR_03a00bae, "The spec valid usage text states 'object must be a Vulkan object of the type associated with objectType as defined in debug-report-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-object-01495)"}, - {VALIDATION_ERROR_03a0da01, "The spec valid usage text states 'objectType must be a valid VkDebugReportObjectTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-objectType-parameter)"}, - {VALIDATION_ERROR_03a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_03a25a01, "The spec valid usage text states 'pTag must be a valid pointer to an array of tagSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-pTag-parameter)"}, - {VALIDATION_ERROR_03a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_03a2f41b, "The spec valid usage text states 'tagSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugMarkerObjectTagInfoEXT-tagSize-arraylength)"}, - {VALIDATION_ERROR_03c00ad2, "The spec valid usage text states 'pfnCallback must be a valid PFN_vkDebugReportCallbackEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-01385)"}, - {VALIDATION_ERROR_03c09001, "The spec valid usage text states 'flags must be a valid combination of VkDebugReportFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter)"}, - {VALIDATION_ERROR_03c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_03e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationBufferCreateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_040007c4, "The spec valid usage text states 'If dedicatedAllocation is VK_TRUE, VkImageCreateInfo::flags must not include VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994)"}, - {VALIDATION_ERROR_0402b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_04200009, "The spec valid usage text states 'Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-commonparent)"}, - {VALIDATION_ERROR_04200512, "The spec valid usage text states 'At least one of image and buffer must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649)"}, - {VALIDATION_ERROR_04200514, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, the image must have been created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650)"}, - {VALIDATION_ERROR_04200516, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, the buffer must have been created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651)"}, - {VALIDATION_ERROR_04200518, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652)"}, - {VALIDATION_ERROR_0420051a, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653)"}, - {VALIDATION_ERROR_0420051c, "The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654)"}, - {VALIDATION_ERROR_0420051e, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655)"}, - {VALIDATION_ERROR_04201a01, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter)"}, - {VALIDATION_ERROR_0420a001, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter)"}, - {VALIDATION_ERROR_0422b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_044002a8, "The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-offset-00340)"}, - {VALIDATION_ERROR_044002aa, "The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00341)"}, - {VALIDATION_ERROR_044002ac, "The spec valid usage text states 'If range is not equal to VK_WHOLE_SIZE, range must be less than or equal to the size of buffer minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00342)"}, - {VALIDATION_ERROR_04401a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorBufferInfo-buffer-parameter)"}, - {VALIDATION_ERROR_04600009, "The spec valid usage text states 'Both of imageView, and sampler that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorImageInfo-commonparent)"}, - {VALIDATION_ERROR_046002ae, "The spec valid usage text states 'imageView must not be 2D or 2D array image view created from a 3D image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorImageInfo-imageView-00343)"}, - {VALIDATION_ERROR_046002b0, "The spec valid usage text states 'imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time this descriptor is accessed' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorImageInfo-imageLayout-00344)"}, - {VALIDATION_ERROR_04600c36, "The spec valid usage text states 'If sampler is used and enables sampler Y'CBCR conversion:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorImageInfo-sampler-01563)"}, - {VALIDATION_ERROR_04600c38, "The spec valid usage text states 'If sampler is used and does not enable sampler Y'CBCR conversion and the VkFormat of the image is a multi-planar format, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorImageInfo-sampler-01564)"}, - {VALIDATION_ERROR_0480025a, "The spec valid usage text states 'maxSets must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-maxSets-00301)"}, - {VALIDATION_ERROR_04809001, "The spec valid usage text states 'flags must be a valid combination of VkDescriptorPoolCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0481c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0481e401, "The spec valid usage text states 'pPoolSizes must be a valid pointer to an array of poolSizeCount valid VkDescriptorPoolSize structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter)"}, - {VALIDATION_ERROR_0482881b, "The spec valid usage text states 'poolSizeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength)"}, - {VALIDATION_ERROR_0482b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_04a0025c, "The spec valid usage text states 'descriptorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolSize-descriptorCount-00302)"}, - {VALIDATION_ERROR_04a30401, "The spec valid usage text states 'type must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorPoolSize-type-parameter)"}, - {VALIDATION_ERROR_04c00009, "The spec valid usage text states 'Both of descriptorPool, and the elements of pSetLayouts must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-commonparent)"}, - {VALIDATION_ERROR_04c00264, "The spec valid usage text states 'descriptorSetCount must not be greater than the number of sets that are currently available for allocation in descriptorPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-00306)"}, - {VALIDATION_ERROR_04c00266, "The spec valid usage text states 'descriptorPool must have enough free descriptor capacity remaining to allocate the descriptor sets of the specified layouts' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorPool-00307)"}, - {VALIDATION_ERROR_04c00268, "The spec valid usage text states 'Each element of pSetLayouts must not have been created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308)"}, - {VALIDATION_ERROR_04c017c8, "The spec valid usage text states 'If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044)"}, - {VALIDATION_ERROR_04c04601, "The spec valid usage text states 'descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter)"}, - {VALIDATION_ERROR_04c04a1b, "The spec valid usage text states 'descriptorSetCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength)"}, - {VALIDATION_ERROR_04c1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountAllocateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_04c22c01, "The spec valid usage text states 'pSetLayouts must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSetLayout handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter)"}, - {VALIDATION_ERROR_04c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetAllocateInfo-sType-sType)"}, - {VALIDATION_ERROR_04e00234, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorType-00282)"}, - {VALIDATION_ERROR_04e00236, "The spec valid usage text states 'If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283)"}, - {VALIDATION_ERROR_04e00bcc, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorType-01510)"}, - {VALIDATION_ERROR_04e04e01, "The spec valid usage text states 'descriptorType must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter)"}, - {VALIDATION_ERROR_0500022e, "The spec valid usage text states 'The VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-binding-00279)"}, - {VALIDATION_ERROR_05000230, "The spec valid usage text states 'If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-00280)"}, - {VALIDATION_ERROR_05000232, "The spec valid usage text states 'If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then the total number of elements of all bindings must be less than or equal to VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-00281)"}, - {VALIDATION_ERROR_05001770, "The spec valid usage text states 'If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, flags must include VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-03000)"}, - {VALIDATION_ERROR_05001772, "The spec valid usage text states 'If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001)"}, - {VALIDATION_ERROR_05009001, "The spec valid usage text states 'flags must be a valid combination of VkDescriptorSetLayoutCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0500fc01, "The spec valid usage text states 'If bindingCount is not 0, pBindings must be a valid pointer to an array of bindingCount valid VkDescriptorSetLayoutBinding structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter)"}, - {VALIDATION_ERROR_0501c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDescriptorSetLayoutBindingFlagsCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0502b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDescriptorSetLayoutCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_05200009, "The spec valid usage text states 'Both of descriptorSetLayout, and pipelineLayout that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent)"}, - {VALIDATION_ERROR_052002bc, "The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must be a valid VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350)"}, - {VALIDATION_ERROR_052002be, "The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351)"}, - {VALIDATION_ERROR_052002c0, "The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352)"}, - {VALIDATION_ERROR_052002c2, "The spec valid usage text states 'If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353)"}, - {VALIDATION_ERROR_05204c01, "The spec valid usage text states 'If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter)"}, - {VALIDATION_ERROR_0520501b, "The spec valid usage text states 'descriptorUpdateEntryCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorUpdateEntryCount-arraylength)"}, - {VALIDATION_ERROR_05209005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_05213201, "The spec valid usage text states 'pDescriptorUpdateEntries must be a valid pointer to an array of descriptorUpdateEntryCount valid VkDescriptorUpdateTemplateEntry structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-pDescriptorUpdateEntries-parameter)"}, - {VALIDATION_ERROR_0521c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0522b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0522f801, "The spec valid usage text states 'templateType must be a valid VkDescriptorUpdateTemplateType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-parameter)"}, - {VALIDATION_ERROR_054002c4, "The spec valid usage text states 'dstBinding must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354)"}, - {VALIDATION_ERROR_054002c6, "The spec valid usage text states 'dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding implicitly specified when using a descriptor update template to update descriptors, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355)"}, - {VALIDATION_ERROR_05404e01, "The spec valid usage text states 'descriptorType must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorUpdateTemplateEntry-descriptorType-parameter)"}, - {VALIDATION_ERROR_056002e8, "The spec valid usage text states '' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-queueFamilyIndex-00372)"}, - {VALIDATION_ERROR_056002ea, "The spec valid usage text states 'If the pNext chain includes a VkPhysicalDeviceFeatures2 structure, then pEnabledFeatures must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-00373)"}, - {VALIDATION_ERROR_056002ec, "The spec valid usage text states 'ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374)"}, - {VALIDATION_ERROR_05600e60, "The spec valid usage text states 'ppEnabledExtensionNames must not contain VK_AMD_negative_viewport_height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840)"}, - {VALIDATION_ERROR_05609005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_05615a01, "The spec valid usage text states 'If pEnabledFeatures is not NULL, pEnabledFeatures must be a valid pointer to a valid VkPhysicalDeviceFeatures structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter)"}, - {VALIDATION_ERROR_0561c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceSamplerYcbcrConversionFeatures, or VkPhysicalDeviceVariablePointerFeatures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0561fe01, "The spec valid usage text states 'pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter)"}, - {VALIDATION_ERROR_05628e01, "The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter)"}, - {VALIDATION_ERROR_05629001, "The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter)"}, - {VALIDATION_ERROR_0562a01b, "The spec valid usage text states 'queueCreateInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength)"}, - {VALIDATION_ERROR_0562b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0562b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_05805801, "The spec valid usage text states 'deviceEvent must be a valid VkDeviceEventTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceEventInfoEXT-deviceEvent-parameter)"}, - {VALIDATION_ERROR_0581c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceEventInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_0582b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceEventInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_05a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsFeaturesNVX-pNext-pNext)"}, - {VALIDATION_ERROR_05a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsFeaturesNVX-sType-sType)"}, - {VALIDATION_ERROR_05c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsLimitsNVX-pNext-pNext)"}, - {VALIDATION_ERROR_05c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGeneratedCommandsLimitsNVX-sType-sType)"}, - {VALIDATION_ERROR_05e008bc, "The spec valid usage text states 'resourceDeviceIndex and memoryDeviceIndex must both be valid device indices.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118)"}, - {VALIDATION_ERROR_05e008be, "The spec valid usage text states 'Each memory allocation bound in this batch must have allocated an instance for memoryDeviceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119)"}, - {VALIDATION_ERROR_05e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupBindSparseInfo-sType-sType)"}, - {VALIDATION_ERROR_060000d4, "The spec valid usage text states 'deviceMask must be a valid device mask value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106)"}, - {VALIDATION_ERROR_060000d6, "The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107)"}, - {VALIDATION_ERROR_0602b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType)"}, - {VALIDATION_ERROR_062002ee, "The spec valid usage text states 'Each element of pPhysicalDevices must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375)"}, - {VALIDATION_ERROR_062002f0, "The spec valid usage text states 'All elements of pPhysicalDevices must be in the same device group as enumerated by vkEnumeratePhysicalDeviceGroups' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376)"}, - {VALIDATION_ERROR_062002f2, "The spec valid usage text states 'If physicalDeviceCount is not 0, the physicalDevice parameter of vkCreateDevice must be an element of pPhysicalDevices.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377)"}, - {VALIDATION_ERROR_0621dc01, "The spec valid usage text states 'If physicalDeviceCount is not 0, pPhysicalDevices must be a valid pointer to an array of physicalDeviceCount valid VkPhysicalDevice handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter)"}, - {VALIDATION_ERROR_0622b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupDeviceCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_06400a22, "The spec valid usage text states 'swapchainCount must equal 0 or VkPresentInfoKHR::swapchainCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297)"}, - {VALIDATION_ERROR_06400a24, "The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01298)"}, - {VALIDATION_ERROR_06400a26, "The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and some physical device in the logical device must include that bit in its VkDeviceGroupPresentCapabilitiesKHR::presentMask.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01299)"}, - {VALIDATION_ERROR_06400a28, "The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, then each element of pDeviceMasks must have a value for which all set bits are set in one of the elements of VkDeviceGroupPresentCapabilitiesKHR::presentMask' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01300)"}, - {VALIDATION_ERROR_06400a2a, "The spec valid usage text states 'If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, then for each bit set in each element of pDeviceMasks, the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01301)"}, - {VALIDATION_ERROR_06400a2c, "The spec valid usage text states 'The value of each element of pDeviceMasks must be equal to the device mask passed in VkAcquireNextImageInfoKHR::deviceMask when the image index was last acquired' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302)"}, - {VALIDATION_ERROR_06400a2e, "The spec valid usage text states 'mode must have exactly one bit set, and that bit must have been included in VkDeviceGroupSwapchainCreateInfoKHR::modes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-01303)"}, - {VALIDATION_ERROR_0640ce01, "The spec valid usage text states 'mode must be a valid VkDeviceGroupPresentModeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-mode-parameter)"}, - {VALIDATION_ERROR_06414001, "The spec valid usage text states 'If swapchainCount is not 0, pDeviceMasks must be a valid pointer to an array of swapchainCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter)"}, - {VALIDATION_ERROR_0642b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_06600712, "The spec valid usage text states 'deviceMask must be a valid device mask value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905)"}, - {VALIDATION_ERROR_06600714, "The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906)"}, - {VALIDATION_ERROR_06600716, "The spec valid usage text states 'deviceMask must be a subset of the command buffer's initial device mask' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907)"}, - {VALIDATION_ERROR_06600718, "The spec valid usage text states 'deviceRenderAreaCount must either be zero or equal to the number of physical devices in the logical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908)"}, - {VALIDATION_ERROR_06614201, "The spec valid usage text states 'If deviceRenderAreaCount is not 0, pDeviceRenderAreas must be a valid pointer to an array of deviceRenderAreaCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter)"}, - {VALIDATION_ERROR_0662b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType)"}, - {VALIDATION_ERROR_068000a4, "The spec valid usage text states 'waitSemaphoreCount must equal VkSubmitInfo::waitSemaphoreCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082)"}, - {VALIDATION_ERROR_068000a6, "The spec valid usage text states 'commandBufferCount must equal VkSubmitInfo::commandBufferCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083)"}, - {VALIDATION_ERROR_068000a8, "The spec valid usage text states 'signalSemaphoreCount must equal VkSubmitInfo::signalSemaphoreCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084)"}, - {VALIDATION_ERROR_068000aa, "The spec valid usage text states 'All elements of pWaitSemaphoreDeviceIndices and pSignalSemaphoreDeviceIndices must be valid device indices' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085)"}, - {VALIDATION_ERROR_068000ac, "The spec valid usage text states 'All elements of pCommandBufferDeviceMasks must be valid device masks' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086)"}, - {VALIDATION_ERROR_06811201, "The spec valid usage text states 'If commandBufferCount is not 0, pCommandBufferDeviceMasks must be a valid pointer to an array of commandBufferCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter)"}, - {VALIDATION_ERROR_06823001, "The spec valid usage text states 'If signalSemaphoreCount is not 0, pSignalSemaphoreDeviceIndices must be a valid pointer to an array of signalSemaphoreCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter)"}, - {VALIDATION_ERROR_06827201, "The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphoreDeviceIndices must be a valid pointer to an array of waitSemaphoreCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter)"}, - {VALIDATION_ERROR_0682b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSubmitInfo-sType-sType)"}, - {VALIDATION_ERROR_06a0d001, "The spec valid usage text states 'modes must be a valid combination of VkDeviceGroupPresentModeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter)"}, - {VALIDATION_ERROR_06a0d003, "The spec valid usage text states 'modes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask)"}, - {VALIDATION_ERROR_06a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_06c002fa, "The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381)"}, - {VALIDATION_ERROR_06c002fc, "The spec valid usage text states 'queueCount must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-queueCount-00382)"}, - {VALIDATION_ERROR_06c002fe, "The spec valid usage text states 'Each element of pQueuePriorities must be between 0.0 and 1.0 inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383)"}, - {VALIDATION_ERROR_06c09001, "The spec valid usage text states 'flags must be a valid combination of VkDeviceQueueCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_06c1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDeviceQueueGlobalPriorityCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_06c20401, "The spec valid usage text states 'pQueuePriorities must be a valid pointer to an array of queueCount float values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter)"}, - {VALIDATION_ERROR_06c29e1b, "The spec valid usage text states 'queueCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-queueCount-arraylength)"}, - {VALIDATION_ERROR_06c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceQueueCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_06e00342, "The spec valid usage text states 'x must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDispatchIndirectCommand-x-00417)"}, - {VALIDATION_ERROR_06e00344, "The spec valid usage text states 'y must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDispatchIndirectCommand-y-00418)"}, - {VALIDATION_ERROR_06e00346, "The spec valid usage text states 'z must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDispatchIndirectCommand-z-00419)"}, - {VALIDATION_ERROR_07006201, "The spec valid usage text states 'displayEvent must be a valid VkDisplayEventTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayEventInfoEXT-displayEvent-parameter)"}, - {VALIDATION_ERROR_0701c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayEventInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_0702b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayEventInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_072009c4, "The spec valid usage text states 'The width and height members of the visibleRegion member of parameters must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-width-01250)"}, - {VALIDATION_ERROR_072009c6, "The spec valid usage text states 'The refreshRate member of parameters must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-refreshRate-01251)"}, - {VALIDATION_ERROR_07209005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_0721c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_0722b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayModeCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0741c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPowerInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_07428a01, "The spec valid usage text states 'powerState must be a valid VkDisplayPowerStateEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPowerInfoEXT-powerState-parameter)"}, - {VALIDATION_ERROR_0742b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPowerInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_076009d2, "The spec valid usage text states 'srcRect must specify a rectangular region that is a subset of the image being presented' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-srcRect-01257)"}, - {VALIDATION_ERROR_076009d4, "The spec valid usage text states 'dstRect must specify a rectangular region that is a subset of the visibleRegion parameter of the display mode the swapchain being presented uses' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-dstRect-01258)"}, - {VALIDATION_ERROR_076009d6, "The spec valid usage text states 'If the persistentContent member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display the present operation targets then persistent must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-persistentContent-01259)"}, - {VALIDATION_ERROR_0762b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplayPresentInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_078009c8, "The spec valid usage text states 'planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252)"}, - {VALIDATION_ERROR_078009ca, "The spec valid usage text states 'If the planeReorderPossible member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display corresponding to displayMode is VK_TRUE then planeStackIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR; otherwise planeStackIndex must equal the currentStackIndex member of VkDisplayPlanePropertiesKHR returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR for the display plane corresponding to displayMode' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253)"}, - {VALIDATION_ERROR_078009cc, "The spec valid usage text states 'If alphaMode is VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR then globalAlpha must be between 0 and 1, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254)"}, - {VALIDATION_ERROR_078009ce, "The spec valid usage text states 'alphaMode must be 0 or one of the bits present in the supportedAlpha member of VkDisplayPlaneCapabilitiesKHR returned by vkGetDisplayPlaneCapabilitiesKHR for the display plane corresponding to displayMode' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255)"}, - {VALIDATION_ERROR_078009d0, "The spec valid usage text states 'The width and height members of imageExtent must be less than the maxImageDimensions2D member of VkPhysicalDeviceLimits' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-width-01256)"}, - {VALIDATION_ERROR_07800a01, "The spec valid usage text states 'alphaMode must be a valid VkDisplayPlaneAlphaFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter)"}, - {VALIDATION_ERROR_07806401, "The spec valid usage text states 'displayMode must be a valid VkDisplayModeKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter)"}, - {VALIDATION_ERROR_07809005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_0781c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_0782b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_07830201, "The spec valid usage text states 'transform must be a valid VkSurfaceTransformFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter)"}, - {VALIDATION_ERROR_07a00450, "The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndexedIndirectCommand-None-00552)"}, - {VALIDATION_ERROR_07a00452, "The spec valid usage text states '(indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndexedIndirectCommand-indexSize-00553)"}, - {VALIDATION_ERROR_07a00454, "The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndexedIndirectCommand-firstInstance-00554)"}, - {VALIDATION_ERROR_07c003e8, "The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndirectCommand-None-00500)"}, - {VALIDATION_ERROR_07c003ea, "The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDrawIndirectCommand-firstInstance-00501)"}, - {VALIDATION_ERROR_07e09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_07e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_07e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_08000520, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfo-handleTypes-00656)"}, - {VALIDATION_ERROR_08009e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfo-handleTypes-parameter)"}, - {VALIDATION_ERROR_0802b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfo-sType-sType)"}, - {VALIDATION_ERROR_08209e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter)"}, - {VALIDATION_ERROR_0822b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_08400522, "The spec valid usage text states 'If VkExportMemoryAllocateInfo::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, VkExportMemoryWin32HandleInfoKHR must not be in the pNext chain of VkMemoryAllocateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657)"}, - {VALIDATION_ERROR_0840f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter)"}, - {VALIDATION_ERROR_0842b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0860f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter)"}, - {VALIDATION_ERROR_0862b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-sType-sType)"}, - {VALIDATION_ERROR_088008c8, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphoreProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreCreateInfo-handleTypes-01124)"}, - {VALIDATION_ERROR_08809e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter)"}, - {VALIDATION_ERROR_0882b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_08a008ca, "The spec valid usage text states 'If VkExportSemaphoreCreateInfo::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, VkExportSemaphoreWin32HandleInfoKHR must not be in the pNext chain of VkSemaphoreCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125)"}, - {VALIDATION_ERROR_08a0f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter)"}, - {VALIDATION_ERROR_08a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_08c09e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter)"}, - {VALIDATION_ERROR_08c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_08e09e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter)"}, - {VALIDATION_ERROR_08e09e03, "The spec valid usage text states 'handleTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask)"}, - {VALIDATION_ERROR_08e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_09009e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter)"}, - {VALIDATION_ERROR_0902b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_09209001, "The spec valid usage text states 'flags must be a valid combination of VkFenceCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0921c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportFenceCreateInfo or VkExportFenceWin32HandleInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0922b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0922b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_09400009, "The spec valid usage text states 'Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-commonparent)"}, - {VALIDATION_ERROR_094006d8, "The spec valid usage text states 'attachmentCount must be equal to the attachment count specified in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-attachmentCount-00876)"}, - {VALIDATION_ERROR_094006da, "The spec valid usage text states 'Each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00877)"}, - {VALIDATION_ERROR_094006dc, "The spec valid usage text states 'Each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00878)"}, - {VALIDATION_ERROR_094006de, "The spec valid usage text states 'Each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00879)"}, - {VALIDATION_ERROR_094006e0, "The spec valid usage text states 'Each element of pAttachments must have been created with an VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00880)"}, - {VALIDATION_ERROR_094006e2, "The spec valid usage text states 'Each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00881)"}, - {VALIDATION_ERROR_094006e4, "The spec valid usage text states 'Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00882)"}, - {VALIDATION_ERROR_094006e6, "The spec valid usage text states 'Each element of pAttachments must only specify a single mip level' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00883)"}, - {VALIDATION_ERROR_094006e8, "The spec valid usage text states 'Each element of pAttachments must have been created with the identity swizzle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00884)"}, - {VALIDATION_ERROR_094006ea, "The spec valid usage text states 'width must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-width-00885)"}, - {VALIDATION_ERROR_094006ec, "The spec valid usage text states 'width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-width-00886)"}, - {VALIDATION_ERROR_094006ee, "The spec valid usage text states 'height must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-height-00887)"}, - {VALIDATION_ERROR_094006f0, "The spec valid usage text states 'height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-height-00888)"}, - {VALIDATION_ERROR_094006f2, "The spec valid usage text states 'layers must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-layers-00889)"}, - {VALIDATION_ERROR_094006f4, "The spec valid usage text states 'layers must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-layers-00890)"}, - {VALIDATION_ERROR_094006f6, "The spec valid usage text states 'Each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00891)"}, - {VALIDATION_ERROR_09409005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0940f201, "The spec valid usage text states 'If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-parameter)"}, - {VALIDATION_ERROR_0941c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0942ae01, "The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-renderPass-parameter)"}, - {VALIDATION_ERROR_0942b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_09600009, "The spec valid usage text states 'Each of basePipelineHandle, layout, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-commonparent)"}, - {VALIDATION_ERROR_096005a4, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00722)"}, - {VALIDATION_ERROR_096005a6, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command's pCreateInfos parameter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00723)"}, - {VALIDATION_ERROR_096005a8, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00724)"}, - {VALIDATION_ERROR_096005aa, "The spec valid usage text states 'If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00725)"}, - {VALIDATION_ERROR_096005ac, "The spec valid usage text states 'The stage member of each element of pStages must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-00726)"}, - {VALIDATION_ERROR_096005ae, "The spec valid usage text states 'The stage member of one element of pStages must be VK_SHADER_STAGE_VERTEX_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-00727)"}, - {VALIDATION_ERROR_096005b0, "The spec valid usage text states 'The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-00728)"}, - {VALIDATION_ERROR_096005b2, "The spec valid usage text states 'If pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00729)"}, - {VALIDATION_ERROR_096005b4, "The spec valid usage text states 'If pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00730)"}, - {VALIDATION_ERROR_096005b6, "The spec valid usage text states 'If pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pTessellationState must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00731)"}, - {VALIDATION_ERROR_096005b8, "The spec valid usage text states 'If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00732)"}, - {VALIDATION_ERROR_096005ba, "The spec valid usage text states 'If pStages includes tessellation shader stages, and the shader code of both stages contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline, they must both specify the same subdivision mode' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00733)"}, - {VALIDATION_ERROR_096005bc, "The spec valid usage text states 'If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the output patch size in the pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00734)"}, - {VALIDATION_ERROR_096005be, "The spec valid usage text states 'If pStages includes tessellation shader stages, and the shader code of both contain an OpExecutionMode instruction that specifies the out patch size in the pipeline, they must both specify the same patch size' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00735)"}, - {VALIDATION_ERROR_096005c0, "The spec valid usage text states 'If pStages includes tessellation shader stages, the topology member of pInputAssembly must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00736)"}, - {VALIDATION_ERROR_096005c2, "The spec valid usage text states 'If the topology member of pInputAssembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, pStages must include tessellation shader stages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-topology-00737)"}, - {VALIDATION_ERROR_096005c4, "The spec valid usage text states 'If pStages includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology specified in pInputAssembly' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00738)"}, - {VALIDATION_ERROR_096005c6, "The spec valid usage text states 'If pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology that is output by the tessellation stages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00739)"}, - {VALIDATION_ERROR_096005c8, "The spec valid usage text states 'If pStages includes a fragment shader stage and a geometry shader stage, and the fragment shader code reads from an input variable that is decorated with PrimitiveID, then the geometry shader code must write to a matching output variable, decorated with PrimitiveID, in all execution paths' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00740)"}, - {VALIDATION_ERROR_096005ca, "The spec valid usage text states 'If pStages includes a fragment shader stage, its shader code must not read from any input attachment that is defined as VK_ATTACHMENT_UNUSED in subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00741)"}, - {VALIDATION_ERROR_096005cc, "The spec valid usage text states 'The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00742)"}, - {VALIDATION_ERROR_096005ce, "The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00743)"}, - {VALIDATION_ERROR_096005d0, "The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00744)"}, - {VALIDATION_ERROR_096005d2, "The spec valid usage text states 'If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the blendEnable member of the corresponding element of the pAttachment member of pColorBlendState must be VK_FALSE if the format of the attachment does not support color blend operations, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00745)"}, - {VALIDATION_ERROR_096005d4, "The spec valid usage text states 'If rasterization is not disabled and the subpass uses color attachments, the attachmentCount member of pColorBlendState must be equal to the colorAttachmentCount used to create subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746)"}, - {VALIDATION_ERROR_096005d6, "The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState::viewportCount VkViewport structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747)"}, - {VALIDATION_ERROR_096005d8, "The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState::scissorCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748)"}, - {VALIDATION_ERROR_096005da, "The spec valid usage text states 'If the wide lines feature is not enabled, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_WIDTH, the lineWidth member of pRasterizationState must be 1.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749)"}, - {VALIDATION_ERROR_096005dc, "The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750)"}, - {VALIDATION_ERROR_096005de, "The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751)"}, - {VALIDATION_ERROR_096005e0, "The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses a depth/stencil attachment, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752)"}, - {VALIDATION_ERROR_096005e2, "The spec valid usage text states 'If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753)"}, - {VALIDATION_ERROR_096005e4, "The spec valid usage text states 'If the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754)"}, - {VALIDATION_ERROR_096005e6, "The spec valid usage text states 'If the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755)"}, - {VALIDATION_ERROR_096005e8, "The spec valid usage text states 'layout must be consistent with all shaders specified in pStages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-00756)"}, - {VALIDATION_ERROR_096005ea, "The spec valid usage text states 'If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must be the same as the sample count for those subpass attachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00757)"}, - {VALIDATION_ERROR_096005ec, "The spec valid usage text states 'If subpass does not use any color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must follow the rules for a zero-attachment subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00758)"}, - {VALIDATION_ERROR_096005ee, "The spec valid usage text states 'subpass must be a valid subpass within renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00759)"}, - {VALIDATION_ERROR_096005f0, "The spec valid usage text states 'If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewTessellationShader is not enabled, then pStages must not include tessellation shaders.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00760)"}, - {VALIDATION_ERROR_096005f2, "The spec valid usage text states 'If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewGeometryShader is not enabled, then pStages must not include a geometry shader.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00761)"}, - {VALIDATION_ERROR_096005f4, "The spec valid usage text states 'If the renderPass has multiview enabled and subpass has more than one bit set in the view mask, shaders in the pipeline must not write to the Layer built-in output' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00762)"}, - {VALIDATION_ERROR_096005f6, "The spec valid usage text states 'If the renderPass has multiview enabled, then all shaders must not include variables decorated with the Layer built-in decoration in their interfaces.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-00763)"}, - {VALIDATION_ERROR_096005f8, "The spec valid usage text states 'flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-00764)"}, - {VALIDATION_ERROR_09600b06, "The spec valid usage text states 'If subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the rasterizationSamples member of pMultisampleState must be the same as the sample count of the depth/stencil attachment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01411)"}, - {VALIDATION_ERROR_09600b08, "The spec valid usage text states 'If subpass has any color attachments, then the rasterizationSamples member of pMultisampleState must be greater than or equal to the sample count for those subpass attachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01412)"}, - {VALIDATION_ERROR_09600bc2, "The spec valid usage text states 'If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must equal the maximum of the sample counts of those subpass attachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01505)"}, - {VALIDATION_ERROR_09600be2, "The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.width must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.width as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521)"}, - {VALIDATION_ERROR_09600be4, "The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.height must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.height as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522)"}, - {VALIDATION_ERROR_09600be6, "The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523)"}, - {VALIDATION_ERROR_09600be8, "The spec valid usage text states 'If the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524)"}, - {VALIDATION_ERROR_09600c3a, "The spec valid usage text states 'If pStages includes a fragment shader stage and an input attachment was referenced by the VkRenderPassInputAttachmentAspectCreateInfo at renderPass create time, its shader code must not read from any aspect that was not specified in the aspectMask of the corresponding VkInputAttachmentAspectReference structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-01565)"}, - {VALIDATION_ERROR_09600d30, "The spec valid usage text states 'The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-01688)"}, - {VALIDATION_ERROR_09600d66, "The spec valid usage text states 'If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, chained to the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715)"}, - {VALIDATION_ERROR_09600db8, "The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01756)"}, - {VALIDATION_ERROR_09600dba, "The spec valid usage text states 'If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-01757)"}, - {VALIDATION_ERROR_09609001, "The spec valid usage text states 'flags must be a valid combination of VkPipelineCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0960be01, "The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-parameter)"}, - {VALIDATION_ERROR_09615601, "The spec valid usage text states 'If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter)"}, - {VALIDATION_ERROR_09619801, "The spec valid usage text states 'pInputAssemblyState must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter)"}, - {VALIDATION_ERROR_0961c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_09620801, "The spec valid usage text states 'pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter)"}, - {VALIDATION_ERROR_09623e01, "The spec valid usage text states 'pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-parameter)"}, - {VALIDATION_ERROR_09626801, "The spec valid usage text states 'pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter)"}, - {VALIDATION_ERROR_0962ae01, "The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter)"}, - {VALIDATION_ERROR_0962b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0962da1b, "The spec valid usage text states 'stageCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength)"}, - {VALIDATION_ERROR_09800a48, "The spec valid usage text states 'pView must be a valid UIView and must be backed by a CALayer instance of type CAMetalLayer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-pView-01316)"}, - {VALIDATION_ERROR_09809005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-flags-zerobitmask)"}, - {VALIDATION_ERROR_0981c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-pNext-pNext)"}, - {VALIDATION_ERROR_0982b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIOSSurfaceCreateInfoMVK-sType-sType)"}, - {VALIDATION_ERROR_09a001dc, "The spec valid usage text states 'The aspectMask member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-aspectMask-00238)"}, - {VALIDATION_ERROR_09a001de, "The spec valid usage text states 'The layerCount member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-layerCount-00239)"}, - {VALIDATION_ERROR_09a001e0, "The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcImage-00240)"}, - {VALIDATION_ERROR_09a001e2, "The spec valid usage text states 'The aspectMask member of srcSubresource must specify aspects present in the calling command's srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-aspectMask-00241)"}, - {VALIDATION_ERROR_09a001e4, "The spec valid usage text states 'The aspectMask member of dstSubresource must specify aspects present in the calling command's dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-aspectMask-00242)"}, - {VALIDATION_ERROR_09a001e6, "The spec valid usage text states 'srcOffset[0].x and srcOffset[1].x must both be greater than or equal to 0 and less than or equal to the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcOffset-00243)"}, - {VALIDATION_ERROR_09a001e8, "The spec valid usage text states 'srcOffset[0].y and srcOffset[1].y must both be greater than or equal to 0 and less than or equal to the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcOffset-00244)"}, - {VALIDATION_ERROR_09a001ea, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset[0].y must be 0 and srcOffset[1].y must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcImage-00245)"}, - {VALIDATION_ERROR_09a001ec, "The spec valid usage text states 'srcOffset[0].z and srcOffset[1].z must both be greater than or equal to 0 and less than or equal to the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcOffset-00246)"}, - {VALIDATION_ERROR_09a001ee, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset[0].z must be 0 and srcOffset[1].z must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcImage-00247)"}, - {VALIDATION_ERROR_09a001f0, "The spec valid usage text states 'dstOffset[0].x and dstOffset[1].x must both be greater than or equal to 0 and less than or equal to the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstOffset-00248)"}, - {VALIDATION_ERROR_09a001f2, "The spec valid usage text states 'dstOffset[0].y and dstOffset[1].y must both be greater than or equal to 0 and less than or equal to the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstOffset-00249)"}, - {VALIDATION_ERROR_09a001f4, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset[0].y must be 0 and dstOffset[1].y must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstImage-00250)"}, - {VALIDATION_ERROR_09a001f6, "The spec valid usage text states 'dstOffset[0].z and dstOffset[1].z must both be greater than or equal to 0 and less than or equal to the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstOffset-00251)"}, - {VALIDATION_ERROR_09a001f8, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset[0].z must be 0 and dstOffset[1].z must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstImage-00252)"}, - {VALIDATION_ERROR_09a07a01, "The spec valid usage text states 'dstSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-dstSubresource-parameter)"}, - {VALIDATION_ERROR_09a2d601, "The spec valid usage text states 'srcSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageBlit-srcSubresource-parameter)"}, - {VALIDATION_ERROR_09c00112, "The spec valid usage text states 'The aspectMask member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-aspectMask-00137)"}, - {VALIDATION_ERROR_09c00114, "The spec valid usage text states 'The layerCount member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-layerCount-00138)"}, - {VALIDATION_ERROR_09c00116, "The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-00139)"}, - {VALIDATION_ERROR_09c00118, "The spec valid usage text states 'The number of slices of the extent (for 3D) or layers of the srcSubresource (for non-3D) must match the number of slices of the extent (for 3D) or layers of the dstSubresource (for non-3D)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-extent-00140)"}, - {VALIDATION_ERROR_09c0011a, "The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of the corresponding subresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-00141)"}, - {VALIDATION_ERROR_09c0011c, "The spec valid usage text states 'The aspectMask member of srcSubresource must specify aspects present in the calling command's srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-aspectMask-00142)"}, - {VALIDATION_ERROR_09c0011e, "The spec valid usage text states 'The aspectMask member of dstSubresource must specify aspects present in the calling command's dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-aspectMask-00143)"}, - {VALIDATION_ERROR_09c00120, "The spec valid usage text states 'srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00144)"}, - {VALIDATION_ERROR_09c00122, "The spec valid usage text states 'srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00145)"}, - {VALIDATION_ERROR_09c00124, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-00146)"}, - {VALIDATION_ERROR_09c00126, "The spec valid usage text states 'srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00147)"}, - {VALIDATION_ERROR_09c0012c, "The spec valid usage text states 'dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00150)"}, - {VALIDATION_ERROR_09c0012e, "The spec valid usage text states 'dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00151)"}, - {VALIDATION_ERROR_09c00130, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstImage-00152)"}, - {VALIDATION_ERROR_09c00132, "The spec valid usage text states 'dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00153)"}, - {VALIDATION_ERROR_09c0013a, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcOffset-00157)"}, - {VALIDATION_ERROR_09c0013c, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00158)"}, - {VALIDATION_ERROR_09c0013e, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00159)"}, - {VALIDATION_ERROR_09c00140, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00160)"}, - {VALIDATION_ERROR_09c00144, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstOffset-00162)"}, - {VALIDATION_ERROR_09c00146, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00163)"}, - {VALIDATION_ERROR_09c00148, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00164)"}, - {VALIDATION_ERROR_09c0014a, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-extent-00165)"}, - {VALIDATION_ERROR_09c00c1e, "The spec valid usage text states 'If neither the calling command's srcImage nor the calling command's dstImage has a multi-planar image format then the aspectMask member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01551)"}, - {VALIDATION_ERROR_09c00c20, "The spec valid usage text states 'If the calling command's srcImage has a VkFormat with two planes then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01552)"}, - {VALIDATION_ERROR_09c00c22, "The spec valid usage text states 'If the calling command's srcImage has a VkFormat with three planes then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01553)"}, - {VALIDATION_ERROR_09c00c24, "The spec valid usage text states 'If the calling command's dstImage has a VkFormat with two planes then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01554)"}, - {VALIDATION_ERROR_09c00c26, "The spec valid usage text states 'If the calling command's dstImage has a VkFormat with three planes then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01555)"}, - {VALIDATION_ERROR_09c00c28, "The spec valid usage text states 'If the calling command's srcImage has a multi-planar image format and the dstImage does not have a multi-planar image format, the dstSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01556)"}, - {VALIDATION_ERROR_09c00c2a, "The spec valid usage text states 'If the calling command's dstImage has a multi-planar image format and the srcImage does not have a multi-planar image format, the srcSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01557)"}, - {VALIDATION_ERROR_09c00d7e, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, \"_422\" image format, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01727)"}, - {VALIDATION_ERROR_09c00d80, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, \"_422\" image format, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01728)"}, - {VALIDATION_ERROR_09c00d82, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, \"_422\" image format, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01729)"}, - {VALIDATION_ERROR_09c00d84, "The spec valid usage text states 'If the calling command's srcImage is a compressed image, or a single-plane, \"_422\" image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01730)"}, - {VALIDATION_ERROR_09c00d86, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, \"_422\" image format, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01731)"}, - {VALIDATION_ERROR_09c00d88, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, \"_422\" image format, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01732)"}, - {VALIDATION_ERROR_09c00d8a, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, \"_422\" image format, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01733)"}, - {VALIDATION_ERROR_09c00d8c, "The spec valid usage text states 'If the calling command's dstImage is a compressed format image, or a single-plane, \"_422\" image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01734)"}, - {VALIDATION_ERROR_09c00df2, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-01785)"}, - {VALIDATION_ERROR_09c00df4, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstImage-01786)"}, - {VALIDATION_ERROR_09c00df6, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_2D, then srcOffset.z must be 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-01787)"}, - {VALIDATION_ERROR_09c00df8, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_2D, then dstOffset.z must be 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstImage-01788)"}, - {VALIDATION_ERROR_09c00dfa, "The spec valid usage text states 'If the calling command's srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcImage-01789)"}, - {VALIDATION_ERROR_09c00dfc, "The spec valid usage text states 'If both srcImage and dstImage are of type VK_IMAGE_TYPE_2D then then extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01790)"}, - {VALIDATION_ERROR_09c00dfe, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_2D, and the dstImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of srcSubresource.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-srcImage-01791)"}, - {VALIDATION_ERROR_09c00e00, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_2D, and the srcImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of dstSubresource.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCopy-dstImage-01792)"}, - {VALIDATION_ERROR_09c07a01, "The spec valid usage text states 'dstSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-dstSubresource-parameter)"}, - {VALIDATION_ERROR_09c2d601, "The spec valid usage text states 'srcSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCopy-srcSubresource-parameter)"}, - {VALIDATION_ERROR_09e00758, "The spec valid usage text states 'The combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-00940)"}, - {VALIDATION_ERROR_09e0075a, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-00941)"}, - {VALIDATION_ERROR_09e0075c, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-00942)"}, - {VALIDATION_ERROR_09e0075e, "The spec valid usage text states 'format must not be VK_FORMAT_UNDEFINED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-00943)"}, - {VALIDATION_ERROR_09e00760, "The spec valid usage text states 'extent::width must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00944)"}, - {VALIDATION_ERROR_09e00762, "The spec valid usage text states 'extent::height must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00945)"}, - {VALIDATION_ERROR_09e00764, "The spec valid usage text states 'extent::depth must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00946)"}, - {VALIDATION_ERROR_09e00766, "The spec valid usage text states 'mipLevels must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-mipLevels-00947)"}, - {VALIDATION_ERROR_09e00768, "The spec valid usage text states 'arrayLayers must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-arrayLayers-00948)"}, - {VALIDATION_ERROR_09e0076a, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_2D' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00949)"}, - {VALIDATION_ERROR_09e0076c, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_3D' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00950)"}, - {VALIDATION_ERROR_09e0076e, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_1D, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension1D, or VkImageFormatProperties::maxExtent.width (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00951)"}, - {VALIDATION_ERROR_09e00770, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D and flags does not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension2D, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00952)"}, - {VALIDATION_ERROR_09e00772, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimensionCube, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00953)"}, - {VALIDATION_ERROR_09e00774, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be equal and arrayLayers must be greater than or equal to 6' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00954)"}, - {VALIDATION_ERROR_09e00776, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_3D, extent.width, extent.height and extent.depth must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension3D, or VkImageFormatProperties::maxExtent.width/height/depth (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00955)"}, - {VALIDATION_ERROR_09e00778, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00956)"}, - {VALIDATION_ERROR_09e0077a, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_2D, extent.depth must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00957)"}, - {VALIDATION_ERROR_09e0077c, "The spec valid usage text states 'mipLevels must be less than or equal to {lfloor}log2(max(extent.width, extent.height, extent.depth)){rfloor} + 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-mipLevels-00958)"}, - {VALIDATION_ERROR_09e0077e, "The spec valid usage text states 'mipLevels must be less than or equal to VkImageFormatProperties::maxMipLevels (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-extent-00959)"}, - {VALIDATION_ERROR_09e00780, "The spec valid usage text states 'arrayLayers must be less than or equal to VkImageFormatProperties::maxArrayLayers (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-arrayLayers-00960)"}, - {VALIDATION_ERROR_09e00782, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_3D, arrayLayers must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00961)"}, - {VALIDATION_ERROR_09e00784, "The spec valid usage text states 'If samples is not VK_SAMPLE_COUNT_1_BIT, imageType must be VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, tiling must be VK_IMAGE_TILING_OPTIMAL, and mipLevels must be equal to 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-00962)"}, - {VALIDATION_ERROR_09e00786, "The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, then bits other than VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT must not be set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00963)"}, - {VALIDATION_ERROR_09e00788, "The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00964)"}, - {VALIDATION_ERROR_09e0078a, "The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00965)"}, - {VALIDATION_ERROR_09e0078c, "The spec valid usage text states 'If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, usage must also contain at least one of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00966)"}, - {VALIDATION_ERROR_09e0078e, "The spec valid usage text states 'samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-00967)"}, - {VALIDATION_ERROR_09e00790, "The spec valid usage text states 'If the multisampled storage images feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-00968)"}, - {VALIDATION_ERROR_09e00792, "The spec valid usage text states 'If the sparse bindings feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00969)"}, - {VALIDATION_ERROR_09e00794, "The spec valid usage text states 'If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00970)"}, - {VALIDATION_ERROR_09e00796, "The spec valid usage text states 'If the sparse residency for 2D images feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00971)"}, - {VALIDATION_ERROR_09e00798, "The spec valid usage text states 'If the sparse residency for 3D images feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00972)"}, - {VALIDATION_ERROR_09e0079a, "The spec valid usage text states 'If the sparse residency for images with 2 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00973)"}, - {VALIDATION_ERROR_09e0079c, "The spec valid usage text states 'If the sparse residency for images with 4 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00974)"}, - {VALIDATION_ERROR_09e0079e, "The spec valid usage text states 'If the sparse residency for images with 8 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00975)"}, - {VALIDATION_ERROR_09e007a0, "The spec valid usage text states 'If the sparse residency for images with 16 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-00976)"}, - {VALIDATION_ERROR_09e007b6, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00987)"}, - {VALIDATION_ERROR_09e007b8, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00988)"}, - {VALIDATION_ERROR_09e007bc, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfo, its handleTypes member must only contain bits that are also in VkExternalImageFormatProperties::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2 with format, imageType, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfo in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfo::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00990)"}, - {VALIDATION_ERROR_09e007be, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, imageType, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00991)"}, - {VALIDATION_ERROR_09e007c0, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00992)"}, - {VALIDATION_ERROR_09e007c2, "The spec valid usage text states 'initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-00993)"}, - {VALIDATION_ERROR_09e00ae0, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01392)"}, - {VALIDATION_ERROR_09e00b18, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01420)"}, - {VALIDATION_ERROR_09e00b1a, "The spec valid usage text states 'If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-physicalDeviceCount-01421)"}, - {VALIDATION_ERROR_09e00b46, "The spec valid usage text states 'If the pNext chain includes a ifdef::VK_VERSION_1_1,VK_KHR_external_memory[VkExternalMemoryImageCreateInfo]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01443)"}, - {VALIDATION_ERROR_09e00bfa, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT format must be a depth or depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01533)"}, - {VALIDATION_ERROR_09e00c48, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then format must be a block-compressed image format, an ETC compressed image format, or an ASTC compressed image format.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01572)"}, - {VALIDATION_ERROR_09e00c4a, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01573)"}, - {VALIDATION_ERROR_09e00c4c, "The spec valid usage text states 'If the image format is one of those listed in features-formats-requiring-sampler-ycbcr-conversion:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-format-01574)"}, - {VALIDATION_ERROR_09e00c4e, "The spec valid usage text states 'If tiling is VK_IMAGE_TILING_OPTIMAL, format is a multi-planar format, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-tiling-01575)"}, - {VALIDATION_ERROR_09e00c50, "The spec valid usage text states 'If tiling is VK_IMAGE_TILING_LINEAR, format is a multi-planar format, and VkFormatProperties::linearTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-tiling-01576)"}, - {VALIDATION_ERROR_09e00c52, "The spec valid usage text states 'If format is not a multi-planar format, and flags does not include VK_IMAGE_CREATE_ALIAS_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-format-01577)"}, - {VALIDATION_ERROR_09e00ec2, "The spec valid usage text states 'If the pNext chain doesn't contain an instance of VkExternalFormatANDROID, or if format is not VK_FORMAT_UNDEFINED, the combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01889)"}, - {VALIDATION_ERROR_09e00ec4, "The spec valid usage text states 'If the protected memory feature is not enabled, flags must not contain VK_IMAGE_CREATE_PROTECTED_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-01890)"}, - {VALIDATION_ERROR_09e00ec6, "The spec valid usage text states 'If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_CREATE_PROTECTED_BIT must not also be set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-None-01891)"}, - {VALIDATION_ERROR_09e00ec8, "The spec valid usage text states 'If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01892)"}, - {VALIDATION_ERROR_09e00eca, "The spec valid usage text states 'If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01893)"}, - {VALIDATION_ERROR_09e00f08, "The spec valid usage text states 'If the sparse aliased residency feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-01924)"}, - {VALIDATION_ERROR_09e00f0a, "The spec valid usage text states 'If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-None-01925)"}, - {VALIDATION_ERROR_09e09001, "The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_09e09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-parameter)"}, - {VALIDATION_ERROR_09e0ac01, "The spec valid usage text states 'imageType must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-parameter)"}, - {VALIDATION_ERROR_09e0b801, "The spec valid usage text states 'initialLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-parameter)"}, - {VALIDATION_ERROR_09e1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageFormatListCreateInfoKHR, or VkImageSwapchainCreateInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_09e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_09e2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_09e2b401, "The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-parameter)"}, - {VALIDATION_ERROR_09e2c001, "The spec valid usage text states 'sharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-parameter)"}, - {VALIDATION_ERROR_09e2fa01, "The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-tiling-parameter)"}, - {VALIDATION_ERROR_09e30601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-parameter)"}, - {VALIDATION_ERROR_09e30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-requiredbitmask)"}, - {VALIDATION_ERROR_0a00095a, "The spec valid usage text states 'oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01197)"}, - {VALIDATION_ERROR_0a00095c, "The spec valid usage text states 'newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-newLayout-01198)"}, - {VALIDATION_ERROR_0a00095e, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01199)"}, - {VALIDATION_ERROR_0a000960, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see devsandqueues-queueprops).' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01200)"}, - {VALIDATION_ERROR_0a000962, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01201)"}, - {VALIDATION_ERROR_0a00096a, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01205)"}, - {VALIDATION_ERROR_0a00096e, "The spec valid usage text states 'If image has a depth/stencil format with both depth and stencil components, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01207)"}, - {VALIDATION_ERROR_0a000970, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01208)"}, - {VALIDATION_ERROR_0a000972, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01209)"}, - {VALIDATION_ERROR_0a000974, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01210)"}, - {VALIDATION_ERROR_0a000976, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01211)"}, - {VALIDATION_ERROR_0a000978, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01212)"}, - {VALIDATION_ERROR_0a00097a, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01213)"}, - {VALIDATION_ERROR_0a000aca, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01381)"}, - {VALIDATION_ERROR_0a000b9c, "The spec valid usage text states 'subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01486)"}, - {VALIDATION_ERROR_0a000ba0, "The spec valid usage text states 'subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01488)"}, - {VALIDATION_ERROR_0a000cf4, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01658)"}, - {VALIDATION_ERROR_0a000cf6, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01659)"}, - {VALIDATION_ERROR_0a000d0e, "The spec valid usage text states 'If image has a single-plane color format or is not disjoint, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01671)"}, - {VALIDATION_ERROR_0a000d10, "The spec valid usage text states 'If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01672)"}, - {VALIDATION_ERROR_0a000d12, "The spec valid usage text states 'If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01673)"}, - {VALIDATION_ERROR_0a000d78, "The spec valid usage text states 'If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01724)"}, - {VALIDATION_ERROR_0a000d7a, "The spec valid usage text states 'If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01725)"}, - {VALIDATION_ERROR_0a000dcc, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01766)"}, - {VALIDATION_ERROR_0a000dce, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01767)"}, - {VALIDATION_ERROR_0a000dd0, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in synchronization-queue-transfers.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01768)"}, - {VALIDATION_ERROR_0a000f18, "The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01932)"}, - {VALIDATION_ERROR_0a006801, "The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-dstAccessMask-parameter)"}, - {VALIDATION_ERROR_0a00a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-parameter)"}, - {VALIDATION_ERROR_0a00d401, "The spec valid usage text states 'newLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-newLayout-parameter)"}, - {VALIDATION_ERROR_0a00dc01, "The spec valid usage text states 'oldLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-parameter)"}, - {VALIDATION_ERROR_0a01c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-pNext-pNext)"}, - {VALIDATION_ERROR_0a02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-sType-sType)"}, - {VALIDATION_ERROR_0a02c401, "The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-srcAccessMask-parameter)"}, - {VALIDATION_ERROR_0a02ea01, "The spec valid usage text states 'subresourceRange must be a valid VkImageSubresourceRange structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-parameter)"}, - {VALIDATION_ERROR_0a200214, "The spec valid usage text states 'The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-aspectMask-00266)"}, - {VALIDATION_ERROR_0a200216, "The spec valid usage text states 'The layerCount member of srcSubresource and dstSubresource must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-layerCount-00267)"}, - {VALIDATION_ERROR_0a200218, "The spec valid usage text states 'If either of the calling command's srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcImage-00268)"}, - {VALIDATION_ERROR_0a20021a, "The spec valid usage text states 'srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcOffset-00269)"}, - {VALIDATION_ERROR_0a20021c, "The spec valid usage text states 'srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcOffset-00270)"}, - {VALIDATION_ERROR_0a20021e, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcImage-00271)"}, - {VALIDATION_ERROR_0a200220, "The spec valid usage text states 'srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcOffset-00272)"}, - {VALIDATION_ERROR_0a200222, "The spec valid usage text states 'If the calling command's srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcImage-00273)"}, - {VALIDATION_ERROR_0a200224, "The spec valid usage text states 'dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstOffset-00274)"}, - {VALIDATION_ERROR_0a200226, "The spec valid usage text states 'dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstOffset-00275)"}, - {VALIDATION_ERROR_0a200228, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstImage-00276)"}, - {VALIDATION_ERROR_0a20022a, "The spec valid usage text states 'dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstOffset-00277)"}, - {VALIDATION_ERROR_0a20022c, "The spec valid usage text states 'If the calling command's dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset.z must be 0 and extent.depth must be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstImage-00278)"}, - {VALIDATION_ERROR_0a207a01, "The spec valid usage text states 'dstSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-dstSubresource-parameter)"}, - {VALIDATION_ERROR_0a22d601, "The spec valid usage text states 'srcSubresource must be a valid VkImageSubresourceLayers structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageResolve-srcSubresource-parameter)"}, - {VALIDATION_ERROR_0a400c01, "The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresource-aspectMask-parameter)"}, - {VALIDATION_ERROR_0a400c03, "The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresource-aspectMask-requiredbitmask)"}, - {VALIDATION_ERROR_0a60014e, "The spec valid usage text states 'If aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-00167)"}, - {VALIDATION_ERROR_0a600150, "The spec valid usage text states 'aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-00168)"}, - {VALIDATION_ERROR_0a600c01, "The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-parameter)"}, - {VALIDATION_ERROR_0a600c03, "The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask)"}, - {VALIDATION_ERROR_0a600d48, "The spec valid usage text states 'layerCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceLayers-layerCount-01700)"}, - {VALIDATION_ERROR_0a800c01, "The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-aspectMask-parameter)"}, - {VALIDATION_ERROR_0a800c03, "The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-aspectMask-requiredbitmask)"}, - {VALIDATION_ERROR_0a800d0c, "The spec valid usage text states 'If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, then it must not include any of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSubresourceRange-aspectMask-01670)"}, - {VALIDATION_ERROR_0a800d70, "The spec valid usage text states 'If levelCount is not VK_REMAINING_MIP_LEVELS, it must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-levelCount-01720)"}, - {VALIDATION_ERROR_0a800d72, "The spec valid usage text states 'If layerCount is not VK_REMAINING_ARRAY_LAYERS, it must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageSubresourceRange-layerCount-01721)"}, - {VALIDATION_ERROR_0aa007c6, "The spec valid usage text states 'If swapchain is not VK_NULL_HANDLE, the fields of VkImageCreateInfo must match the implied image creation parameters of the swapchain' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995)"}, - {VALIDATION_ERROR_0aa2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSwapchainCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0aa2f001, "The spec valid usage text states 'If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_0ac007d6, "The spec valid usage text states 'If image was not created with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then viewType must not be VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01003)"}, - {VALIDATION_ERROR_0ac007d8, "The spec valid usage text states 'If the image cubemap arrays feature is not enabled, viewType must not be VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-viewType-01004)"}, - {VALIDATION_ERROR_0ac007da, "The spec valid usage text states 'If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01005)"}, - {VALIDATION_ERROR_0ac007dc, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01006)"}, - {VALIDATION_ERROR_0ac007de, "The spec valid usage text states 'image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01007)"}, - {VALIDATION_ERROR_0ac007e0, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01008)"}, - {VALIDATION_ERROR_0ac007e2, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01009)"}, - {VALIDATION_ERROR_0ac007e4, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01010)"}, - {VALIDATION_ERROR_0ac007e6, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01011)"}, - {VALIDATION_ERROR_0ac007e8, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01012)"}, - {VALIDATION_ERROR_0ac007ea, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01013)"}, - {VALIDATION_ERROR_0ac007ec, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01014)"}, - {VALIDATION_ERROR_0ac007ee, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01015)"}, - {VALIDATION_ERROR_0ac007f0, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01016)"}, - {VALIDATION_ERROR_0ac007f4, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01018)"}, - {VALIDATION_ERROR_0ac007f6, "The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be identical to the format used to create image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01019)"}, - {VALIDATION_ERROR_0ac007f8, "The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01020)"}, - {VALIDATION_ERROR_0ac007fa, "The spec valid usage text states 'subresourceRange and viewType must be compatible with the image, as described in the compatibility table' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subResourceRange-01021)"}, - {VALIDATION_ERROR_0ac00b8c, "The spec valid usage text states 'subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01478)"}, - {VALIDATION_ERROR_0ac00b90, "The spec valid usage text states 'subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01480)"}, - {VALIDATION_ERROR_0ac00b94, "The spec valid usage text states 'If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01482)"}, - {VALIDATION_ERROR_0ac00b96, "The spec valid usage text states 'If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01483)"}, - {VALIDATION_ERROR_0ac00b98, "The spec valid usage text states 'If image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the extent.depth specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01484)"}, - {VALIDATION_ERROR_0ac00b9a, "The spec valid usage text states 'If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the extent.depth specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01485)"}, - {VALIDATION_ERROR_0ac00c5e, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with, or must be an uncompressed format that is size-compatible with, the format used to create image.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01583)"}, - {VALIDATION_ERROR_0ac00c60, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, the levelCount and layerCount members of subresourceRange must both be 1.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01584)"}, - {VALIDATION_ERROR_0ac00c62, "The spec valid usage text states 'If a VkImageFormatListCreateInfoKHR structure was included in the pNext chain of the VkImageCreateInfo struct used when creating image and the viewFormatCount field of VkImageFormatListCreateInfoKHR is not zero then format must be one of the formats in VkImageFormatListCreateInfoKHR::pViewFormats.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-pNext-01585)"}, - {VALIDATION_ERROR_0ac00c64, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a multi-planar format, and if subresourceRange.aspectMask is one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in features-formats-compatible-planes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01586)"}, - {VALIDATION_ERROR_0ac00d6c, "The spec valid usage text states 'If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01718)"}, - {VALIDATION_ERROR_0ac00d6e, "The spec valid usage text states 'If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01719)"}, - {VALIDATION_ERROR_0ac00dbe, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01759)"}, - {VALIDATION_ERROR_0ac00dc0, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01760)"}, - {VALIDATION_ERROR_0ac00dc2, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01761)"}, - {VALIDATION_ERROR_0ac00dc4, "The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag,' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01762)"}, - {VALIDATION_ERROR_0ac00ed0, "The spec valid usage text states 'If image has an external format:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01896)"}, - {VALIDATION_ERROR_0ac02c01, "The spec valid usage text states 'components must be a valid VkComponentMapping structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-components-parameter)"}, - {VALIDATION_ERROR_0ac09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0ac09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-format-parameter)"}, - {VALIDATION_ERROR_0ac0a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-parameter)"}, - {VALIDATION_ERROR_0ac1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageViewUsageCreateInfo or VkSamplerYcbcrConversionInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0ac2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0ac2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_0ac2ea01, "The spec valid usage text states 'subresourceRange must be a valid VkImageSubresourceRange structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-parameter)"}, - {VALIDATION_ERROR_0ac30801, "The spec valid usage text states 'viewType must be a valid VkImageViewType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-viewType-parameter)"}, - {VALIDATION_ERROR_0ae00536, "The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00667)"}, - {VALIDATION_ERROR_0ae00538, "The spec valid usage text states 'The memory from which fd was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-00668)"}, - {VALIDATION_ERROR_0ae0053a, "The spec valid usage text states 'If handleType is not 0, it must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00669)"}, - {VALIDATION_ERROR_0ae0053c, "The spec valid usage text states 'If handleType is not 0, fd must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00670)"}, - {VALIDATION_ERROR_0ae00be0, "The spec valid usage text states 'fd must obey any requirements listed for handleType in external memory handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-01520)"}, - {VALIDATION_ERROR_0ae00da4, "The spec valid usage text states 'The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in external-memory-handle-types-compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-01746)"}, - {VALIDATION_ERROR_0ae09c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_0ae2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0b000524, "The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658)"}, - {VALIDATION_ERROR_0b000526, "The spec valid usage text states 'The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659)"}, - {VALIDATION_ERROR_0b000528, "The spec valid usage text states 'If handleType is not 0, it must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660)"}, - {VALIDATION_ERROR_0b00052a, "The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661)"}, - {VALIDATION_ERROR_0b000b3e, "The spec valid usage text states 'If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439)"}, - {VALIDATION_ERROR_0b000b40, "The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440)"}, - {VALIDATION_ERROR_0b000b42, "The spec valid usage text states 'if handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441)"}, - {VALIDATION_ERROR_0b000bdc, "The spec valid usage text states 'If handle is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518)"}, - {VALIDATION_ERROR_0b000bde, "The spec valid usage text states 'If name is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-name-01519)"}, - {VALIDATION_ERROR_0b009c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_0b02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0b200a5e, "The spec valid usage text states 'handleType must not have more than one bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327)"}, - {VALIDATION_ERROR_0b200a60, "The spec valid usage text states 'handle must be a valid handle to memory, obtained as specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handle-01328)"}, - {VALIDATION_ERROR_0b209c01, "The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter)"}, - {VALIDATION_ERROR_0b22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-sType-sType)"}, - {VALIDATION_ERROR_0b4008ee, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreFdInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-01143)"}, - {VALIDATION_ERROR_0b400c10, "The spec valid usage text states 'fd must obey any requirements listed for handleType in external semaphore handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-fd-01544)"}, - {VALIDATION_ERROR_0b409001, "The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-flags-parameter)"}, - {VALIDATION_ERROR_0b409c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_0b41c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_0b42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0b42b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter)"}, - {VALIDATION_ERROR_0b6008e8, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140)"}, - {VALIDATION_ERROR_0b600b74, "The spec valid usage text states 'If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466)"}, - {VALIDATION_ERROR_0b600b76, "The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467)"}, - {VALIDATION_ERROR_0b600b78, "The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468)"}, - {VALIDATION_ERROR_0b600b7a, "The spec valid usage text states 'If handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469)"}, - {VALIDATION_ERROR_0b600c0c, "The spec valid usage text states 'If handle is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542)"}, - {VALIDATION_ERROR_0b600c0e, "The spec valid usage text states 'If name is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543)"}, - {VALIDATION_ERROR_0b609001, "The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter)"}, - {VALIDATION_ERROR_0b609c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_0b61c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_0b62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0b62b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter)"}, - {VALIDATION_ERROR_0b800a86, "The spec valid usage text states 'tokenCount must be greater than 0 and below VkDeviceGeneratedCommandsLimitsNVX::maxIndirectCommandsLayoutTokenCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347)"}, - {VALIDATION_ERROR_0b800a88, "The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, then pipelineBindPoint must not be VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348)"}, - {VALIDATION_ERROR_0b800a8a, "The spec valid usage text states 'If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX it must be the first element of the array and there must be only a single element of such token type.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349)"}, - {VALIDATION_ERROR_0b800a8c, "The spec valid usage text states 'All state binding tokens in pTokens must occur prior work provoking tokens (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01350)"}, - {VALIDATION_ERROR_0b800a8e, "The spec valid usage text states 'The content of pTokens must include one single work provoking token that is compatible with the pipelineBindPoint.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01351)"}, - {VALIDATION_ERROR_0b809001, "The spec valid usage text states 'flags must be a valid combination of VkIndirectCommandsLayoutUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter)"}, - {VALIDATION_ERROR_0b809003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask)"}, - {VALIDATION_ERROR_0b81c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pNext-pNext)"}, - {VALIDATION_ERROR_0b826001, "The spec valid usage text states 'pTokens must be a valid pointer to an array of tokenCount valid VkIndirectCommandsLayoutTokenNVX structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter)"}, - {VALIDATION_ERROR_0b827e01, "The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter)"}, - {VALIDATION_ERROR_0b82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-sType-sType)"}, - {VALIDATION_ERROR_0b82fc1b, "The spec valid usage text states 'tokenCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength)"}, - {VALIDATION_ERROR_0ba00a7c, "The spec valid usage text states 'bindingUnit must stay within device supported limits for the appropriate commands.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-bindingUnit-01342)"}, - {VALIDATION_ERROR_0ba00a7e, "The spec valid usage text states 'dynamicCount must stay within device supported limits for the appropriate commands.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-dynamicCount-01343)"}, - {VALIDATION_ERROR_0ba00a80, "The spec valid usage text states 'divisor must be greater than 0 and a power of two.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-divisor-01344)"}, - {VALIDATION_ERROR_0ba2fe01, "The spec valid usage text states 'tokenType must be a valid VkIndirectCommandsTokenTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsLayoutTokenNVX-tokenType-parameter)"}, - {VALIDATION_ERROR_0bc00a82, "The spec valid usage text states 'The buffer's usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-buffer-01345)"}, - {VALIDATION_ERROR_0bc00a84, "The spec valid usage text states 'The offset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minCommandsTokenBufferOffsetAlignment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-offset-01346)"}, - {VALIDATION_ERROR_0bc01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-buffer-parameter)"}, - {VALIDATION_ERROR_0bc2fe01, "The spec valid usage text states 'tokenType must be a valid VkIndirectCommandsTokenTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-tokenType-parameter)"}, - {VALIDATION_ERROR_0be09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0be0ee01, "The spec valid usage text states 'If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid VkApplicationInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pApplicationInfo-parameter)"}, - {VALIDATION_ERROR_0be1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT, VkDebugUtilsMessengerCreateInfoEXT, or VkValidationFlagsEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0be28e01, "The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter)"}, - {VALIDATION_ERROR_0be29001, "The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter)"}, - {VALIDATION_ERROR_0be2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0be2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_0c000a4a, "The spec valid usage text states 'pView must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317)"}, - {VALIDATION_ERROR_0c009005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask)"}, - {VALIDATION_ERROR_0c01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext)"}, - {VALIDATION_ERROR_0c02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType)"}, - {VALIDATION_ERROR_0c200558, "The spec valid usage text states 'memory must be currently mapped' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-memory-00684)"}, - {VALIDATION_ERROR_0c20055a, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, offset and size must specify a range contained within the currently mapped range of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-00685)"}, - {VALIDATION_ERROR_0c20055c, "The spec valid usage text states 'If size is equal to VK_WHOLE_SIZE, offset must be within the currently mapped range of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-00686)"}, - {VALIDATION_ERROR_0c20055e, "The spec valid usage text states 'offset must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-offset-00687)"}, - {VALIDATION_ERROR_0c200ada, "The spec valid usage text states 'If size is equal to VK_WHOLE_SIZE, the end of the current mapping of memory must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize bytes from the beginning of the memory object.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-01389)"}, - {VALIDATION_ERROR_0c200adc, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must either be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, or offset plus size must equal the size of memory.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-size-01390)"}, - {VALIDATION_ERROR_0c20c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-memory-parameter)"}, - {VALIDATION_ERROR_0c21c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-pNext-pNext)"}, - {VALIDATION_ERROR_0c22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMappedMemoryRange-sType-sType)"}, - {VALIDATION_ERROR_0c400546, "The spec valid usage text states 'If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must be a valid device mask.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675)"}, - {VALIDATION_ERROR_0c400548, "The spec valid usage text states 'If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676)"}, - {VALIDATION_ERROR_0c409001, "The spec valid usage text states 'flags must be a valid combination of VkMemoryAllocateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-flags-parameter)"}, - {VALIDATION_ERROR_0c42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfo-sType-sType)"}, - {VALIDATION_ERROR_0c6004fc, "The spec valid usage text states 'allocationSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00638)"}, - {VALIDATION_ERROR_0c6004fe, "The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfo, and any of the handle types specified in VkExportMemoryAllocateInfo::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2 in VkExternalImageFormatProperties::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferProperties::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of ifdef::VK_KHR_dedicated_allocation[VkMemoryDedicatedAllocateInfo]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00639)"}, - {VALIDATION_ERROR_0c600500, "The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfo, it must not contain an instance of VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00640)"}, - {VALIDATION_ERROR_0c600502, "The spec valid usage text states 'If the pNext chain contains an instance of VkImportMemoryWin32HandleInfoKHR, it must not contain an instance of VkImportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00641)"}, - {VALIDATION_ERROR_0c600506, "The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfo must match that specified when the memory object being imported was allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00643)"}, - {VALIDATION_ERROR_0c600508, "The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the memory was originally allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00644)"}, - {VALIDATION_ERROR_0c60050a, "The spec valid usage text states 'If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645)"}, - {VALIDATION_ERROR_0c60050c, "The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, allocationSize must match the size reported in the memory requirements of the image or buffer member of the instance of VkDedicatedAllocationMemoryAllocateInfoNV included in the pNext chain.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00646)"}, - {VALIDATION_ERROR_0c60050e, "The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00647)"}, - {VALIDATION_ERROR_0c600510, "The spec valid usage text states 'If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648)"}, - {VALIDATION_ERROR_0c600d9c, "The spec valid usage text states 'If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-01742)"}, - {VALIDATION_ERROR_0c600d9e, "The spec valid usage text states 'If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-01743)"}, - {VALIDATION_ERROR_0c600da0, "The spec valid usage text states 'If the parameters define an import operation and the external handle is a host pointer, the value of memoryTypeIndex must be one of those returned by vkGetMemoryHostPointerPropertiesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744)"}, - {VALIDATION_ERROR_0c600da2, "The spec valid usage text states 'If the parameters define an import operation and the external handle is a host pointer, allocationSize must be an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-01745)"}, - {VALIDATION_ERROR_0c600ea0, "The spec valid usage text states 'If the protected memory feature is not enabled, the VkMemoryAllocateInfo::memoryTypeIndex must not indicate a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872)"}, - {VALIDATION_ERROR_0c600ea2, "The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BIT_ANDROID:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-01873)"}, - {VALIDATION_ERROR_0c600ea4, "The spec valid usage text states 'If the parameters do not define an import operation, and the pNext chain contains an instance of VkExportMemoryAllocateInfo with VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID included in its handleTypes member, and the pNext contains an instance of VkMemoryDedicatedAllocateInfo with image not equal to VK_NULL_HANDLE, then allocationSize must be 0, otherwise allocationSize must be greater than 0.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-01874)"}, - {VALIDATION_ERROR_0c600ea6, "The spec valid usage text states 'If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-01875)"}, - {VALIDATION_ERROR_0c61c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkMemoryAllocateFlagsInfo, or VkMemoryDedicatedAllocateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0c62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-sType-sType)"}, - {VALIDATION_ERROR_0c62b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-sType-unique)"}, - {VALIDATION_ERROR_0c806801, "The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-dstAccessMask-parameter)"}, - {VALIDATION_ERROR_0c81c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-pNext-pNext)"}, - {VALIDATION_ERROR_0c82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-sType-sType)"}, - {VALIDATION_ERROR_0c82c401, "The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-srcAccessMask-parameter)"}, - {VALIDATION_ERROR_0ca009de, "The spec valid usage text states 'connection must point to a valid MirConnection.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-connection-01263)"}, - {VALIDATION_ERROR_0ca009e0, "The spec valid usage text states 'surface must point to a valid MirSurface.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-surface-01264)"}, - {VALIDATION_ERROR_0ca09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_0ca1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_0ca2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMirSurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_0cc00a96, "The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, pObjectEntryUsageFlags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-computeBindingPointSupport-01355)"}, - {VALIDATION_ERROR_0cc00a98, "The spec valid usage text states 'Any value within pObjectEntryCounts must not exceed VkDeviceGeneratedCommandsLimitsNVX::maxObjectEntryCounts' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-01356)"}, - {VALIDATION_ERROR_0cc00a9a, "The spec valid usage text states 'maxUniformBuffersPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxUniformBuffersPerDescriptor-01357)"}, - {VALIDATION_ERROR_0cc00a9c, "The spec valid usage text states 'maxStorageBuffersPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxStorageBuffersPerDescriptor-01358)"}, - {VALIDATION_ERROR_0cc00a9e, "The spec valid usage text states 'maxStorageImagesPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxStorageImagesPerDescriptor-01359)"}, - {VALIDATION_ERROR_0cc00aa0, "The spec valid usage text states 'maxSampledImagesPerDescriptor must be within the limits supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-maxSampledImagesPerDescriptor-01360)"}, - {VALIDATION_ERROR_0cc0d61b, "The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-objectCount-arraylength)"}, - {VALIDATION_ERROR_0cc1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pNext-pNext)"}, - {VALIDATION_ERROR_0cc1c601, "The spec valid usage text states 'pObjectEntryCounts must be a valid pointer to an array of objectCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-parameter)"}, - {VALIDATION_ERROR_0cc1c801, "The spec valid usage text states 'pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryTypes-parameter)"}, - {VALIDATION_ERROR_0cc1ca01, "The spec valid usage text states 'pObjectEntryUsageFlags must be a valid pointer to an array of objectCount valid combinations of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-parameter)"}, - {VALIDATION_ERROR_0cc1ca03, "The spec valid usage text states 'Each element of pObjectEntryUsageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-requiredbitmask)"}, - {VALIDATION_ERROR_0cc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableCreateInfoNVX-sType-sType)"}, - {VALIDATION_ERROR_0ce00009, "The spec valid usage text states 'Both of descriptorSet, and pipelineLayout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-commonparent)"}, - {VALIDATION_ERROR_0ce00ab2, "The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-type-01369)"}, - {VALIDATION_ERROR_0ce04801, "The spec valid usage text states 'descriptorSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-descriptorSet-parameter)"}, - {VALIDATION_ERROR_0ce09001, "The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-flags-parameter)"}, - {VALIDATION_ERROR_0ce09003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-flags-requiredbitmask)"}, - {VALIDATION_ERROR_0ce28201, "The spec valid usage text states 'pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-pipelineLayout-parameter)"}, - {VALIDATION_ERROR_0ce30401, "The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableDescriptorSetEntryNVX-type-parameter)"}, - {VALIDATION_ERROR_0d000aae, "The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, flags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-computeBindingPointSupport-01367)"}, - {VALIDATION_ERROR_0d009001, "The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-flags-parameter)"}, - {VALIDATION_ERROR_0d009003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-flags-requiredbitmask)"}, - {VALIDATION_ERROR_0d030401, "The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableEntryNVX-type-parameter)"}, - {VALIDATION_ERROR_0d200ab6, "The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-type-01371)"}, - {VALIDATION_ERROR_0d201a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter)"}, - {VALIDATION_ERROR_0d209001, "The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter)"}, - {VALIDATION_ERROR_0d209003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask)"}, - {VALIDATION_ERROR_0d20b201, "The spec valid usage text states 'indexType must be a valid VkIndexType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter)"}, - {VALIDATION_ERROR_0d230401, "The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-type-parameter)"}, - {VALIDATION_ERROR_0d400ab0, "The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-type-01368)"}, - {VALIDATION_ERROR_0d409001, "The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-flags-parameter)"}, - {VALIDATION_ERROR_0d409003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-flags-requiredbitmask)"}, - {VALIDATION_ERROR_0d427c01, "The spec valid usage text states 'pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-pipeline-parameter)"}, - {VALIDATION_ERROR_0d430401, "The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePipelineEntryNVX-type-parameter)"}, - {VALIDATION_ERROR_0d600ab8, "The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-type-01372)"}, - {VALIDATION_ERROR_0d609001, "The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-flags-parameter)"}, - {VALIDATION_ERROR_0d609003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-flags-requiredbitmask)"}, - {VALIDATION_ERROR_0d628201, "The spec valid usage text states 'pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-pipelineLayout-parameter)"}, - {VALIDATION_ERROR_0d62dc01, "The spec valid usage text states 'stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-stageFlags-parameter)"}, - {VALIDATION_ERROR_0d62dc03, "The spec valid usage text states 'stageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-stageFlags-requiredbitmask)"}, - {VALIDATION_ERROR_0d630401, "The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTablePushConstantEntryNVX-type-parameter)"}, - {VALIDATION_ERROR_0d800ab4, "The spec valid usage text states 'type must be VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-type-01370)"}, - {VALIDATION_ERROR_0d801a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-buffer-parameter)"}, - {VALIDATION_ERROR_0d809001, "The spec valid usage text states 'flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-flags-parameter)"}, - {VALIDATION_ERROR_0d809003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-flags-requiredbitmask)"}, - {VALIDATION_ERROR_0d830401, "The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-type-parameter)"}, - {VALIDATION_ERROR_0da2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_0dc09001, "The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter)"}, - {VALIDATION_ERROR_0dc09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter)"}, - {VALIDATION_ERROR_0dc1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0dc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType)"}, - {VALIDATION_ERROR_0dc30601, "The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter)"}, - {VALIDATION_ERROR_0dc30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask)"}, - {VALIDATION_ERROR_0de09c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter)"}, - {VALIDATION_ERROR_0de2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType)"}, - {VALIDATION_ERROR_0e009c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter)"}, - {VALIDATION_ERROR_0e01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0e02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType)"}, - {VALIDATION_ERROR_0e42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceFeatures2-sType-sType)"}, - {VALIDATION_ERROR_0e609001, "The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter)"}, - {VALIDATION_ERROR_0e609201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter)"}, - {VALIDATION_ERROR_0e61c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceExternalImageFormatInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext)"}, - {VALIDATION_ERROR_0e62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType)"}, - {VALIDATION_ERROR_0e62fa01, "The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter)"}, - {VALIDATION_ERROR_0e630401, "The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter)"}, - {VALIDATION_ERROR_0e630601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter)"}, - {VALIDATION_ERROR_0e630603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask)"}, - {VALIDATION_ERROR_0e800488, "The spec valid usage text states 'If multiviewGeometryShader is enabled then multiview must also be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580)"}, - {VALIDATION_ERROR_0e80048a, "The spec valid usage text states 'If multiviewTessellationShader is enabled then multiview must also be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581)"}, - {VALIDATION_ERROR_0e82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType)"}, - {VALIDATION_ERROR_0ea2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType)"}, - {VALIDATION_ERROR_0ec0088e, "The spec valid usage text states 'samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095)"}, - {VALIDATION_ERROR_0ec09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter)"}, - {VALIDATION_ERROR_0ec1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-pNext-pNext)"}, - {VALIDATION_ERROR_0ec2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType)"}, - {VALIDATION_ERROR_0ec2b401, "The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter)"}, - {VALIDATION_ERROR_0ec2fa01, "The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter)"}, - {VALIDATION_ERROR_0ec30401, "The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter)"}, - {VALIDATION_ERROR_0ec30601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter)"}, - {VALIDATION_ERROR_0ec30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask)"}, - {VALIDATION_ERROR_0ee1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext)"}, - {VALIDATION_ERROR_0ee2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType)"}, - {VALIDATION_ERROR_0ee2ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter)"}, - {VALIDATION_ERROR_0f000600, "The spec valid usage text states 'If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-initialDataSize-00768)"}, - {VALIDATION_ERROR_0f000602, "The spec valid usage text states 'If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-initialDataSize-00769)"}, - {VALIDATION_ERROR_0f009005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0f019601, "The spec valid usage text states 'If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-pInitialData-parameter)"}, - {VALIDATION_ERROR_0f01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0f02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineCacheCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0f2004c0, "The spec valid usage text states 'If the dual source blending feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608)"}, - {VALIDATION_ERROR_0f2004c2, "The spec valid usage text states 'If the dual source blending feature is not enabled, dstColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609)"}, - {VALIDATION_ERROR_0f2004c4, "The spec valid usage text states 'If the dual source blending feature is not enabled, srcAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610)"}, - {VALIDATION_ERROR_0f2004c6, "The spec valid usage text states 'If the dual source blending feature is not enabled, dstAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611)"}, - {VALIDATION_ERROR_0f200801, "The spec valid usage text states 'alphaBlendOp must be a valid VkBlendOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter)"}, - {VALIDATION_ERROR_0f200afc, "The spec valid usage text states 'If either of colorBlendOp or alphaBlendOp is an advanced blend operation, then colorBlendOp must equal alphaBlendOp' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406)"}, - {VALIDATION_ERROR_0f200afe, "The spec valid usage text states 'If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and colorBlendOp is an advanced blend operation, then colorBlendOp must be the same for all attachments.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407)"}, - {VALIDATION_ERROR_0f200b00, "The spec valid usage text states 'If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and alphaBlendOp is an advanced blend operation, then alphaBlendOp must be the same for all attachments.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408)"}, - {VALIDATION_ERROR_0f200b02, "The spec valid usage text states 'If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendAllOperations is VK_FALSE, then colorBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409)"}, - {VALIDATION_ERROR_0f200b04, "The spec valid usage text states 'If colorBlendOp or alphaBlendOp is an advanced blend operation, then VkSubpassDescription::colorAttachmentCount of the subpass this pipeline is compiled against must be less than or equal to VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendMaxColorAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410)"}, - {VALIDATION_ERROR_0f202001, "The spec valid usage text states 'colorBlendOp must be a valid VkBlendOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter)"}, - {VALIDATION_ERROR_0f202201, "The spec valid usage text states 'colorWriteMask must be a valid combination of VkColorComponentFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter)"}, - {VALIDATION_ERROR_0f206a01, "The spec valid usage text states 'dstAlphaBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter)"}, - {VALIDATION_ERROR_0f207001, "The spec valid usage text states 'dstColorBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter)"}, - {VALIDATION_ERROR_0f22c601, "The spec valid usage text states 'srcAlphaBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter)"}, - {VALIDATION_ERROR_0f22cc01, "The spec valid usage text states 'srcColorBlendFactor must be a valid VkBlendFactor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter)"}, - {VALIDATION_ERROR_0f4004ba, "The spec valid usage text states 'If the independent blending feature is not enabled, all elements of pAttachments must be identical' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605)"}, - {VALIDATION_ERROR_0f4004bc, "The spec valid usage text states 'If the logic operations feature is not enabled, logicOpEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606)"}, - {VALIDATION_ERROR_0f4004be, "The spec valid usage text states 'If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607)"}, - {VALIDATION_ERROR_0f409005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0f40f201, "The spec valid usage text states 'If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter)"}, - {VALIDATION_ERROR_0f41c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0f42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0f6004ac, "The spec valid usage text states 'If the depth bounds testing feature is not enabled, depthBoundsTestEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598)"}, - {VALIDATION_ERROR_0f601201, "The spec valid usage text states 'back must be a valid VkStencilOpState structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter)"}, - {VALIDATION_ERROR_0f604001, "The spec valid usage text states 'depthCompareOp must be a valid VkCompareOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter)"}, - {VALIDATION_ERROR_0f609005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0f609601, "The spec valid usage text states 'front must be a valid VkStencilOpState structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter)"}, - {VALIDATION_ERROR_0f61c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0f62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0f80048c, "The spec valid usage text states 'discardRectangleCount must be between 0 and VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582)"}, - {VALIDATION_ERROR_0f805e01, "The spec valid usage text states 'discardRectangleMode must be a valid VkDiscardRectangleModeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter)"}, - {VALIDATION_ERROR_0f809005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask)"}, - {VALIDATION_ERROR_0f82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_0fa00b44, "The spec valid usage text states 'Each element of pDynamicStates must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442)"}, - {VALIDATION_ERROR_0fa07c1b, "The spec valid usage text states 'dynamicStateCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-dynamicStateCount-arraylength)"}, - {VALIDATION_ERROR_0fa09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0fa15801, "The spec valid usage text states 'pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter)"}, - {VALIDATION_ERROR_0fa1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0fa2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0fc00358, "The spec valid usage text states 'If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, primitiveRestartEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428)"}, - {VALIDATION_ERROR_0fc0035a, "The spec valid usage text states 'If the geometry shaders feature is not enabled, topology must not be any of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429)"}, - {VALIDATION_ERROR_0fc0035c, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, topology must not be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430)"}, - {VALIDATION_ERROR_0fc09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0fc1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0fc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_0fc30001, "The spec valid usage text states 'topology must be a valid VkPrimitiveTopology value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter)"}, - {VALIDATION_ERROR_0fe0023c, "The spec valid usage text states 'setLayoutCount must be less than or equal to VkPhysicalDeviceLimits::maxBoundDescriptorSets' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286)"}, - {VALIDATION_ERROR_0fe0023e, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00287)"}, - {VALIDATION_ERROR_0fe00240, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00288)"}, - {VALIDATION_ERROR_0fe00242, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00289)"}, - {VALIDATION_ERROR_0fe00244, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00290)"}, - {VALIDATION_ERROR_0fe00246, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00291)"}, - {VALIDATION_ERROR_0fe00248, "The spec valid usage text states 'Any two elements of pPushConstantRanges must not include the same stage in stageFlags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292)"}, - {VALIDATION_ERROR_0fe0024a, "The spec valid usage text states 'pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293)"}, - {VALIDATION_ERROR_0fe00d18, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01676)"}, - {VALIDATION_ERROR_0fe00d1a, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01677)"}, - {VALIDATION_ERROR_0fe00d1c, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stagess and and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01678)"}, - {VALIDATION_ERROR_0fe00d1e, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01679)"}, - {VALIDATION_ERROR_0fe00d20, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01680)"}, - {VALIDATION_ERROR_0fe00d22, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01681)"}, - {VALIDATION_ERROR_0fe00d24, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01682)"}, - {VALIDATION_ERROR_0fe00d26, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01683)"}, - {VALIDATION_ERROR_0fe00d28, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01684)"}, - {VALIDATION_ERROR_0fe01790, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03016)"}, - {VALIDATION_ERROR_0fe01792, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03017)"}, - {VALIDATION_ERROR_0fe01794, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03018)"}, - {VALIDATION_ERROR_0fe01796, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03019)"}, - {VALIDATION_ERROR_0fe01798, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03020)"}, - {VALIDATION_ERROR_0fe0179a, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03021)"}, - {VALIDATION_ERROR_0fe0179c, "The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03022)"}, - {VALIDATION_ERROR_0fe0179e, "The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03023)"}, - {VALIDATION_ERROR_0fe017a0, "The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03024)"}, - {VALIDATION_ERROR_0fe017a2, "The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03025)"}, - {VALIDATION_ERROR_0fe017a4, "The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03026)"}, - {VALIDATION_ERROR_0fe017a6, "The spec valid usage text states 'The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03027)"}, - {VALIDATION_ERROR_0fe017a8, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03028)"}, - {VALIDATION_ERROR_0fe017aa, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stagess and and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03029)"}, - {VALIDATION_ERROR_0fe017ac, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03030)"}, - {VALIDATION_ERROR_0fe017ae, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03031)"}, - {VALIDATION_ERROR_0fe017b0, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03032)"}, - {VALIDATION_ERROR_0fe017b2, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03033)"}, - {VALIDATION_ERROR_0fe017b4, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03034)"}, - {VALIDATION_ERROR_0fe017b6, "The spec valid usage text states 'The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-descriptorType-03035)"}, - {VALIDATION_ERROR_0fe017b8, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSamplers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036)"}, - {VALIDATION_ERROR_0fe017ba, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stagess and and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037)"}, - {VALIDATION_ERROR_0fe017bc, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038)"}, - {VALIDATION_ERROR_0fe017be, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039)"}, - {VALIDATION_ERROR_0fe017c0, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040)"}, - {VALIDATION_ERROR_0fe017c2, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSampledImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041)"}, - {VALIDATION_ERROR_0fe017c4, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageImages' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042)"}, - {VALIDATION_ERROR_0fe017c6, "The spec valid usage text states 'The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindInputAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043)"}, - {VALIDATION_ERROR_0fe09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_0fe1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_0fe1f801, "The spec valid usage text states 'If pushConstantRangeCount is not 0, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter)"}, - {VALIDATION_ERROR_0fe22c01, "The spec valid usage text states 'If setLayoutCount is not 0, pSetLayouts must be a valid pointer to an array of setLayoutCount valid VkDescriptorSetLayout handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter)"}, - {VALIDATION_ERROR_0fe2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineLayoutCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_10000620, "The spec valid usage text states 'If the sample rate shading feature is not enabled, sampleShadingEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784)"}, - {VALIDATION_ERROR_10000622, "The spec valid usage text states 'If the alpha to one feature is not enabled, alphaToOneEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785)"}, - {VALIDATION_ERROR_10000624, "The spec valid usage text states 'minSampleShading must be in the range [0,1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786)"}, - {VALIDATION_ERROR_10000b0e, "The spec valid usage text states 'If the subpass has any color attachments and rasterizationSamples is greater than the number of color samples, then sampleShadingEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415)"}, - {VALIDATION_ERROR_10009005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_1001c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, or VkPipelineSampleLocationsStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_10022201, "The spec valid usage text states 'If pSampleMask is not NULL, pSampleMask must be a valid pointer to an array of (lceil{mathit{rasterizationSamples} over 32}rceil) VkSampleMask values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter)"}, - {VALIDATION_ERROR_1002a801, "The spec valid usage text states 'rasterizationSamples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter)"}, - {VALIDATION_ERROR_1002b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_1002b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineMultisampleStateCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_1020061c, "The spec valid usage text states 'If the depth clamping feature is not enabled, depthClampEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782)"}, - {VALIDATION_ERROR_10200b0a, "The spec valid usage text states 'If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413)"}, - {VALIDATION_ERROR_10200b0c, "The spec valid usage text states 'If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414)"}, - {VALIDATION_ERROR_10200bc6, "The spec valid usage text states 'If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507)"}, - {VALIDATION_ERROR_10203a01, "The spec valid usage text states 'cullMode must be a valid combination of VkCullModeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter)"}, - {VALIDATION_ERROR_10209005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_10209801, "The spec valid usage text states 'frontFace must be a valid VkFrontFace value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter)"}, - {VALIDATION_ERROR_1021c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT or VkPipelineRasterizationStateRasterizationOrderAMD' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_10228601, "The spec valid usage text states 'polygonMode must be a valid VkPolygonMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter)"}, - {VALIDATION_ERROR_1022b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_1022b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_1042a601, "The spec valid usage text states 'rasterizationOrder must be a valid VkRasterizationOrderAMD value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter)"}, - {VALIDATION_ERROR_1042b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType)"}, - {VALIDATION_ERROR_10600580, "The spec valid usage text states 'If the geometry shaders feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00704)"}, - {VALIDATION_ERROR_10600582, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00705)"}, - {VALIDATION_ERROR_10600584, "The spec valid usage text states 'stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00706)"}, - {VALIDATION_ERROR_10600586, "The spec valid usage text states 'pName must be the name of an OpEntryPoint in module with an execution model that matches stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pName-00707)"}, - {VALIDATION_ERROR_10600588, "The spec valid usage text states 'If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708)"}, - {VALIDATION_ERROR_1060058a, "The spec valid usage text states 'If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709)"}, - {VALIDATION_ERROR_1060058c, "The spec valid usage text states 'If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710)"}, - {VALIDATION_ERROR_1060058e, "The spec valid usage text states 'If the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711)"}, - {VALIDATION_ERROR_10600590, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00712)"}, - {VALIDATION_ERROR_10600592, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction that specifies a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00713)"}, - {VALIDATION_ERROR_10600594, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00714)"}, - {VALIDATION_ERROR_10600596, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00715)"}, - {VALIDATION_ERROR_10600598, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00716)"}, - {VALIDATION_ERROR_1060059a, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00717)"}, - {VALIDATION_ERROR_1060059c, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00718)"}, - {VALIDATION_ERROR_1060059e, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, it must write to FragDepth in all execution paths' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00719)"}, - {VALIDATION_ERROR_10600bce, "The spec valid usage text states 'If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragStencilRefEXT in any execution path, it must write to FragStencilRefEXT in all execution paths' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-01511)"}, - {VALIDATION_ERROR_10609005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_1060d201, "The spec valid usage text states 'module must be a valid VkShaderModule handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-module-parameter)"}, - {VALIDATION_ERROR_1061c001, "The spec valid usage text states 'pName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pName-parameter)"}, - {VALIDATION_ERROR_1061c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_10623a01, "The spec valid usage text states 'If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter)"}, - {VALIDATION_ERROR_1062b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_1062d801, "The spec valid usage text states 'stage must be a valid VkShaderStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-parameter)"}, - {VALIDATION_ERROR_1080097c, "The spec valid usage text states 'patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214)"}, - {VALIDATION_ERROR_10809005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_1081c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineTessellationDomainOriginStateCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_1082b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_10a004ca, "The spec valid usage text states 'vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613)"}, - {VALIDATION_ERROR_10a004cc, "The spec valid usage text states 'vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614)"}, - {VALIDATION_ERROR_10a004ce, "The spec valid usage text states 'For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription must exist in pVertexBindingDescriptions with the same value of binding' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-binding-00615)"}, - {VALIDATION_ERROR_10a004d0, "The spec valid usage text states 'All elements of pVertexBindingDescriptions must describe distinct binding numbers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616)"}, - {VALIDATION_ERROR_10a004d2, "The spec valid usage text states 'All elements of pVertexAttributeDescriptions must describe distinct attribute locations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617)"}, - {VALIDATION_ERROR_10a09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_10a1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineVertexInputDivisorStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_10a26401, "The spec valid usage text states 'If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter)"}, - {VALIDATION_ERROR_10a26601, "The spec valid usage text states 'If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter)"}, - {VALIDATION_ERROR_10a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineVertexInputStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_10c00980, "The spec valid usage text states 'If the multiple viewports feature is not enabled, viewportCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216)"}, - {VALIDATION_ERROR_10c00982, "The spec valid usage text states 'If the multiple viewports feature is not enabled, scissorCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217)"}, - {VALIDATION_ERROR_10c00984, "The spec valid usage text states 'viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218)"}, - {VALIDATION_ERROR_10c00986, "The spec valid usage text states 'scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219)"}, - {VALIDATION_ERROR_10c00988, "The spec valid usage text states 'scissorCount and viewportCount must be identical' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220)"}, - {VALIDATION_ERROR_10c00d7c, "The spec valid usage text states 'If the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure chained to the pNext chain is VK_TRUE, the viewportCount member of the VkPipelineViewportWScalingStateCreateInfoNV structure must be equal to viewportCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726)"}, - {VALIDATION_ERROR_10c09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_10c1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineViewportSwizzleStateCreateInfoNV or VkPipelineViewportWScalingStateCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_10c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_10c2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_10c2b61b, "The spec valid usage text states 'scissorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength)"}, - {VALIDATION_ERROR_10c30a1b, "The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength)"}, - {VALIDATION_ERROR_10e0097e, "The spec valid usage text states 'viewportCount must match the viewportCount set in VkPipelineViewportStateCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215)"}, - {VALIDATION_ERROR_10e09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-flags-zerobitmask)"}, - {VALIDATION_ERROR_10e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_10e30a1b, "The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength)"}, - {VALIDATION_ERROR_1102b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_11030a1b, "The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength)"}, - {VALIDATION_ERROR_11200009, "The spec valid usage text states 'Both of the elements of pSwapchains, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-commonparent)"}, - {VALIDATION_ERROR_11200a20, "The spec valid usage text states 'Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR layout at the time the operation is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPresentInfoKHR-pImageIndices-01296)"}, - {VALIDATION_ERROR_11200b2c, "The spec valid usage text states 'Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pImageIndices-01430)"}, - {VALIDATION_ERROR_11218801, "The spec valid usage text states 'pImageIndices must be a valid pointer to an array of swapchainCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pImageIndices-parameter)"}, - {VALIDATION_ERROR_1121c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupPresentInfoKHR, VkDisplayPresentInfoKHR, VkPresentRegionsKHR, or VkPresentTimesInfoGOOGLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_11221e01, "The spec valid usage text states 'If pResults is not NULL, pResults must be a valid pointer to an array of swapchainCount VkResult values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pResults-parameter)"}, - {VALIDATION_ERROR_11225801, "The spec valid usage text states 'pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pSwapchains-parameter)"}, - {VALIDATION_ERROR_11227601, "The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-pWaitSemaphores-parameter)"}, - {VALIDATION_ERROR_1122b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_1122b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-sType-unique)"}, - {VALIDATION_ERROR_1122f21b, "The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentInfoKHR-swapchainCount-arraylength)"}, - {VALIDATION_ERROR_11420c01, "The spec valid usage text states 'If rectangleCount is not 0, and pRectangles is not NULL, pRectangles must be a valid pointer to an array of rectangleCount VkRectLayerKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionKHR-pRectangles-parameter)"}, - {VALIDATION_ERROR_116009d8, "The spec valid usage text states 'swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext-chain of this VkPresentRegionsKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-swapchainCount-01260)"}, - {VALIDATION_ERROR_11621001, "The spec valid usage text states 'If pRegions is not NULL, pRegions must be a valid pointer to an array of swapchainCount valid VkPresentRegionKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-pRegions-parameter)"}, - {VALIDATION_ERROR_1162b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-sType-sType)"}, - {VALIDATION_ERROR_1162f21b, "The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentRegionsKHR-swapchainCount-arraylength)"}, - {VALIDATION_ERROR_118009be, "The spec valid usage text states 'swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext chain of this VkPresentTimesInfoGOOGLE structure.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247)"}, - {VALIDATION_ERROR_11825e01, "The spec valid usage text states 'If pTimes is not NULL, pTimes must be a valid pointer to an array of swapchainCount VkPresentTimeGOOGLE structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-pTimes-parameter)"}, - {VALIDATION_ERROR_1182b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-sType-sType)"}, - {VALIDATION_ERROR_1182f21b, "The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPresentTimesInfoGOOGLE-swapchainCount-arraylength)"}, - {VALIDATION_ERROR_11a0024c, "The spec valid usage text states 'offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-offset-00294)"}, - {VALIDATION_ERROR_11a0024e, "The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-offset-00295)"}, - {VALIDATION_ERROR_11a00250, "The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-size-00296)"}, - {VALIDATION_ERROR_11a00252, "The spec valid usage text states 'size must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-size-00297)"}, - {VALIDATION_ERROR_11a00254, "The spec valid usage text states 'size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-size-00298)"}, - {VALIDATION_ERROR_11a2dc01, "The spec valid usage text states 'stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-stageFlags-parameter)"}, - {VALIDATION_ERROR_11a2dc03, "The spec valid usage text states 'stageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPushConstantRange-stageFlags-requiredbitmask)"}, - {VALIDATION_ERROR_11c0062e, "The spec valid usage text states 'If the pipeline statistics queries feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-00791)"}, - {VALIDATION_ERROR_11c00630, "The spec valid usage text states 'If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-00792)"}, - {VALIDATION_ERROR_11c09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_11c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_11c29a01, "The spec valid usage text states 'queryType must be a valid VkQueryType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-parameter)"}, - {VALIDATION_ERROR_11c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueryPoolCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_11e009da, "The spec valid usage text states 'The sum of offset and extent must be no greater than the imageExtent member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRectLayerKHR-offset-01261)"}, - {VALIDATION_ERROR_11e009dc, "The spec valid usage text states 'layer must be less than imageArrayLayers member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRectLayerKHR-layer-01262)"}, - {VALIDATION_ERROR_12000009, "The spec valid usage text states 'Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-commonparent)"}, - {VALIDATION_ERROR_1200070c, "The spec valid usage text states 'clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-clearValueCount-00902)"}, - {VALIDATION_ERROR_1200070e, "The spec valid usage text states 'If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount valid VkClearValue unions' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-clearValueCount-00903)"}, - {VALIDATION_ERROR_12000710, "The spec valid usage text states 'renderPass must be compatible with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-renderPass-00904)"}, - {VALIDATION_ERROR_12009401, "The spec valid usage text states 'framebuffer must be a valid VkFramebuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-parameter)"}, - {VALIDATION_ERROR_1201c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo or VkRenderPassSampleLocationsBeginInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-pNext-pNext)"}, - {VALIDATION_ERROR_1202ae01, "The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-renderPass-parameter)"}, - {VALIDATION_ERROR_1202b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-sType-sType)"}, - {VALIDATION_ERROR_1202b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassBeginInfo-sType-unique)"}, - {VALIDATION_ERROR_12200680, "The spec valid usage text states 'If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-None-00832)"}, - {VALIDATION_ERROR_12200682, "The spec valid usage text states 'If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-attachment-00833)"}, - {VALIDATION_ERROR_12200684, "The spec valid usage text states 'If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-attachment-00834)"}, - {VALIDATION_ERROR_12200686, "The spec valid usage text states 'The value of each element of the pPreserveAttachments member in each element of pSubpasses must not be VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pPreserveAttachments-00835)"}, - {VALIDATION_ERROR_12200688, "The spec valid usage text states 'For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-00836)"}, - {VALIDATION_ERROR_1220068a, "The spec valid usage text states 'For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-00837)"}, - {VALIDATION_ERROR_1220068c, "The spec valid usage text states 'For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-00838)"}, - {VALIDATION_ERROR_12200c3c, "The spec valid usage text states 'For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-01566)"}, - {VALIDATION_ERROR_12200c3e, "The spec valid usage text states 'For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-01567)"}, - {VALIDATION_ERROR_12200f0c, "The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the subpass member of each element of its pAspectReferences member must be less than subpassCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01926)"}, - {VALIDATION_ERROR_12200f0e, "The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the member of pSubpasses identified by its subpass member' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01927)"}, - {VALIDATION_ERROR_12200f10, "The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, and its subpassCount member is not zero, that member must be equal to the value of subpassCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01928)"}, - {VALIDATION_ERROR_12200f12, "The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, if its dependencyCount member is not zero, it must be equal to dependencyCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01929)"}, - {VALIDATION_ERROR_12200f14, "The spec valid usage text states 'If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01930)"}, - {VALIDATION_ERROR_12209005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_1220f201, "The spec valid usage text states 'If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-parameter)"}, - {VALIDATION_ERROR_12212601, "The spec valid usage text states 'If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-parameter)"}, - {VALIDATION_ERROR_1221c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassInputAttachmentAspectCreateInfo or VkRenderPassMultiviewCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_12224201, "The spec valid usage text states 'pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pSubpasses-parameter)"}, - {VALIDATION_ERROR_1222b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_1222b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_1222e61b, "The spec valid usage text states 'subpassCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-subpassCount-arraylength)"}, - {VALIDATION_ERROR_12400692, "The spec valid usage text states 'Each view index must not be set in more than one element of pCorrelationMasks' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841)"}, - {VALIDATION_ERROR_12411a01, "The spec valid usage text states 'If correlationMaskCount is not 0, pCorrelationMasks must be a valid pointer to an array of correlationMaskCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter)"}, - {VALIDATION_ERROR_12426c01, "The spec valid usage text states 'If subpassCount is not 0, pViewMasks must be a valid pointer to an array of subpassCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter)"}, - {VALIDATION_ERROR_12426e01, "The spec valid usage text states 'If dependencyCount is not 0, pViewOffsets must be a valid pointer to an array of dependencyCount int32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter)"}, - {VALIDATION_ERROR_1242b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassMultiviewCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_12600201, "The spec valid usage text states 'addressModeU must be a valid VkSamplerAddressMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-parameter)"}, - {VALIDATION_ERROR_12600401, "The spec valid usage text states 'addressModeV must be a valid VkSamplerAddressMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeV-parameter)"}, - {VALIDATION_ERROR_12600601, "The spec valid usage text states 'addressModeW must be a valid VkSamplerAddressMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeW-parameter)"}, - {VALIDATION_ERROR_1260085a, "The spec valid usage text states 'The absolute value of mipLodBias must be less than or equal to VkPhysicalDeviceLimits::maxSamplerLodBias' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-mipLodBias-01069)"}, - {VALIDATION_ERROR_1260085c, "The spec valid usage text states 'If the anisotropic sampling feature is not enabled, anisotropyEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-anisotropyEnable-01070)"}, - {VALIDATION_ERROR_1260085e, "The spec valid usage text states 'If anisotropyEnable is VK_TRUE, maxAnisotropy must be between 1.0 and VkPhysicalDeviceLimits::maxSamplerAnisotropy, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-anisotropyEnable-01071)"}, - {VALIDATION_ERROR_12600860, "The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, minFilter and magFilter must be equal' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072)"}, - {VALIDATION_ERROR_12600862, "The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073)"}, - {VALIDATION_ERROR_12600864, "The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, minLod and maxLod must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074)"}, - {VALIDATION_ERROR_12600866, "The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075)"}, - {VALIDATION_ERROR_12600868, "The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, anisotropyEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076)"}, - {VALIDATION_ERROR_1260086a, "The spec valid usage text states 'If unnormalizedCoordinates is VK_TRUE, compareEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077)"}, - {VALIDATION_ERROR_1260086c, "The spec valid usage text states 'If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a valid VkBorderColor value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-01078)"}, - {VALIDATION_ERROR_1260086e, "The spec valid usage text states 'If the VK_KHR_sampler_mirror_clamp_to_edge extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-01079)"}, - {VALIDATION_ERROR_12600870, "The spec valid usage text states 'If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-compareEnable-01080)"}, - {VALIDATION_ERROR_12600872, "The spec valid usage text states 'If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, anisotropyEnable must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-magFilter-01081)"}, - {VALIDATION_ERROR_12600b1c, "The spec valid usage text states 'If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-magFilter-01422)"}, - {VALIDATION_ERROR_12600b1e, "The spec valid usage text states 'If compareEnable is VK_TRUE, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-compareEnable-01423)"}, - {VALIDATION_ERROR_12600cda, "The spec valid usage text states 'If sampler Y'CBCR conversion is enabled and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT is not set for the format, minFilter and magFilter must be equal to the sampler Y'CBCR conversion's chromaFilter' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-minFilter-01645)"}, - {VALIDATION_ERROR_12600cdc, "The spec valid usage text states 'If sampler Y'CBCR conversion is enabled, addressModeU, addressModeV, and addressModeW must be VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE, and unnormalizedCoordinates must be VK_FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-addressModeU-01646)"}, - {VALIDATION_ERROR_12600cde, "The spec valid usage text states 'The sampler reduction mode must be set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT if sampler Y'CBCR conversion is enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerCreateInfo-None-01647)"}, - {VALIDATION_ERROR_12609005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_1260c401, "The spec valid usage text states 'magFilter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-magFilter-parameter)"}, - {VALIDATION_ERROR_1260ca01, "The spec valid usage text states 'minFilter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-minFilter-parameter)"}, - {VALIDATION_ERROR_1260cc01, "The spec valid usage text states 'mipmapMode must be a valid VkSamplerMipmapMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-mipmapMode-parameter)"}, - {VALIDATION_ERROR_1261c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSamplerReductionModeCreateInfoEXT or VkSamplerYcbcrConversionInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_1262b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_1262b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_12809005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_1281c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportSemaphoreCreateInfo or VkExportSemaphoreWin32HandleInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_1282b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_1282b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-sType-unique)"}, - {VALIDATION_ERROR_12a0087a, "The spec valid usage text states 'codeSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01085)"}, - {VALIDATION_ERROR_12a0087c, "The spec valid usage text states 'codeSize must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01086)"}, - {VALIDATION_ERROR_12a0087e, "The spec valid usage text states 'pCode must point to valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01087)"}, - {VALIDATION_ERROR_12a00880, "The spec valid usage text states 'pCode must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01088)"}, - {VALIDATION_ERROR_12a00882, "The spec valid usage text states 'pCode must declare the Shader capability for SPIR-V code' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01089)"}, - {VALIDATION_ERROR_12a00884, "The spec valid usage text states 'pCode must not declare any capability that is not supported by the API, as described by the Capabilities section of the SPIR-V Environment appendix' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01090)"}, - {VALIDATION_ERROR_12a00886, "The spec valid usage text states 'If pCode declares any of the capabilities listed as optional in the SPIR-V Environment appendix, the corresponding feature(s) must be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01091)"}, - {VALIDATION_ERROR_12a00ac0, "The spec valid usage text states 'If pCode points to SPIR-V code, codeSize must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01376)"}, - {VALIDATION_ERROR_12a00ac2, "The spec valid usage text states 'pCode must point to either valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification or valid GLSL code which must be written to the GL_KHR_vulkan_glsl extension specification' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01377)"}, - {VALIDATION_ERROR_12a00ac4, "The spec valid usage text states 'If pCode points to SPIR-V code, that code must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01378)"}, - {VALIDATION_ERROR_12a00ac6, "The spec valid usage text states 'If pCode points to GLSL code, it must be valid GLSL code written to the GL_KHR_vulkan_glsl GLSL extension specification' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01379)"}, - {VALIDATION_ERROR_12a09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_12a10c01, "The spec valid usage text states 'pCode must be a valid pointer to an array of (codeSize over 4) uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-parameter)"}, - {VALIDATION_ERROR_12a1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkShaderModuleValidationCacheCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_12a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_12c0141b, "The spec valid usage text states 'bindCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseBufferMemoryBindInfo-bindCount-arraylength)"}, - {VALIDATION_ERROR_12c01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseBufferMemoryBindInfo-buffer-parameter)"}, - {VALIDATION_ERROR_12c0fe01, "The spec valid usage text states 'pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseBufferMemoryBindInfo-pBinds-parameter)"}, - {VALIDATION_ERROR_12e008a0, "The spec valid usage text states 'If the sparse aliased residency feature is not enabled, and if any other resources are bound to ranges of memory, the range of memory being bound must not overlap with those bound ranges' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-memory-01104)"}, - {VALIDATION_ERROR_12e008a2, "The spec valid usage text states 'memory and memoryOffset must match the memory requirements of the calling command's image, as described in section resources-association' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-memory-01105)"}, - {VALIDATION_ERROR_12e008a4, "The spec valid usage text states 'subresource must be a valid image subresource for image (see resources-image-views)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-subresource-01106)"}, - {VALIDATION_ERROR_12e008a6, "The spec valid usage text states 'offset.x must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-offset-01107)"}, - {VALIDATION_ERROR_12e008a8, "The spec valid usage text states 'extent.width must either be a multiple of the sparse image block width of the image, or else (extent.width + offset.x) must equal the width of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-extent-01108)"}, - {VALIDATION_ERROR_12e008aa, "The spec valid usage text states 'offset.y must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-offset-01109)"}, - {VALIDATION_ERROR_12e008ac, "The spec valid usage text states 'extent.height must either be a multiple of the sparse image block height of the image, or else (extent.height + offset.y) must equal the height of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-extent-01110)"}, - {VALIDATION_ERROR_12e008ae, "The spec valid usage text states 'offset.z must be a multiple of the sparse image block depth (VkSparseImageFormatProperties::imageGranularity.depth) of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-offset-01111)"}, - {VALIDATION_ERROR_12e008b0, "The spec valid usage text states 'extent.depth must either be a multiple of the sparse image block depth of the image, or else (extent.depth + offset.z) must equal the depth of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-extent-01112)"}, - {VALIDATION_ERROR_12e09001, "The spec valid usage text states 'flags must be a valid combination of VkSparseMemoryBindFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-flags-parameter)"}, - {VALIDATION_ERROR_12e0c601, "The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-memory-parameter)"}, - {VALIDATION_ERROR_12e2e801, "The spec valid usage text states 'subresource must be a valid VkImageSubresource structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBind-subresource-parameter)"}, - {VALIDATION_ERROR_13000d74, "The spec valid usage text states 'The subresource.mipLevel member of each element of pBinds must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-subresource-01722)"}, - {VALIDATION_ERROR_13000d76, "The spec valid usage text states 'The subresource.arrayLayer member of each element of pBinds must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-subresource-01723)"}, - {VALIDATION_ERROR_1300141b, "The spec valid usage text states 'bindCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-bindCount-arraylength)"}, - {VALIDATION_ERROR_1300a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-image-parameter)"}, - {VALIDATION_ERROR_1300fe01, "The spec valid usage text states 'pBinds must be a valid pointer to an array of bindCount valid VkSparseImageMemoryBind structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageMemoryBindInfo-pBinds-parameter)"}, - {VALIDATION_ERROR_1320089e, "The spec valid usage text states 'If the flags member of any element of pBinds contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must be within the mip tail region of the metadata aspect of image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103)"}, - {VALIDATION_ERROR_1320141b, "The spec valid usage text states 'bindCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-bindCount-arraylength)"}, - {VALIDATION_ERROR_1320a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter)"}, - {VALIDATION_ERROR_1320fe01, "The spec valid usage text states 'pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-parameter)"}, - {VALIDATION_ERROR_13400890, "The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory and memoryOffset must match the memory requirements of the resource, as described in section resources-association' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memory-01096)"}, - {VALIDATION_ERROR_13400892, "The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must not have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memory-01097)"}, - {VALIDATION_ERROR_13400894, "The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-size-01098)"}, - {VALIDATION_ERROR_13400896, "The spec valid usage text states 'resourceOffset must be less than the size of the resource' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-resourceOffset-01099)"}, - {VALIDATION_ERROR_13400898, "The spec valid usage text states 'size must be less than or equal to the size of the resource minus resourceOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-size-01100)"}, - {VALIDATION_ERROR_1340089a, "The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memoryOffset-01101)"}, - {VALIDATION_ERROR_1340089c, "The spec valid usage text states 'size must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-size-01102)"}, - {VALIDATION_ERROR_13409001, "The spec valid usage text states 'flags must be a valid combination of VkSparseMemoryBindFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-flags-parameter)"}, - {VALIDATION_ERROR_1340c601, "The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseMemoryBind-memory-parameter)"}, - {VALIDATION_ERROR_1360060a, "The spec valid usage text states 'The offset member of each element of pMapEntries must be less than dataSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-offset-00773)"}, - {VALIDATION_ERROR_1360060c, "The spec valid usage text states 'The size member of each element of pMapEntries must be less than or equal to dataSize minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-pMapEntries-00774)"}, - {VALIDATION_ERROR_1360060e, "The spec valid usage text states 'If mapEntryCount is not 0, pMapEntries must be a valid pointer to an array of mapEntryCount valid VkSpecializationMapEntry structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-mapEntryCount-00775)"}, - {VALIDATION_ERROR_13612201, "The spec valid usage text states 'If dataSize is not 0, pData must be a valid pointer to an array of dataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationInfo-pData-parameter)"}, - {VALIDATION_ERROR_13800610, "The spec valid usage text states 'For a constantID specialization constant declared in a shader, size must match the byte size of the constantID. If the specialization constant is of type boolean, size must be the byte size of VkBool32' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSpecializationMapEntry-constantID-00776)"}, - {VALIDATION_ERROR_13a02a01, "The spec valid usage text states 'compareOp must be a valid VkCompareOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-compareOp-parameter)"}, - {VALIDATION_ERROR_13a04201, "The spec valid usage text states 'depthFailOp must be a valid VkStencilOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-depthFailOp-parameter)"}, - {VALIDATION_ERROR_13a08601, "The spec valid usage text states 'failOp must be a valid VkStencilOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-failOp-parameter)"}, - {VALIDATION_ERROR_13a27801, "The spec valid usage text states 'passOp must be a valid VkStencilOp value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkStencilOpState-passOp-parameter)"}, - {VALIDATION_ERROR_13c00009, "The spec valid usage text states 'Each of the elements of pCommandBuffers, the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-commonparent)"}, - {VALIDATION_ERROR_13c00096, "The spec valid usage text states 'Each element of pCommandBuffers must not have been allocated with VK_COMMAND_BUFFER_LEVEL_SECONDARY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pCommandBuffers-00075)"}, - {VALIDATION_ERROR_13c00098, "The spec valid usage text states 'If the geometry shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00076)"}, - {VALIDATION_ERROR_13c0009a, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00077)"}, - {VALIDATION_ERROR_13c0009c, "The spec valid usage text states 'Each element of pWaitDstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00078)"}, - {VALIDATION_ERROR_13c11401, "The spec valid usage text states 'If commandBufferCount is not 0, pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pCommandBuffers-parameter)"}, - {VALIDATION_ERROR_13c1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfo, VkProtectedSubmitInfo, VkWin32KeyedMutexAcquireReleaseInfoKHR, or VkWin32KeyedMutexAcquireReleaseInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pNext-pNext)"}, - {VALIDATION_ERROR_13c23401, "The spec valid usage text states 'If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pSignalSemaphores-parameter)"}, - {VALIDATION_ERROR_13c27001, "The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitDstStageMask must be a valid pointer to an array of waitSemaphoreCount valid combinations of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-parameter)"}, - {VALIDATION_ERROR_13c27003, "The spec valid usage text states 'Each element of pWaitDstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask)"}, - {VALIDATION_ERROR_13c27601, "The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitSemaphores-parameter)"}, - {VALIDATION_ERROR_13c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SUBMIT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-sType-sType)"}, - {VALIDATION_ERROR_13c2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-sType-unique)"}, - {VALIDATION_ERROR_13e006b4, "The spec valid usage text states 'If srcSubpass is not VK_SUBPASS_EXTERNAL, srcStageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00858)"}, - {VALIDATION_ERROR_13e006b6, "The spec valid usage text states 'If dstSubpass is not VK_SUBPASS_EXTERNAL, dstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstSubpass-00859)"}, - {VALIDATION_ERROR_13e006b8, "The spec valid usage text states 'If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-00860)"}, - {VALIDATION_ERROR_13e006ba, "The spec valid usage text states 'If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-00861)"}, - {VALIDATION_ERROR_13e006bc, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-00862)"}, - {VALIDATION_ERROR_13e006be, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-00863)"}, - {VALIDATION_ERROR_13e006c0, "The spec valid usage text states 'srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00864)"}, - {VALIDATION_ERROR_13e006c2, "The spec valid usage text states 'srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00865)"}, - {VALIDATION_ERROR_13e006c4, "The spec valid usage text states 'If srcSubpass is equal to dstSubpass, srcStageMask and dstStageMask must only contain one of VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, or VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00866)"}, - {VALIDATION_ERROR_13e006c6, "The spec valid usage text states 'If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00867)"}, - {VALIDATION_ERROR_13e006c8, "The spec valid usage text states 'Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcAccessMask-00868)"}, - {VALIDATION_ERROR_13e006ca, "The spec valid usage text states 'Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstAccessMask-00869)"}, - {VALIDATION_ERROR_13e006cc, "The spec valid usage text states 'If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then both srcSubpass and dstSubpass must not equal VK_SUBPASS_EXTERNAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDependency-dependencyFlags-00870)"}, - {VALIDATION_ERROR_13e006ce, "The spec valid usage text states 'If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then the render pass must have multiview enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDependency-dependencyFlags-00871)"}, - {VALIDATION_ERROR_13e006d0, "The spec valid usage text states 'If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00872)"}, - {VALIDATION_ERROR_13e03e01, "The spec valid usage text states 'dependencyFlags must be a valid combination of VkDependencyFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dependencyFlags-parameter)"}, - {VALIDATION_ERROR_13e06801, "The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstAccessMask-parameter)"}, - {VALIDATION_ERROR_13e07801, "The spec valid usage text states 'dstStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-parameter)"}, - {VALIDATION_ERROR_13e07803, "The spec valid usage text states 'dstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-requiredbitmask)"}, - {VALIDATION_ERROR_13e2c401, "The spec valid usage text states 'srcAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcAccessMask-parameter)"}, - {VALIDATION_ERROR_13e2d401, "The spec valid usage text states 'srcStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-parameter)"}, - {VALIDATION_ERROR_13e2d403, "The spec valid usage text states 'srcStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-requiredbitmask)"}, - {VALIDATION_ERROR_14000698, "The spec valid usage text states 'pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pipelineBindPoint-00844)"}, - {VALIDATION_ERROR_1400069a, "The spec valid usage text states 'colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-colorAttachmentCount-00845)"}, - {VALIDATION_ERROR_1400069c, "The spec valid usage text states 'If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-loadOp-00846)"}, - {VALIDATION_ERROR_1400069e, "The spec valid usage text states 'If pResolveAttachments is not NULL, for each resolve attachment that does not have the value VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have the value VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00847)"}, - {VALIDATION_ERROR_140006a0, "The spec valid usage text states 'If pResolveAttachments is not NULL, the sample count of each element of pColorAttachments must be anything other than VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00848)"}, - {VALIDATION_ERROR_140006a2, "The spec valid usage text states 'Each element of pResolveAttachments must have a sample count of VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00849)"}, - {VALIDATION_ERROR_140006a4, "The spec valid usage text states 'Each element of pResolveAttachments must have the same VkFormat as its corresponding color attachment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-00850)"}, - {VALIDATION_ERROR_140006a8, "The spec valid usage text states 'If any input attachments are VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass must not access those input attachments from the fragment shader' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-None-00852)"}, - {VALIDATION_ERROR_140006aa, "The spec valid usage text states 'The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-attachment-00853)"}, - {VALIDATION_ERROR_140006ac, "The spec valid usage text states 'Each element of pPreserveAttachments must not also be an element of any other member of the subpass description' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pPreserveAttachments-00854)"}, - {VALIDATION_ERROR_140006ae, "The spec valid usage text states 'If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same layout' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-layout-00855)"}, - {VALIDATION_ERROR_140006b0, "The spec valid usage text states 'If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDescription-flags-00856)"}, - {VALIDATION_ERROR_14000b12, "The spec valid usage text states 'All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pColorAttachments-01417)"}, - {VALIDATION_ERROR_14000b14, "The spec valid usage text states 'If pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pDepthStencilAttachment-01418)"}, - {VALIDATION_ERROR_14000bc4, "The spec valid usage text states 'All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassDescription-pColorAttachments-01506)"}, - {VALIDATION_ERROR_14009001, "The spec valid usage text states 'flags must be a valid combination of VkSubpassDescriptionFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-flags-parameter)"}, - {VALIDATION_ERROR_14011001, "The spec valid usage text states 'If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pColorAttachments-parameter)"}, - {VALIDATION_ERROR_14012a01, "The spec valid usage text states 'If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pDepthStencilAttachment-parameter)"}, - {VALIDATION_ERROR_14019a01, "The spec valid usage text states 'If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pInputAttachments-parameter)"}, - {VALIDATION_ERROR_1401f001, "The spec valid usage text states 'If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pPreserveAttachments-parameter)"}, - {VALIDATION_ERROR_14021c01, "The spec valid usage text states 'If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pResolveAttachments-parameter)"}, - {VALIDATION_ERROR_14027e01, "The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubpassDescription-pipelineBindPoint-parameter)"}, - {VALIDATION_ERROR_142009bc, "The spec valid usage text states 'supportedSurfaceCounters must not include VK_SURFACE_COUNTER_VBLANK_EXT unless the surface queried is a display surface.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246)"}, - {VALIDATION_ERROR_1421c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2EXT-pNext-pNext)"}, - {VALIDATION_ERROR_1422b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2EXT-sType-sType)"}, - {VALIDATION_ERROR_144009b8, "The spec valid usage text states 'The bits in surfaceCounters must be supported by VkSwapchainCreateInfoKHR::surface, as reported by vkGetPhysicalDeviceSurfaceCapabilities2EXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244)"}, - {VALIDATION_ERROR_1442b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCounterCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_1442ee01, "The spec valid usage text states 'surfaceCounters must be a valid combination of VkSurfaceCounterFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter)"}, - {VALIDATION_ERROR_14600009, "The spec valid usage text states 'Both of oldSwapchain, and surface that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-commonparent)"}, - {VALIDATION_ERROR_146009ec, "The spec valid usage text states 'surface must be a surface that is supported by the device as determined using vkGetPhysicalDeviceSurfaceSupportKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-surface-01270)"}, - {VALIDATION_ERROR_146009ee, "The spec valid usage text states 'minImageCount must be greater than or equal to the value returned in the minImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-minImageCount-01271)"}, - {VALIDATION_ERROR_146009f0, "The spec valid usage text states 'minImageCount must be less than or equal to the value returned in the maxImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface if the returned maxImageCount is not zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-minImageCount-01272)"}, - {VALIDATION_ERROR_146009f2, "The spec valid usage text states 'imageFormat and imageColorSpace must match the format and colorSpace members, respectively, of one of the VkSurfaceFormatKHR structures returned by vkGetPhysicalDeviceSurfaceFormatsKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageFormat-01273)"}, - {VALIDATION_ERROR_146009f4, "The spec valid usage text states 'imageExtent must be between minImageExtent and maxImageExtent, inclusive, where minImageExtent and maxImageExtent are members of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageExtent-01274)"}, - {VALIDATION_ERROR_146009f6, "The spec valid usage text states 'imageArrayLayers must be greater than 0 and less than or equal to the maxImageArrayLayers member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275)"}, - {VALIDATION_ERROR_146009f8, "The spec valid usage text states 'imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-01276)"}, - {VALIDATION_ERROR_146009fa, "The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277)"}, - {VALIDATION_ERROR_146009fc, "The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278)"}, - {VALIDATION_ERROR_146009fe, "The spec valid usage text states 'preTransform must be one of the bits present in the supportedTransforms member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-preTransform-01279)"}, - {VALIDATION_ERROR_14600a00, "The spec valid usage text states 'compositeAlpha must be one of the bits present in the supportedCompositeAlpha member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280)"}, - {VALIDATION_ERROR_14600a02, "The spec valid usage text states 'presentMode must be one of the VkPresentModeKHR values returned by vkGetPhysicalDeviceSurfacePresentModesKHR for the surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-presentMode-01281)"}, - {VALIDATION_ERROR_14600ace, "The spec valid usage text states 'minImageCount must be 1 if presentMode is either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-minImageCount-01383)"}, - {VALIDATION_ERROR_14600ad0, "The spec valid usage text states 'If presentMode is VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, imageUsage must be a subset of the supported usage flags present in the sharedPresentSupportedUsageFlags member of the VkSharedPresentSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-01384)"}, - {VALIDATION_ERROR_14600ae2, "The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01393)"}, - {VALIDATION_ERROR_14600b26, "The spec valid usage text states 'If presentMode is VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_FIFO_RELAXED_KHR, imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-presentMode-01427)"}, - {VALIDATION_ERROR_14600b28, "The spec valid usage text states 'If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428)"}, - {VALIDATION_ERROR_14600b2a, "The spec valid usage text states 'If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429)"}, - {VALIDATION_ERROR_14600d32, "The spec valid usage text states 'imageExtent members width and height must both be non-zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageExtent-01689)"}, - {VALIDATION_ERROR_14600de4, "The spec valid usage text states 'imageFormat, imageUsage, imageExtent, and imageArrayLayers must be supported for VK_IMAGE_TYPE_2D VK_IMAGE_TILING_OPTIMAL images as reported by vkGetPhysicalDeviceImageFormatProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageFormat-01778)"}, - {VALIDATION_ERROR_14600f1a, "The spec valid usage text states 'If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933)"}, - {VALIDATION_ERROR_14602e01, "The spec valid usage text states 'compositeAlpha must be a valid VkCompositeAlphaFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter)"}, - {VALIDATION_ERROR_14609001, "The spec valid usage text states 'flags must be a valid combination of VkSwapchainCreateFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-flags-parameter)"}, - {VALIDATION_ERROR_1460a201, "The spec valid usage text states 'imageColorSpace must be a valid VkColorSpaceKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter)"}, - {VALIDATION_ERROR_1460a401, "The spec valid usage text states 'imageFormat must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter)"}, - {VALIDATION_ERROR_1460a801, "The spec valid usage text states 'imageSharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter)"}, - {VALIDATION_ERROR_1460ae01, "The spec valid usage text states 'imageUsage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter)"}, - {VALIDATION_ERROR_1460ae03, "The spec valid usage text states 'imageUsage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask)"}, - {VALIDATION_ERROR_1460de01, "The spec valid usage text states 'If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter)"}, - {VALIDATION_ERROR_1460de07, "The spec valid usage text states 'If oldSwapchain is a valid handle, it must have been created, allocated, or retrieved from surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent)"}, - {VALIDATION_ERROR_1461c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHR or VkSwapchainCounterCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_14629401, "The spec valid usage text states 'preTransform must be a valid VkSurfaceTransformFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-preTransform-parameter)"}, - {VALIDATION_ERROR_14629601, "The spec valid usage text states 'presentMode must be a valid VkPresentModeKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-presentMode-parameter)"}, - {VALIDATION_ERROR_1462b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_1462b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-sType-unique)"}, - {VALIDATION_ERROR_1462ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-surface-parameter)"}, - {VALIDATION_ERROR_14805a1b, "The spec valid usage text states 'disabledValidationCheckCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength)"}, - {VALIDATION_ERROR_14814401, "The spec valid usage text states 'pDisabledValidationChecks must be a valid pointer to an array of disabledValidationCheckCount VkValidationCheckEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter)"}, - {VALIDATION_ERROR_1482b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationFlagsEXT-sType-sType)"}, - {VALIDATION_ERROR_14a004d8, "The spec valid usage text states 'location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-location-00620)"}, - {VALIDATION_ERROR_14a004da, "The spec valid usage text states 'binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-binding-00621)"}, - {VALIDATION_ERROR_14a004dc, "The spec valid usage text states 'offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-offset-00622)"}, - {VALIDATION_ERROR_14a004de, "The spec valid usage text states 'format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-format-00623)"}, - {VALIDATION_ERROR_14a09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputAttributeDescription-format-parameter)"}, - {VALIDATION_ERROR_14c004d4, "The spec valid usage text states 'binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputBindingDescription-binding-00618)"}, - {VALIDATION_ERROR_14c004d6, "The spec valid usage text states 'stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputBindingDescription-stride-00619)"}, - {VALIDATION_ERROR_14c0ba01, "The spec valid usage text states 'inputRate must be a valid VkVertexInputRate value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkVertexInputBindingDescription-inputRate-parameter)"}, - {VALIDATION_ERROR_14e00a4c, "The spec valid usage text states 'window must be a valid nn::vi::NativeWindowHandle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-window-01318)"}, - {VALIDATION_ERROR_14e09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-flags-zerobitmask)"}, - {VALIDATION_ERROR_14e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-pNext-pNext)"}, - {VALIDATION_ERROR_14e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViSurfaceCreateInfoNN-sType-sType)"}, - {VALIDATION_ERROR_150009a0, "The spec valid usage text states '(x + width) must be less than or equal to viewportBoundsRange[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-x-01232)"}, - {VALIDATION_ERROR_150009a2, "The spec valid usage text states '(y + height) must be less than or equal to viewportBoundsRange[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-y-01233)"}, - {VALIDATION_ERROR_150009a4, "The spec valid usage text states 'Unless VK_EXT_depth_range_unrestricted extension is enabled minDepth must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-minDepth-01234)"}, - {VALIDATION_ERROR_150009a6, "The spec valid usage text states 'Unless VK_EXT_depth_range_unrestricted extension is enabled maxDepth must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-maxDepth-01235)"}, - {VALIDATION_ERROR_15000dd4, "The spec valid usage text states 'width must be greater than 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-width-01770)"}, - {VALIDATION_ERROR_15000dd6, "The spec valid usage text states 'width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-width-01771)"}, - {VALIDATION_ERROR_15000dd8, "The spec valid usage text states 'height must be greater than 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-height-01772)"}, - {VALIDATION_ERROR_15000dda, "The spec valid usage text states 'The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-height-01773)"}, - {VALIDATION_ERROR_15000ddc, "The spec valid usage text states 'x must be greater than or equal to viewportBoundsRange[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-x-01774)"}, - {VALIDATION_ERROR_15000dde, "The spec valid usage text states 'y must be greater than or equal to viewportBoundsRange[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkViewport-y-01775)"}, - {VALIDATION_ERROR_15000de0, "The spec valid usage text states 'y must be less than or equal to viewportBoundsRange[1]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-y-01776)"}, - {VALIDATION_ERROR_15000de2, "The spec valid usage text states '(y + height) must be greater than or equal to viewportBoundsRange[0]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewport-y-01777)"}, - {VALIDATION_ERROR_15230c01, "The spec valid usage text states 'w must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-w-parameter)"}, - {VALIDATION_ERROR_15231001, "The spec valid usage text states 'x must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-x-parameter)"}, - {VALIDATION_ERROR_15231201, "The spec valid usage text states 'y must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-y-parameter)"}, - {VALIDATION_ERROR_15231401, "The spec valid usage text states 'z must be a valid VkViewportCoordinateSwizzleNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkViewportSwizzleNV-z-parameter)"}, - {VALIDATION_ERROR_15400a30, "The spec valid usage text states 'display must point to a valid Wayland wl_display.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-display-01304)"}, - {VALIDATION_ERROR_15400a32, "The spec valid usage text states 'surface must point to a valid Wayland wl_surface.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305)"}, - {VALIDATION_ERROR_15409005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_1541c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_1542b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_15600009, "The spec valid usage text states 'Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent)"}, - {VALIDATION_ERROR_156000a2, "The spec valid usage text states 'Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHR::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081)"}, - {VALIDATION_ERROR_1560e201, "The spec valid usage text states 'If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter)"}, - {VALIDATION_ERROR_1560e401, "The spec valid usage text states 'If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter)"}, - {VALIDATION_ERROR_1560e801, "The spec valid usage text states 'If acquireCount is not 0, pAcquireTimeouts must be a valid pointer to an array of acquireCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter)"}, - {VALIDATION_ERROR_15621201, "The spec valid usage text states 'If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter)"}, - {VALIDATION_ERROR_15621401, "The spec valid usage text states 'If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter)"}, - {VALIDATION_ERROR_1562b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_15800009, "The spec valid usage text states 'Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent)"}, - {VALIDATION_ERROR_1580e201, "The spec valid usage text states 'If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter)"}, - {VALIDATION_ERROR_1580e401, "The spec valid usage text states 'If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter)"}, - {VALIDATION_ERROR_1580e601, "The spec valid usage text states 'If acquireCount is not 0, pAcquireTimeoutMilliseconds must be a valid pointer to an array of acquireCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireTimeoutMilliseconds-parameter)"}, - {VALIDATION_ERROR_15821201, "The spec valid usage text states 'If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseKeys-parameter)"}, - {VALIDATION_ERROR_15821401, "The spec valid usage text states 'If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseSyncs-parameter)"}, - {VALIDATION_ERROR_1582b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-sType-sType)"}, - {VALIDATION_ERROR_15a00a36, "The spec valid usage text states 'hinstance must be a valid Win32 HINSTANCE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307)"}, - {VALIDATION_ERROR_15a00a38, "The spec valid usage text states 'hwnd must be a valid Win32 HWND.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308)"}, - {VALIDATION_ERROR_15a09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_15a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_15a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWin32SurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_15c00009, "The spec valid usage text states 'Both of dstSet, and the elements of pTexelBufferView that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-commonparent)"}, - {VALIDATION_ERROR_15c00276, "The spec valid usage text states 'dstBinding must be less than or equal to the maximum value of binding of all VkDescriptorSetLayoutBinding structures specified when dstSet's descriptor set layout was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstBinding-00315)"}, - {VALIDATION_ERROR_15c00278, "The spec valid usage text states 'dstBinding must be a binding with a non-zero descriptorCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstBinding-00316)"}, - {VALIDATION_ERROR_15c0027a, "The spec valid usage text states 'All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical descriptorType and stageFlags.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-00317)"}, - {VALIDATION_ERROR_15c0027c, "The spec valid usage text states 'All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must all either use immutable samplers or must all not use immutable samplers.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-00318)"}, - {VALIDATION_ERROR_15c0027e, "The spec valid usage text states 'descriptorType must match the type of dstBinding within dstSet' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00319)"}, - {VALIDATION_ERROR_15c00280, "The spec valid usage text states 'dstSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstSet-00320)"}, - {VALIDATION_ERROR_15c00282, "The spec valid usage text states 'The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by descriptorsets-updates-consecutive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-dstArrayElement-00321)"}, - {VALIDATION_ERROR_15c00284, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pImageInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorImageInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00322)"}, - {VALIDATION_ERROR_15c00286, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pTexelBufferView must be a valid pointer to an array of descriptorCount valid VkBufferView handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00323)"}, - {VALIDATION_ERROR_15c00288, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00324)"}, - {VALIDATION_ERROR_15c0028a, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was not allocated with a layout that included immutable samplers for dstBinding with descriptorType, the sampler member of each element of pImageInfo must be a valid VkSampler object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00325)"}, - {VALIDATION_ERROR_15c0028c, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView and imageLayout members of each element of pImageInfo must be a valid VkImageView and VkImageLayout, respectively' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00326)"}, - {VALIDATION_ERROR_15c0028e, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00327)"}, - {VALIDATION_ERROR_15c00290, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00328)"}, - {VALIDATION_ERROR_15c00292, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, and the buffer member of any element of pBufferInfo is the handle of a non-sparse buffer, then that buffer must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00329)"}, - {VALIDATION_ERROR_15c00294, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00330)"}, - {VALIDATION_ERROR_15c00296, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00331)"}, - {VALIDATION_ERROR_15c00298, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxUniformBufferRange' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00332)"}, - {VALIDATION_ERROR_15c0029a, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxStorageBufferRange' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00333)"}, - {VALIDATION_ERROR_15c0029c, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00334)"}, - {VALIDATION_ERROR_15c0029e, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00335)"}, - {VALIDATION_ERROR_15c002a0, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the identity swizzle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00336)"}, - {VALIDATION_ERROR_15c002a2, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_SAMPLED_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00337)"}, - {VALIDATION_ERROR_15c002a4, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00338)"}, - {VALIDATION_ERROR_15c002a6, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-00339)"}, - {VALIDATION_ERROR_15c00af4, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, for each descriptor that will be accessed via load or store operations the imageLayout member for corresponding elements of pImageInfo must be VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-01402)"}, - {VALIDATION_ERROR_15c00af6, "The spec valid usage text states 'If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageLayout member of each element of pImageInfo must be VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-01403)"}, - {VALIDATION_ERROR_15c017d0, "The spec valid usage text states 'All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical VkDescriptorBindingFlagBitsEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-03048)"}, - {VALIDATION_ERROR_15c0441b, "The spec valid usage text states 'descriptorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorCount-arraylength)"}, - {VALIDATION_ERROR_15c04e01, "The spec valid usage text states 'descriptorType must be a valid VkDescriptorType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-parameter)"}, - {VALIDATION_ERROR_15c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-pNext-pNext)"}, - {VALIDATION_ERROR_15c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWriteDescriptorSet-sType-sType)"}, - {VALIDATION_ERROR_15e00a3c, "The spec valid usage text states 'connection must point to a valid X11 xcb_connection_t.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-connection-01310)"}, - {VALIDATION_ERROR_15e00a3e, "The spec valid usage text states 'window must be a valid X11 xcb_window_t.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-window-01311)"}, - {VALIDATION_ERROR_15e09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_15e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_15e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXcbSurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_16000a42, "The spec valid usage text states 'dpy must point to a valid Xlib Display.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313)"}, - {VALIDATION_ERROR_16000a44, "The spec valid usage text states 'window must be a valid Xlib Window.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-window-01314)"}, - {VALIDATION_ERROR_16009005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-flags-zerobitmask)"}, - {VALIDATION_ERROR_1601c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_1602b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkXlibSurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_16200e16, "The spec valid usage text states 'If the number of currently acquired images is greater than the difference between the number of images in the swapchain member of pAcquireInfo and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, the timeout member of pAcquireInfo must not be UINT64_MAX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-swapchain-01803)"}, - {VALIDATION_ERROR_16205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-device-parameter)"}, - {VALIDATION_ERROR_1620e001, "The spec valid usage text states 'pAcquireInfo must be a valid pointer to a valid VkAcquireNextImageInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter)"}, - {VALIDATION_ERROR_16218601, "The spec valid usage text states 'pImageIndex must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImage2KHR-pImageIndex-parameter)"}, - {VALIDATION_ERROR_16400009, "The spec valid usage text states 'Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-commonparent)"}, - {VALIDATION_ERROR_16400a0a, "The spec valid usage text states 'swapchain must not be in the retired state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-swapchain-01285)"}, - {VALIDATION_ERROR_16400a0c, "The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-01286)"}, - {VALIDATION_ERROR_16400a0e, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-fence-01287)"}, - {VALIDATION_ERROR_16400de6, "The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-01779)"}, - {VALIDATION_ERROR_16400de8, "The spec valid usage text states 'semaphore and fence must not both be equal to VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-01780)"}, - {VALIDATION_ERROR_16400e14, "The spec valid usage text states 'If the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-swapchain-01802)"}, - {VALIDATION_ERROR_16405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-device-parameter)"}, - {VALIDATION_ERROR_16408801, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-fence-parameter)"}, - {VALIDATION_ERROR_16408807, "The spec valid usage text states 'If fence is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-fence-parent)"}, - {VALIDATION_ERROR_16418601, "The spec valid usage text states 'pImageIndex must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-pImageIndex-parameter)"}, - {VALIDATION_ERROR_1642b801, "The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-parameter)"}, - {VALIDATION_ERROR_1642b807, "The spec valid usage text states 'If semaphore is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-semaphore-parent)"}, - {VALIDATION_ERROR_1642f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_16606001, "The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireXlibDisplayEXT-display-parameter)"}, - {VALIDATION_ERROR_16606601, "The spec valid usage text states 'dpy must be a valid pointer to a Display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireXlibDisplayEXT-dpy-parameter)"}, - {VALIDATION_ERROR_16627a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter)"}, - {VALIDATION_ERROR_16805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateCommandBuffers-device-parameter)"}, - {VALIDATION_ERROR_1680ea01, "The spec valid usage text states 'pAllocateInfo must be a valid pointer to a valid VkCommandBufferAllocateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter)"}, - {VALIDATION_ERROR_16811401, "The spec valid usage text states 'pCommandBuffers must be a valid pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter)"}, - {VALIDATION_ERROR_16a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateDescriptorSets-device-parameter)"}, - {VALIDATION_ERROR_16a0ea01, "The spec valid usage text states 'pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter)"}, - {VALIDATION_ERROR_16a13001, "The spec valid usage text states 'pDescriptorSets must be a valid pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter)"}, - {VALIDATION_ERROR_16c00d62, "The spec valid usage text states 'pAllocateInfo-&gt;allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[pAllocateInfo-&gt;memoryTypeIndex].size as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-01713)"}, - {VALIDATION_ERROR_16c00d64, "The spec valid usage text states 'pAllocateInfo-&gt;memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-01714)"}, - {VALIDATION_ERROR_16c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-device-parameter)"}, - {VALIDATION_ERROR_16c0ea01, "The spec valid usage text states 'pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-parameter)"}, - {VALIDATION_ERROR_16c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pAllocator-parameter)"}, - {VALIDATION_ERROR_16c1aa01, "The spec valid usage text states 'pMemory must be a valid pointer to a VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkAllocateMemory-pMemory-parameter)"}, - {VALIDATION_ERROR_16e00062, "The spec valid usage text states 'commandBuffer must not be in the recording or pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00049)"}, - {VALIDATION_ERROR_16e00064, "The spec valid usage text states 'If commandBuffer was allocated from a VkCommandPool which did not have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the initial state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00050)"}, - {VALIDATION_ERROR_16e00066, "The spec valid usage text states 'If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00051)"}, - {VALIDATION_ERROR_16e00068, "The spec valid usage text states 'If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is VK_FALSE, or the precise occlusion queries feature is not enabled, the queryFlags member of the pInheritanceInfo member pBeginInfo must not contain VK_QUERY_CONTROL_PRECISE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-00052)"}, - {VALIDATION_ERROR_16e02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_16e0f601, "The spec valid usage text states 'pBeginInfo must be a valid pointer to a valid VkCommandBufferBeginInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBeginCommandBuffer-pBeginInfo-parameter)"}, - {VALIDATION_ERROR_1700080a, "The spec valid usage text states 'buffer must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01029)"}, - {VALIDATION_ERROR_1700080c, "The spec valid usage text states 'buffer must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01030)"}, - {VALIDATION_ERROR_1700080e, "The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memoryOffset-01031)"}, - {VALIDATION_ERROR_17000810, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01032)"}, - {VALIDATION_ERROR_17000812, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01033)"}, - {VALIDATION_ERROR_17000814, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01034)"}, - {VALIDATION_ERROR_17000816, "The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memory-01035)"}, - {VALIDATION_ERROR_17000818, "The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memoryOffset-01036)"}, - {VALIDATION_ERROR_1700081a, "The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-size-01037)"}, - {VALIDATION_ERROR_1700081c, "The spec valid usage text states 'If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01038)"}, - {VALIDATION_ERROR_1700081e, "The spec valid usage text states 'If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01039)"}, - {VALIDATION_ERROR_17000b48, "The spec valid usage text states 'If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01444)"}, - {VALIDATION_ERROR_17000bc8, "The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-01508)"}, - {VALIDATION_ERROR_17000ed4, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-None-01898)"}, - {VALIDATION_ERROR_17000ed6, "The spec valid usage text states 'If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-None-01899)"}, - {VALIDATION_ERROR_17001a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-parameter)"}, - {VALIDATION_ERROR_17001a07, "The spec valid usage text states 'buffer must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-parent)"}, - {VALIDATION_ERROR_17005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-device-parameter)"}, - {VALIDATION_ERROR_1700c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memory-parameter)"}, - {VALIDATION_ERROR_1700c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memory-parent)"}, - {VALIDATION_ERROR_1720161b, "The spec valid usage text states 'bindInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory2-bindInfoCount-arraylength)"}, - {VALIDATION_ERROR_17205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory2-device-parameter)"}, - {VALIDATION_ERROR_1720fa01, "The spec valid usage text states 'pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindBufferMemoryInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory2-pBindInfos-parameter)"}, - {VALIDATION_ERROR_17400828, "The spec valid usage text states 'image must not already be backed by a memory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-01044)"}, - {VALIDATION_ERROR_1740082a, "The spec valid usage text states 'image must not have been created with any sparse memory binding flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-01045)"}, - {VALIDATION_ERROR_1740082c, "The spec valid usage text states 'memoryOffset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memoryOffset-01046)"}, - {VALIDATION_ERROR_1740082e, "The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memory-01047)"}, - {VALIDATION_ERROR_17400830, "The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memoryOffset-01048)"}, - {VALIDATION_ERROR_17400832, "The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-size-01049)"}, - {VALIDATION_ERROR_17400834, "The spec valid usage text states 'If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01050)"}, - {VALIDATION_ERROR_17400836, "The spec valid usage text states 'If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-01051)"}, - {VALIDATION_ERROR_17400b4a, "The spec valid usage text states 'If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01445)"}, - {VALIDATION_ERROR_17400bca, "The spec valid usage text states 'If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-01509)"}, - {VALIDATION_ERROR_17400c90, "The spec valid usage text states 'image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT set.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01608)"}, - {VALIDATION_ERROR_17400eda, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-None-01901)"}, - {VALIDATION_ERROR_17400edc, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-None-01902)"}, - {VALIDATION_ERROR_17405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-device-parameter)"}, - {VALIDATION_ERROR_1740a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-parameter)"}, - {VALIDATION_ERROR_1740a007, "The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-parent)"}, - {VALIDATION_ERROR_1740c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memory-parameter)"}, - {VALIDATION_ERROR_1740c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memory-parent)"}, - {VALIDATION_ERROR_1760161b, "The spec valid usage text states 'bindInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory2-bindInfoCount-arraylength)"}, - {VALIDATION_ERROR_17605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory2-device-parameter)"}, - {VALIDATION_ERROR_1760fa01, "The spec valid usage text states 'pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindImageMemoryInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory2-pBindInfos-parameter)"}, - {VALIDATION_ERROR_17800009, "The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commonparent)"}, - {VALIDATION_ERROR_17800640, "The spec valid usage text states 'If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00800)"}, - {VALIDATION_ERROR_17800644, "The spec valid usage text states 'query must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-query-00802)"}, - {VALIDATION_ERROR_17800646, "The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00803)"}, - {VALIDATION_ERROR_17800648, "The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00804)"}, - {VALIDATION_ERROR_1780064a, "The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryType-00805)"}, - {VALIDATION_ERROR_1780064e, "The spec valid usage text states 'All queries used by the command must be unavailable' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-None-00807)"}, - {VALIDATION_ERROR_17800650, "The spec valid usage text states 'If vkCmdBeginQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass's view mask must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginQuery-query-00808)"}, - {VALIDATION_ERROR_17800eba, "The spec valid usage text states 'commandBuffer must not be a protected command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-01885)"}, - {VALIDATION_ERROR_17800f04, "The spec valid usage text states 'queryPool must have been created with a queryType that differs from that of any queries that are active within commandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryPool-01922)"}, - {VALIDATION_ERROR_17802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-parameter)"}, - {VALIDATION_ERROR_17802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-recording)"}, - {VALIDATION_ERROR_17802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_17809001, "The spec valid usage text states 'flags must be a valid combination of VkQueryControlFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-flags-parameter)"}, - {VALIDATION_ERROR_17829801, "The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginQuery-queryPool-parameter)"}, - {VALIDATION_ERROR_17a00017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-renderpass)"}, - {VALIDATION_ERROR_17a00019, "The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-bufferlevel)"}, - {VALIDATION_ERROR_17a006fe, "The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00895)"}, - {VALIDATION_ERROR_17a00700, "The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00896)"}, - {VALIDATION_ERROR_17a00702, "The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00897)"}, - {VALIDATION_ERROR_17a00704, "The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00898)"}, - {VALIDATION_ERROR_17a00706, "The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00899)"}, - {VALIDATION_ERROR_17a00708, "The spec valid usage text states 'If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-00900)"}, - {VALIDATION_ERROR_17a0070a, "The spec valid usage text states 'The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-srcStageMask-00901)"}, - {VALIDATION_ERROR_17a00dbc, "The spec valid usage text states 'If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass-initialLayout-01758)"}, - {VALIDATION_ERROR_17a02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-commandBuffer-parameter)"}, - {VALIDATION_ERROR_17a02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-commandBuffer-recording)"}, - {VALIDATION_ERROR_17a02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_17a03201, "The spec valid usage text states 'contents must be a valid VkSubpassContents value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-contents-parameter)"}, - {VALIDATION_ERROR_17a21801, "The spec valid usage text states 'pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter)"}, - {VALIDATION_ERROR_17c00009, "The spec valid usage text states 'Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commonparent)"}, - {VALIDATION_ERROR_17c002cc, "The spec valid usage text states 'Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358)"}, - {VALIDATION_ERROR_17c002ce, "The spec valid usage text states 'dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359)"}, - {VALIDATION_ERROR_17c002d0, "The spec valid usage text states 'The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-firstSet-00360)"}, - {VALIDATION_ERROR_17c002d2, "The spec valid usage text states 'pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361)"}, - {VALIDATION_ERROR_17c002d4, "The spec valid usage text states 'Each element of pDynamicOffsets must satisfy the required alignment for the corresponding descriptor binding's descriptor type' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDynamicOffsets-00362)"}, - {VALIDATION_ERROR_17c02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commandBuffer-parameter)"}, - {VALIDATION_ERROR_17c02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commandBuffer-recording)"}, - {VALIDATION_ERROR_17c02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_17c04a1b, "The spec valid usage text states 'descriptorSetCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength)"}, - {VALIDATION_ERROR_17c0be01, "The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-layout-parameter)"}, - {VALIDATION_ERROR_17c13001, "The spec valid usage text states 'pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter)"}, - {VALIDATION_ERROR_17c15401, "The spec valid usage text states 'If dynamicOffsetCount is not 0, pDynamicOffsets must be a valid pointer to an array of dynamicOffsetCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter)"}, - {VALIDATION_ERROR_17c27e01, "The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter)"}, - {VALIDATION_ERROR_17e00009, "The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commonparent)"}, - {VALIDATION_ERROR_17e0035e, "The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-offset-00431)"}, - {VALIDATION_ERROR_17e00360, "The spec valid usage text states 'The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-offset-00432)"}, - {VALIDATION_ERROR_17e00362, "The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-buffer-00433)"}, - {VALIDATION_ERROR_17e00364, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-buffer-00434)"}, - {VALIDATION_ERROR_17e01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-buffer-parameter)"}, - {VALIDATION_ERROR_17e02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_17e02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commandBuffer-recording)"}, - {VALIDATION_ERROR_17e02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_17e0b201, "The spec valid usage text states 'indexType must be a valid VkIndexType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindIndexBuffer-indexType-parameter)"}, - {VALIDATION_ERROR_18000009, "The spec valid usage text states 'Both of commandBuffer, and pipeline must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commonparent)"}, - {VALIDATION_ERROR_18000612, "The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00777)"}, - {VALIDATION_ERROR_18000614, "The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00778)"}, - {VALIDATION_ERROR_18000616, "The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00779)"}, - {VALIDATION_ERROR_18000618, "The spec valid usage text states 'If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-00780)"}, - {VALIDATION_ERROR_1800061a, "The spec valid usage text states 'If the variable multisample rate feature is not supported, pipeline is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipeline-00781)"}, - {VALIDATION_ERROR_18000bea, "The spec valid usage text states 'If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, and pipeline is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its sampleLocationsEnable member set to VK_TRUE but without VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sampleLocationsInfo specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBindPipeline-variableSampleLocations-01525)"}, - {VALIDATION_ERROR_18002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commandBuffer-recording)"}, - {VALIDATION_ERROR_18002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_18027c01, "The spec valid usage text states 'pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipeline-parameter)"}, - {VALIDATION_ERROR_18027e01, "The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindPipeline-pipelineBindPoint-parameter)"}, - {VALIDATION_ERROR_18200009, "The spec valid usage text states 'Both of commandBuffer, and the elements of pBuffers must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commonparent)"}, - {VALIDATION_ERROR_182004e0, "The spec valid usage text states 'firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-firstBinding-00624)"}, - {VALIDATION_ERROR_182004e2, "The spec valid usage text states 'The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-firstBinding-00625)"}, - {VALIDATION_ERROR_182004e4, "The spec valid usage text states 'All elements of pOffsets must be less than the size of the corresponding element in pBuffers' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pOffsets-00626)"}, - {VALIDATION_ERROR_182004e6, "The spec valid usage text states 'All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pBuffers-00627)"}, - {VALIDATION_ERROR_182004e8, "The spec valid usage text states 'Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pBuffers-00628)"}, - {VALIDATION_ERROR_1820181b, "The spec valid usage text states 'bindingCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-bindingCount-arraylength)"}, - {VALIDATION_ERROR_18202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commandBuffer-recording)"}, - {VALIDATION_ERROR_18202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_18210601, "The spec valid usage text states 'pBuffers must be a valid pointer to an array of bindingCount valid VkBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pBuffers-parameter)"}, - {VALIDATION_ERROR_1821d201, "The spec valid usage text states 'pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBindVertexBuffers-pOffsets-parameter)"}, - {VALIDATION_ERROR_18400009, "The spec valid usage text states 'Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commonparent)"}, - {VALIDATION_ERROR_18400017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-renderpass)"}, - {VALIDATION_ERROR_184001ae, "The spec valid usage text states 'The source region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-00215)"}, - {VALIDATION_ERROR_184001b0, "The spec valid usage text states 'The destination region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-00216)"}, - {VALIDATION_ERROR_184001b2, "The spec valid usage text states 'The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-00217)"}, - {VALIDATION_ERROR_184001b4, "The spec valid usage text states 'srcImage must use a format that supports VK_FORMAT_FEATURE_BLIT_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00218)"}, - {VALIDATION_ERROR_184001b6, "The spec valid usage text states 'srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00219)"}, - {VALIDATION_ERROR_184001b8, "The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00220)"}, - {VALIDATION_ERROR_184001ba, "The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-00221)"}, - {VALIDATION_ERROR_184001bc, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-00222)"}, - {VALIDATION_ERROR_184001be, "The spec valid usage text states 'dstImage must use a format that supports VK_FORMAT_FEATURE_BLIT_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00223)"}, - {VALIDATION_ERROR_184001c0, "The spec valid usage text states 'dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00224)"}, - {VALIDATION_ERROR_184001c2, "The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00225)"}, - {VALIDATION_ERROR_184001c4, "The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-00226)"}, - {VALIDATION_ERROR_184001c6, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-00227)"}, - {VALIDATION_ERROR_184001c8, "The spec valid usage text states 'The sample count of srcImage and dstImage must both be equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00228)"}, - {VALIDATION_ERROR_184001ca, "The spec valid usage text states 'If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00229)"}, - {VALIDATION_ERROR_184001cc, "The spec valid usage text states 'If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00230)"}, - {VALIDATION_ERROR_184001ce, "The spec valid usage text states 'If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00231)"}, - {VALIDATION_ERROR_184001d0, "The spec valid usage text states 'If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00232)"}, - {VALIDATION_ERROR_184001d2, "The spec valid usage text states 'srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-00233)"}, - {VALIDATION_ERROR_184001d4, "The spec valid usage text states 'dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-00234)"}, - {VALIDATION_ERROR_184001d6, "The spec valid usage text states 'If filter is VK_FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-filter-00235)"}, - {VALIDATION_ERROR_184001d8, "The spec valid usage text states 'If filter is VK_FILTER_CUBIC_IMG, srcImage must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-filter-00236)"}, - {VALIDATION_ERROR_184001da, "The spec valid usage text states 'If filter is VK_FILTER_CUBIC_IMG, srcImage must have a VkImageType of VK_IMAGE_TYPE_3D' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-filter-00237)"}, - {VALIDATION_ERROR_18400aec, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-01398)"}, - {VALIDATION_ERROR_18400aee, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-01399)"}, - {VALIDATION_ERROR_18400c32, "The spec valid usage text states 'srcImage must not use a format listed in features-formats-requiring-sampler-ycbcr-conversion' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-01561)"}, - {VALIDATION_ERROR_18400c34, "The spec valid usage text states 'dstImage must not use a format listed in features-formats-requiring-sampler-ycbcr-conversion' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-01562)"}, - {VALIDATION_ERROR_18400d52, "The spec valid usage text states 'The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcSubresource-01705)"}, - {VALIDATION_ERROR_18400d54, "The spec valid usage text states 'The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstSubresource-01706)"}, - {VALIDATION_ERROR_18400d56, "The spec valid usage text states 'The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcSubresource-01707)"}, - {VALIDATION_ERROR_18400d58, "The spec valid usage text states 'The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstSubresource-01708)"}, - {VALIDATION_ERROR_18400e54, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-01834)"}, - {VALIDATION_ERROR_18400e56, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-01835)"}, - {VALIDATION_ERROR_18400e58, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-01836)"}, - {VALIDATION_ERROR_18402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18402413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-recording)"}, - {VALIDATION_ERROR_18402415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_18407201, "The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImage-parameter)"}, - {VALIDATION_ERROR_18407401, "The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-dstImageLayout-parameter)"}, - {VALIDATION_ERROR_18408c01, "The spec valid usage text states 'filter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-filter-parameter)"}, - {VALIDATION_ERROR_18421001, "The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkImageBlit structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-pRegions-parameter)"}, - {VALIDATION_ERROR_1842ac1b, "The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-regionCount-arraylength)"}, - {VALIDATION_ERROR_1842ce01, "The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImage-parameter)"}, - {VALIDATION_ERROR_1842d001, "The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdBlitImage-srcImageLayout-parameter)"}, - {VALIDATION_ERROR_18600017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-renderpass)"}, - {VALIDATION_ERROR_1860001e, "The spec valid usage text states 'If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, the colorAttachment member of that element must refer to a valid color attachment in the current subpass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-aspectMask-00015)"}, - {VALIDATION_ERROR_18600020, "The spec valid usage text states 'The rectangular region specified by each element of pRects must be contained within the render area of the current render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pRects-00016)"}, - {VALIDATION_ERROR_18600022, "The spec valid usage text states 'The layers specified by each element of pRects must be contained within every attachment that pAttachments refers to' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pRects-00017)"}, - {VALIDATION_ERROR_18600024, "The spec valid usage text states 'If the render pass instance this is recorded in uses multiview, then baseArrayLayer must be zero and layerCount must be one.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearAttachments-baseArrayLayer-00018)"}, - {VALIDATION_ERROR_18600e1b, "The spec valid usage text states 'attachmentCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-attachmentCount-arraylength)"}, - {VALIDATION_ERROR_18600f1c, "The spec valid usage text states 'The layerCount member of each element of pRects must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-layerCount-01934)"}, - {VALIDATION_ERROR_18602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18602413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-commandBuffer-recording)"}, - {VALIDATION_ERROR_18602415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1860f201, "The spec valid usage text states 'pAttachments must be a valid pointer to an array of attachmentCount valid VkClearAttachment structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pAttachments-parameter)"}, - {VALIDATION_ERROR_18620e01, "The spec valid usage text states 'pRects must be a valid pointer to an array of rectCount VkClearRect structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-pRects-parameter)"}, - {VALIDATION_ERROR_1862aa1b, "The spec valid usage text states 'rectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearAttachments-rectCount-arraylength)"}, - {VALIDATION_ERROR_18800002, "The spec valid usage text states 'image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-image-00001)"}, - {VALIDATION_ERROR_18800004, "The spec valid usage text states 'image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-00002)"}, - {VALIDATION_ERROR_18800006, "The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-00003)"}, - {VALIDATION_ERROR_18800008, "The spec valid usage text states 'imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-00004)"}, - {VALIDATION_ERROR_18800009, "The spec valid usage text states 'Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commonparent)"}, - {VALIDATION_ERROR_1880000a, "The spec valid usage text states 'imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-00005)"}, - {VALIDATION_ERROR_1880000e, "The spec valid usage text states 'image must not have a compressed or depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-00007)"}, - {VALIDATION_ERROR_18800017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-renderpass)"}, - {VALIDATION_ERROR_18800ae4, "The spec valid usage text states 'imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-01394)"}, - {VALIDATION_ERROR_18800b7c, "The spec valid usage text states 'The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-baseMipLevel-01470)"}, - {VALIDATION_ERROR_18800b80, "The spec valid usage text states 'The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-baseArrayLayer-01472)"}, - {VALIDATION_ERROR_18800c12, "The spec valid usage text states 'image must not use a format listed in features-formats-requiring-sampler-ycbcr-conversion' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-image-01545)"}, - {VALIDATION_ERROR_18800d38, "The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pRanges-01692)"}, - {VALIDATION_ERROR_18800d3a, "The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pRanges-01693)"}, - {VALIDATION_ERROR_18800e1a, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then image must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-01805)"}, - {VALIDATION_ERROR_18800e1c, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then image must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-01806)"}, - {VALIDATION_ERROR_18802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-recording)"}, - {VALIDATION_ERROR_18802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1880a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-image-parameter)"}, - {VALIDATION_ERROR_1880a601, "The spec valid usage text states 'imageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-imageLayout-parameter)"}, - {VALIDATION_ERROR_18810e01, "The spec valid usage text states 'pColor must be a valid pointer to a valid VkClearColorValue union' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pColor-parameter)"}, - {VALIDATION_ERROR_18820601, "The spec valid usage text states 'pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-pRanges-parameter)"}, - {VALIDATION_ERROR_1882a41b, "The spec valid usage text states 'rangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearColorImage-rangeCount-arraylength)"}, - {VALIDATION_ERROR_18a00009, "The spec valid usage text states 'Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commonparent)"}, - {VALIDATION_ERROR_18a00010, "The spec valid usage text states 'image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00008)"}, - {VALIDATION_ERROR_18a00012, "The spec valid usage text states 'image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00009)"}, - {VALIDATION_ERROR_18a00014, "The spec valid usage text states 'If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00010)"}, - {VALIDATION_ERROR_18a00016, "The spec valid usage text states 'imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-imageLayout-00011)"}, - {VALIDATION_ERROR_18a00017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-renderpass)"}, - {VALIDATION_ERROR_18a00018, "The spec valid usage text states 'imageLayout must be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-imageLayout-00012)"}, - {VALIDATION_ERROR_18a0001c, "The spec valid usage text states 'image must have a depth/stencil format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-00014)"}, - {VALIDATION_ERROR_18a00b84, "The spec valid usage text states 'The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474)"}, - {VALIDATION_ERROR_18a00b88, "The spec valid usage text states 'The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476)"}, - {VALIDATION_ERROR_18a00d3c, "The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pRanges-01694)"}, - {VALIDATION_ERROR_18a00d3e, "The spec valid usage text states 'For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pRanges-01695)"}, - {VALIDATION_ERROR_18a00e1e, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then image must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-01807)"}, - {VALIDATION_ERROR_18a00e20, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then image must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-01808)"}, - {VALIDATION_ERROR_18a02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18a02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-recording)"}, - {VALIDATION_ERROR_18a02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_18a0a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-image-parameter)"}, - {VALIDATION_ERROR_18a0a601, "The spec valid usage text states 'imageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-imageLayout-parameter)"}, - {VALIDATION_ERROR_18a12801, "The spec valid usage text states 'pDepthStencil must be a valid pointer to a valid VkClearDepthStencilValue structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter)"}, - {VALIDATION_ERROR_18a20601, "The spec valid usage text states 'pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-pRanges-parameter)"}, - {VALIDATION_ERROR_18a2a41b, "The spec valid usage text states 'rangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength)"}, - {VALIDATION_ERROR_18c00009, "The spec valid usage text states 'Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commonparent)"}, - {VALIDATION_ERROR_18c00017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-renderpass)"}, - {VALIDATION_ERROR_18c000e0, "The spec valid usage text states 'The size member of each element of pRegions must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-size-00112)"}, - {VALIDATION_ERROR_18c000e2, "The spec valid usage text states 'The srcOffset member of each element of pRegions must be less than the size of srcBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcOffset-00113)"}, - {VALIDATION_ERROR_18c000e4, "The spec valid usage text states 'The dstOffset member of each element of pRegions must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstOffset-00114)"}, - {VALIDATION_ERROR_18c000e6, "The spec valid usage text states 'The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-size-00115)"}, - {VALIDATION_ERROR_18c000e8, "The spec valid usage text states 'The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-size-00116)"}, - {VALIDATION_ERROR_18c000ea, "The spec valid usage text states 'The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-pRegions-00117)"}, - {VALIDATION_ERROR_18c000ec, "The spec valid usage text states 'srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcBuffer-00118)"}, - {VALIDATION_ERROR_18c000ee, "The spec valid usage text states 'If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcBuffer-00119)"}, - {VALIDATION_ERROR_18c000f0, "The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstBuffer-00120)"}, - {VALIDATION_ERROR_18c000f2, "The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstBuffer-00121)"}, - {VALIDATION_ERROR_18c00e3c, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-01822)"}, - {VALIDATION_ERROR_18c00e3e, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-01823)"}, - {VALIDATION_ERROR_18c00e40, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-01824)"}, - {VALIDATION_ERROR_18c02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18c02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-recording)"}, - {VALIDATION_ERROR_18c02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_18c06c01, "The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-dstBuffer-parameter)"}, - {VALIDATION_ERROR_18c21001, "The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount VkBufferCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-pRegions-parameter)"}, - {VALIDATION_ERROR_18c2ac1b, "The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-regionCount-arraylength)"}, - {VALIDATION_ERROR_18c2c801, "The spec valid usage text states 'srcBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBuffer-srcBuffer-parameter)"}, - {VALIDATION_ERROR_18e00009, "The spec valid usage text states 'Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commonparent)"}, - {VALIDATION_ERROR_18e00017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-renderpass)"}, - {VALIDATION_ERROR_18e00156, "The spec valid usage text states 'srcBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-00171)"}, - {VALIDATION_ERROR_18e00158, "The spec valid usage text states 'The image region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-00172)"}, - {VALIDATION_ERROR_18e0015a, "The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-00173)"}, - {VALIDATION_ERROR_18e0015c, "The spec valid usage text states 'srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-srcBuffer-00174)"}, - {VALIDATION_ERROR_18e0015e, "The spec valid usage text states 'dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00175)"}, - {VALIDATION_ERROR_18e00160, "The spec valid usage text states 'If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-srcBuffer-00176)"}, - {VALIDATION_ERROR_18e00162, "The spec valid usage text states 'dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00177)"}, - {VALIDATION_ERROR_18e00164, "The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00178)"}, - {VALIDATION_ERROR_18e00166, "The spec valid usage text states 'dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-00179)"}, - {VALIDATION_ERROR_18e00168, "The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-00180)"}, - {VALIDATION_ERROR_18e0016a, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-00181)"}, - {VALIDATION_ERROR_18e00ae8, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-01396)"}, - {VALIDATION_ERROR_18e00d4a, "The spec valid usage text states 'The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-imageSubresource-01701)"}, - {VALIDATION_ERROR_18e00d4c, "The spec valid usage text states 'The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-imageSubresource-01702)"}, - {VALIDATION_ERROR_18e00e02, "The spec valid usage text states 'The imageOffset and and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-imageOffset-01793)"}, - {VALIDATION_ERROR_18e00e48, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-01828)"}, - {VALIDATION_ERROR_18e00e4a, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-01829)"}, - {VALIDATION_ERROR_18e00e4c, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-01830)"}, - {VALIDATION_ERROR_18e02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-parameter)"}, - {VALIDATION_ERROR_18e02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-recording)"}, - {VALIDATION_ERROR_18e02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_18e07201, "The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImage-parameter)"}, - {VALIDATION_ERROR_18e07401, "The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter)"}, - {VALIDATION_ERROR_18e21001, "The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-pRegions-parameter)"}, - {VALIDATION_ERROR_18e2ac1b, "The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-regionCount-arraylength)"}, - {VALIDATION_ERROR_18e2c801, "The spec valid usage text states 'srcBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyBufferToImage-srcBuffer-parameter)"}, - {VALIDATION_ERROR_19000009, "The spec valid usage text states 'Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commonparent)"}, - {VALIDATION_ERROR_19000017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-renderpass)"}, - {VALIDATION_ERROR_190000f4, "The spec valid usage text states 'The source region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-00122)"}, - {VALIDATION_ERROR_190000f6, "The spec valid usage text states 'The destination region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-00123)"}, - {VALIDATION_ERROR_190000f8, "The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-00124)"}, - {VALIDATION_ERROR_190000fa, "The spec valid usage text states 'srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00125)"}, - {VALIDATION_ERROR_190000fc, "The spec valid usage text states 'srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00126)"}, - {VALIDATION_ERROR_190000fe, "The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00127)"}, - {VALIDATION_ERROR_19000100, "The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-00128)"}, - {VALIDATION_ERROR_19000102, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-00129)"}, - {VALIDATION_ERROR_19000104, "The spec valid usage text states 'dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-00130)"}, - {VALIDATION_ERROR_19000106, "The spec valid usage text states 'dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-00131)"}, - {VALIDATION_ERROR_19000108, "The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-00132)"}, - {VALIDATION_ERROR_1900010a, "The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-00133)"}, - {VALIDATION_ERROR_1900010c, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-00134)"}, - {VALIDATION_ERROR_1900010e, "The spec valid usage text states 'The VkFormat of each of srcImage and dstImage must be compatible, as defined below' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00135)"}, - {VALIDATION_ERROR_19000110, "The spec valid usage text states 'The sample count of srcImage and dstImage must match' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-00136)"}, - {VALIDATION_ERROR_19000ae6, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-01395)"}, - {VALIDATION_ERROR_19000c14, "The spec valid usage text states 'If srcImage is non-sparse then the image or disjoint plane to be copied must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-01546)"}, - {VALIDATION_ERROR_19000c16, "The spec valid usage text states 'If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-01547)"}, - {VALIDATION_ERROR_19000c18, "The spec valid usage text states 'If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined below' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-01548)"}, - {VALIDATION_ERROR_19000c1a, "The spec valid usage text states 'In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-None-01549)"}, - {VALIDATION_ERROR_19000c1c, "The spec valid usage text states 'When a copy is performed to or from an image with a multi-planar format, the aspectMask of the srcSubresource and/or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for a VkFormat with three planes)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-aspectMask-01550)"}, - {VALIDATION_ERROR_19000d40, "The spec valid usage text states 'The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcSubresource-01696)"}, - {VALIDATION_ERROR_19000d42, "The spec valid usage text states 'The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstSubresource-01697)"}, - {VALIDATION_ERROR_19000d44, "The spec valid usage text states 'The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcSubresource-01698)"}, - {VALIDATION_ERROR_19000d46, "The spec valid usage text states 'The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstSubresource-01699)"}, - {VALIDATION_ERROR_19000dee, "The spec valid usage text states 'The srcOffset and and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcOffset-01783)"}, - {VALIDATION_ERROR_19000df0, "The spec valid usage text states 'The dstOffset and and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstOffset-01784)"}, - {VALIDATION_ERROR_19000e42, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-01825)"}, - {VALIDATION_ERROR_19000e44, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-01826)"}, - {VALIDATION_ERROR_19000e46, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-01827)"}, - {VALIDATION_ERROR_19000efa, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-01917)"}, - {VALIDATION_ERROR_19002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-recording)"}, - {VALIDATION_ERROR_19002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_19007201, "The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImage-parameter)"}, - {VALIDATION_ERROR_19007401, "The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-dstImageLayout-parameter)"}, - {VALIDATION_ERROR_19021001, "The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkImageCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-pRegions-parameter)"}, - {VALIDATION_ERROR_1902ac1b, "The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-regionCount-arraylength)"}, - {VALIDATION_ERROR_1902ce01, "The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImage-parameter)"}, - {VALIDATION_ERROR_1902d001, "The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImage-srcImageLayout-parameter)"}, - {VALIDATION_ERROR_19200009, "The spec valid usage text states 'Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commonparent)"}, - {VALIDATION_ERROR_19200017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-renderpass)"}, - {VALIDATION_ERROR_1920016c, "The spec valid usage text states 'The image region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-00182)"}, - {VALIDATION_ERROR_1920016e, "The spec valid usage text states 'dstBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-00183)"}, - {VALIDATION_ERROR_19200170, "The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-00184)"}, - {VALIDATION_ERROR_19200172, "The spec valid usage text states 'srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00185)"}, - {VALIDATION_ERROR_19200174, "The spec valid usage text states 'srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00186)"}, - {VALIDATION_ERROR_19200176, "The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00187)"}, - {VALIDATION_ERROR_19200178, "The spec valid usage text states 'srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-00188)"}, - {VALIDATION_ERROR_1920017a, "The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189)"}, - {VALIDATION_ERROR_1920017c, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190)"}, - {VALIDATION_ERROR_1920017e, "The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-dstBuffer-00191)"}, - {VALIDATION_ERROR_19200180, "The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-dstBuffer-00192)"}, - {VALIDATION_ERROR_19200aea, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397)"}, - {VALIDATION_ERROR_19200d4e, "The spec valid usage text states 'The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-imageSubresource-01703)"}, - {VALIDATION_ERROR_19200d50, "The spec valid usage text states 'The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-imageSubresource-01704)"}, - {VALIDATION_ERROR_19200e04, "The spec valid usage text states 'The imageOffset and and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-imageOffset-01794)"}, - {VALIDATION_ERROR_19200e4e, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-01831)"}, - {VALIDATION_ERROR_19200e50, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-01832)"}, - {VALIDATION_ERROR_19200e52, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-01833)"}, - {VALIDATION_ERROR_19202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-recording)"}, - {VALIDATION_ERROR_19202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_19206c01, "The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter)"}, - {VALIDATION_ERROR_19221001, "The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-pRegions-parameter)"}, - {VALIDATION_ERROR_1922ac1b, "The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-regionCount-arraylength)"}, - {VALIDATION_ERROR_1922ce01, "The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImage-parameter)"}, - {VALIDATION_ERROR_1922d001, "The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter)"}, - {VALIDATION_ERROR_19400009, "The spec valid usage text states 'Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commonparent)"}, - {VALIDATION_ERROR_19400017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-renderpass)"}, - {VALIDATION_ERROR_19400666, "The spec valid usage text states 'dstOffset must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstOffset-00819)"}, - {VALIDATION_ERROR_19400668, "The spec valid usage text states 'firstQuery must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-firstQuery-00820)"}, - {VALIDATION_ERROR_1940066a, "The spec valid usage text states 'The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-firstQuery-00821)"}, - {VALIDATION_ERROR_1940066c, "The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-flags-00822)"}, - {VALIDATION_ERROR_1940066e, "The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-flags-00823)"}, - {VALIDATION_ERROR_19400670, "The spec valid usage text states 'dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824)"}, - {VALIDATION_ERROR_19400672, "The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825)"}, - {VALIDATION_ERROR_19400674, "The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826)"}, - {VALIDATION_ERROR_19400676, "The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-queryType-00827)"}, - {VALIDATION_ERROR_19402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19402413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording)"}, - {VALIDATION_ERROR_19402415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_19406c01, "The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter)"}, - {VALIDATION_ERROR_19409001, "The spec valid usage text states 'flags must be a valid combination of VkQueryResultFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-flags-parameter)"}, - {VALIDATION_ERROR_19429801, "The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdCopyQueryPoolResults-queryPool-parameter)"}, - {VALIDATION_ERROR_19602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19602413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_19602415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1961a601, "The spec valid usage text states 'pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerBeginEXT-pMarkerInfo-parameter)"}, - {VALIDATION_ERROR_198009ae, "The spec valid usage text states 'There must be an outstanding vkCmdDebugMarkerBeginEXT command prior to the vkCmdDebugMarkerEndEXT on the queue that commandBuffer is submitted to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239)"}, - {VALIDATION_ERROR_198009b0, "The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240)"}, - {VALIDATION_ERROR_19802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_19802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerEndEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_19a02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19a02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_19a02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_19a1a601, "The spec valid usage text states 'pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDebugMarkerInsertEXT-pMarkerInfo-parameter)"}, - {VALIDATION_ERROR_19c00017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-renderpass)"}, - {VALIDATION_ERROR_19c00304, "The spec valid usage text states 'groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-groupCountX-00386)"}, - {VALIDATION_ERROR_19c00306, "The spec valid usage text states 'groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-groupCountY-00387)"}, - {VALIDATION_ERROR_19c00308, "The spec valid usage text states 'groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-groupCountZ-00388)"}, - {VALIDATION_ERROR_19c0030a, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00389)"}, - {VALIDATION_ERROR_19c0030c, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00390)"}, - {VALIDATION_ERROR_19c0030e, "The spec valid usage text states 'A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00391)"}, - {VALIDATION_ERROR_19c00310, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00392)"}, - {VALIDATION_ERROR_19c00312, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00393)"}, - {VALIDATION_ERROR_19c00314, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00394)"}, - {VALIDATION_ERROR_19c00316, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00395)"}, - {VALIDATION_ERROR_19c00318, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00396)"}, - {VALIDATION_ERROR_19c0031a, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-None-00397)"}, - {VALIDATION_ERROR_19c0031c, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-linearTilingFeatures-00398)"}, - {VALIDATION_ERROR_19c0031e, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-linearTilingFeatures-00399)"}, - {VALIDATION_ERROR_19c00320, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-None-00400)"}, - {VALIDATION_ERROR_19c00e68, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-01844)"}, - {VALIDATION_ERROR_19c00e6a, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-01845)"}, - {VALIDATION_ERROR_19c00e6c, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-01846)"}, - {VALIDATION_ERROR_19c02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19c02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-recording)"}, - {VALIDATION_ERROR_19c02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatch-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_19e00017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-renderpass)"}, - {VALIDATION_ERROR_19e00348, "The spec valid usage text states 'All valid usage rules from vkCmdDispatch apply' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-None-00420)"}, - {VALIDATION_ERROR_19e0034a, "The spec valid usage text states 'baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupX-00421)"}, - {VALIDATION_ERROR_19e0034c, "The spec valid usage text states 'baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupX-00422)"}, - {VALIDATION_ERROR_19e0034e, "The spec valid usage text states 'baseGroupZ must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupZ-00423)"}, - {VALIDATION_ERROR_19e00350, "The spec valid usage text states 'groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] minus baseGroupX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-groupCountX-00424)"}, - {VALIDATION_ERROR_19e00352, "The spec valid usage text states 'groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] minus baseGroupY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-groupCountY-00425)"}, - {VALIDATION_ERROR_19e00354, "The spec valid usage text states 'groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] minus baseGroupZ' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-groupCountZ-00426)"}, - {VALIDATION_ERROR_19e00356, "The spec valid usage text states 'If any of baseGroupX, baseGroupY, or baseGroupZ are not zero, then the bound compute pipeline must have been created with the VK_PIPELINE_CREATE_DISPATCH_BASE flag.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-baseGroupX-00427)"}, - {VALIDATION_ERROR_19e02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-commandBuffer-parameter)"}, - {VALIDATION_ERROR_19e02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-commandBuffer-recording)"}, - {VALIDATION_ERROR_19e02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchBase-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1a000009, "The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commonparent)"}, - {VALIDATION_ERROR_1a000017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-renderpass)"}, - {VALIDATION_ERROR_1a000322, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-buffer-00401)"}, - {VALIDATION_ERROR_1a000324, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00402)"}, - {VALIDATION_ERROR_1a000326, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00403)"}, - {VALIDATION_ERROR_1a000328, "The spec valid usage text states 'A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00404)"}, - {VALIDATION_ERROR_1a00032a, "The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-buffer-00405)"}, - {VALIDATION_ERROR_1a00032c, "The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-offset-00406)"}, - {VALIDATION_ERROR_1a00032e, "The spec valid usage text states 'The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-offset-00407)"}, - {VALIDATION_ERROR_1a000330, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00408)"}, - {VALIDATION_ERROR_1a000332, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00409)"}, - {VALIDATION_ERROR_1a000334, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00410)"}, - {VALIDATION_ERROR_1a000336, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00411)"}, - {VALIDATION_ERROR_1a000338, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00412)"}, - {VALIDATION_ERROR_1a00033a, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00413)"}, - {VALIDATION_ERROR_1a00033c, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-linearTilingFeatures-00414)"}, - {VALIDATION_ERROR_1a00033e, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-linearTilingFeatures-00415)"}, - {VALIDATION_ERROR_1a000340, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-None-00416)"}, - {VALIDATION_ERROR_1a000e6e, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-01847)"}, - {VALIDATION_ERROR_1a000e70, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-01848)"}, - {VALIDATION_ERROR_1a000e72, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-01849)"}, - {VALIDATION_ERROR_1a001a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-buffer-parameter)"}, - {VALIDATION_ERROR_1a002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1a002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-recording)"}, - {VALIDATION_ERROR_1a002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1a200017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-renderpass)"}, - {VALIDATION_ERROR_1a200366, "The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-renderPass-00435)"}, - {VALIDATION_ERROR_1a200368, "The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-subpass-00436)"}, - {VALIDATION_ERROR_1a20036a, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00437)"}, - {VALIDATION_ERROR_1a20036c, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00438)"}, - {VALIDATION_ERROR_1a20036e, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00439)"}, - {VALIDATION_ERROR_1a200370, "The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00440)"}, - {VALIDATION_ERROR_1a200372, "The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00441)"}, - {VALIDATION_ERROR_1a200374, "The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00442)"}, - {VALIDATION_ERROR_1a200376, "The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00443)"}, - {VALIDATION_ERROR_1a200378, "The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00444)"}, - {VALIDATION_ERROR_1a20037a, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00445)"}, - {VALIDATION_ERROR_1a20037c, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00446)"}, - {VALIDATION_ERROR_1a20037e, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00447)"}, - {VALIDATION_ERROR_1a200380, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00448)"}, - {VALIDATION_ERROR_1a200382, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-00449)"}, - {VALIDATION_ERROR_1a200384, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-linearTilingFeatures-00450)"}, - {VALIDATION_ERROR_1a200386, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-linearTilingFeatures-00451)"}, - {VALIDATION_ERROR_1a200388, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-None-00452)"}, - {VALIDATION_ERROR_1a20038a, "The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-maxMultiviewInstanceIndex-00453)"}, - {VALIDATION_ERROR_1a200bb6, "The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-None-01499)"}, - {VALIDATION_ERROR_1a200bd0, "The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-sampleLocationsEnable-01512)"}, - {VALIDATION_ERROR_1a200e74, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-01850)"}, - {VALIDATION_ERROR_1a200e76, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-01851)"}, - {VALIDATION_ERROR_1a200e78, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-01852)"}, - {VALIDATION_ERROR_1a202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1a202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-recording)"}, - {VALIDATION_ERROR_1a202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDraw-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1a400017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-renderpass)"}, - {VALIDATION_ERROR_1a40038c, "The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-renderPass-00454)"}, - {VALIDATION_ERROR_1a40038e, "The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-subpass-00455)"}, - {VALIDATION_ERROR_1a400390, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00456)"}, - {VALIDATION_ERROR_1a400392, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00457)"}, - {VALIDATION_ERROR_1a400394, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00458)"}, - {VALIDATION_ERROR_1a400396, "The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00459)"}, - {VALIDATION_ERROR_1a400398, "The spec valid usage text states 'For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in fxvertex-input' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00460)"}, - {VALIDATION_ERROR_1a40039a, "The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00461)"}, - {VALIDATION_ERROR_1a40039c, "The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00462)"}, - {VALIDATION_ERROR_1a40039e, "The spec valid usage text states '(indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-indexSize-00463)"}, - {VALIDATION_ERROR_1a4003a0, "The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00464)"}, - {VALIDATION_ERROR_1a4003a2, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00465)"}, - {VALIDATION_ERROR_1a4003a4, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00466)"}, - {VALIDATION_ERROR_1a4003a6, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00467)"}, - {VALIDATION_ERROR_1a4003a8, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00468)"}, - {VALIDATION_ERROR_1a4003aa, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00469)"}, - {VALIDATION_ERROR_1a4003ac, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-linearTilingFeatures-00470)"}, - {VALIDATION_ERROR_1a4003ae, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-linearTilingFeatures-00471)"}, - {VALIDATION_ERROR_1a4003b0, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-None-00472)"}, - {VALIDATION_ERROR_1a4003b2, "The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-00473)"}, - {VALIDATION_ERROR_1a400bb8, "The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-None-01500)"}, - {VALIDATION_ERROR_1a400bd2, "The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-sampleLocationsEnable-01513)"}, - {VALIDATION_ERROR_1a400e7a, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-01853)"}, - {VALIDATION_ERROR_1a400e7c, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-01854)"}, - {VALIDATION_ERROR_1a400e7e, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-01855)"}, - {VALIDATION_ERROR_1a402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1a402413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-recording)"}, - {VALIDATION_ERROR_1a402415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexed-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1a600009, "The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commonparent)"}, - {VALIDATION_ERROR_1a600017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-renderpass)"}, - {VALIDATION_ERROR_1a60041c, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-buffer-00526)"}, - {VALIDATION_ERROR_1a60041e, "The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-offset-00527)"}, - {VALIDATION_ERROR_1a600420, "The spec valid usage text states 'If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00528)"}, - {VALIDATION_ERROR_1a600422, "The spec valid usage text states 'If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00529)"}, - {VALIDATION_ERROR_1a600424, "The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-firstInstance-00530)"}, - {VALIDATION_ERROR_1a600426, "The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-renderPass-00531)"}, - {VALIDATION_ERROR_1a600428, "The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-subpass-00532)"}, - {VALIDATION_ERROR_1a60042a, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00533)"}, - {VALIDATION_ERROR_1a60042c, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00534)"}, - {VALIDATION_ERROR_1a60042e, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00535)"}, - {VALIDATION_ERROR_1a600430, "The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00536)"}, - {VALIDATION_ERROR_1a600432, "The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00537)"}, - {VALIDATION_ERROR_1a600434, "The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00538)"}, - {VALIDATION_ERROR_1a600436, "The spec valid usage text states 'If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00539)"}, - {VALIDATION_ERROR_1a600438, "The spec valid usage text states 'If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00540)"}, - {VALIDATION_ERROR_1a60043a, "The spec valid usage text states 'drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-drawCount-00541)"}, - {VALIDATION_ERROR_1a60043c, "The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00542)"}, - {VALIDATION_ERROR_1a60043e, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00543)"}, - {VALIDATION_ERROR_1a600440, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00544)"}, - {VALIDATION_ERROR_1a600442, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00545)"}, - {VALIDATION_ERROR_1a600444, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00546)"}, - {VALIDATION_ERROR_1a600446, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00547)"}, - {VALIDATION_ERROR_1a600448, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00548)"}, - {VALIDATION_ERROR_1a60044a, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00549)"}, - {VALIDATION_ERROR_1a60044c, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-00550)"}, - {VALIDATION_ERROR_1a60044e, "The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-00551)"}, - {VALIDATION_ERROR_1a600bbe, "The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-None-01503)"}, - {VALIDATION_ERROR_1a600bd8, "The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-01516)"}, - {VALIDATION_ERROR_1a600d02, "The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-buffer-01665)"}, - {VALIDATION_ERROR_1a600e8c, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-01862)"}, - {VALIDATION_ERROR_1a600e8e, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-01863)"}, - {VALIDATION_ERROR_1a600e90, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-01864)"}, - {VALIDATION_ERROR_1a601a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-buffer-parameter)"}, - {VALIDATION_ERROR_1a602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1a602413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording)"}, - {VALIDATION_ERROR_1a602415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1a800009, "The spec valid usage text states 'Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commonparent)"}, - {VALIDATION_ERROR_1a800017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-renderpass)"}, - {VALIDATION_ERROR_1a800456, "The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-offset-00555)"}, - {VALIDATION_ERROR_1a800458, "The spec valid usage text states 'countBufferOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBufferOffset-00556)"}, - {VALIDATION_ERROR_1a80045a, "The spec valid usage text states 'stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-stride-00557)"}, - {VALIDATION_ERROR_1a80045c, "The spec valid usage text states 'If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-maxDrawCount-00558)"}, - {VALIDATION_ERROR_1a80045e, "The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-firstInstance-00559)"}, - {VALIDATION_ERROR_1a800460, "The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-renderPass-00560)"}, - {VALIDATION_ERROR_1a800462, "The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-subpass-00561)"}, - {VALIDATION_ERROR_1a800464, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00562)"}, - {VALIDATION_ERROR_1a800466, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00563)"}, - {VALIDATION_ERROR_1a800468, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00564)"}, - {VALIDATION_ERROR_1a80046a, "The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00565)"}, - {VALIDATION_ERROR_1a80046c, "The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00566)"}, - {VALIDATION_ERROR_1a80046e, "The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00567)"}, - {VALIDATION_ERROR_1a800470, "The spec valid usage text states 'If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00568)"}, - {VALIDATION_ERROR_1a800472, "The spec valid usage text states 'If count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00569)"}, - {VALIDATION_ERROR_1a800474, "The spec valid usage text states 'drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-drawCount-00570)"}, - {VALIDATION_ERROR_1a800476, "The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00571)"}, - {VALIDATION_ERROR_1a800478, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00572)"}, - {VALIDATION_ERROR_1a80047a, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00573)"}, - {VALIDATION_ERROR_1a80047c, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00574)"}, - {VALIDATION_ERROR_1a80047e, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00575)"}, - {VALIDATION_ERROR_1a800480, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-00576)"}, - {VALIDATION_ERROR_1a800482, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-linearTilingFeatures-00577)"}, - {VALIDATION_ERROR_1a800484, "The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-maxMultiviewInstanceIndex-00578)"}, - {VALIDATION_ERROR_1a800bc0, "The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-None-01504)"}, - {VALIDATION_ERROR_1a800bda, "The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-sampleLocationsEnable-01517)"}, - {VALIDATION_ERROR_1a800d04, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01666)"}, - {VALIDATION_ERROR_1a800d06, "The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01667)"}, - {VALIDATION_ERROR_1a800d08, "The spec valid usage text states 'If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01668)"}, - {VALIDATION_ERROR_1a800d0a, "The spec valid usage text states 'countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01669)"}, - {VALIDATION_ERROR_1a800e92, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01865)"}, - {VALIDATION_ERROR_1a800e94, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01866)"}, - {VALIDATION_ERROR_1a800e96, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01867)"}, - {VALIDATION_ERROR_1a801a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-parameter)"}, - {VALIDATION_ERROR_1a802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1a802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-recording)"}, - {VALIDATION_ERROR_1a802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1a803401, "The spec valid usage text states 'countBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-parameter)"}, - {VALIDATION_ERROR_1aa00009, "The spec valid usage text states 'Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commonparent)"}, - {VALIDATION_ERROR_1aa00017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-renderpass)"}, - {VALIDATION_ERROR_1aa003b4, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-buffer-00474)"}, - {VALIDATION_ERROR_1aa003b6, "The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-offset-00475)"}, - {VALIDATION_ERROR_1aa003b8, "The spec valid usage text states 'If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00476)"}, - {VALIDATION_ERROR_1aa003ba, "The spec valid usage text states 'If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00477)"}, - {VALIDATION_ERROR_1aa003bc, "The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-firstInstance-00478)"}, - {VALIDATION_ERROR_1aa003be, "The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-renderPass-00479)"}, - {VALIDATION_ERROR_1aa003c0, "The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-subpass-00480)"}, - {VALIDATION_ERROR_1aa003c2, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00481)"}, - {VALIDATION_ERROR_1aa003c4, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00482)"}, - {VALIDATION_ERROR_1aa003c6, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00483)"}, - {VALIDATION_ERROR_1aa003c8, "The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00484)"}, - {VALIDATION_ERROR_1aa003ca, "The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00485)"}, - {VALIDATION_ERROR_1aa003cc, "The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00486)"}, - {VALIDATION_ERROR_1aa003ce, "The spec valid usage text states 'If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00487)"}, - {VALIDATION_ERROR_1aa003d0, "The spec valid usage text states 'If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00488)"}, - {VALIDATION_ERROR_1aa003d2, "The spec valid usage text states 'drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-drawCount-00489)"}, - {VALIDATION_ERROR_1aa003d4, "The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00490)"}, - {VALIDATION_ERROR_1aa003d6, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00491)"}, - {VALIDATION_ERROR_1aa003d8, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00492)"}, - {VALIDATION_ERROR_1aa003da, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00493)"}, - {VALIDATION_ERROR_1aa003dc, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00494)"}, - {VALIDATION_ERROR_1aa003de, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00495)"}, - {VALIDATION_ERROR_1aa003e0, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-linearTilingFeatures-00496)"}, - {VALIDATION_ERROR_1aa003e2, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-linearTilingFeatures-00497)"}, - {VALIDATION_ERROR_1aa003e4, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-None-00498)"}, - {VALIDATION_ERROR_1aa003e6, "The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-00499)"}, - {VALIDATION_ERROR_1aa00bba, "The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-None-01501)"}, - {VALIDATION_ERROR_1aa00bd4, "The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-sampleLocationsEnable-01514)"}, - {VALIDATION_ERROR_1aa00cf8, "The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-buffer-01660)"}, - {VALIDATION_ERROR_1aa00e80, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-01856)"}, - {VALIDATION_ERROR_1aa00e82, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-01857)"}, - {VALIDATION_ERROR_1aa00e84, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-01858)"}, - {VALIDATION_ERROR_1aa01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-buffer-parameter)"}, - {VALIDATION_ERROR_1aa02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1aa02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-recording)"}, - {VALIDATION_ERROR_1aa02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdDrawIndirect-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1ac00009, "The spec valid usage text states 'Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commonparent)"}, - {VALIDATION_ERROR_1ac00017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-renderpass)"}, - {VALIDATION_ERROR_1ac003ec, "The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-offset-00502)"}, - {VALIDATION_ERROR_1ac003ee, "The spec valid usage text states 'countBufferOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBufferOffset-00503)"}, - {VALIDATION_ERROR_1ac003f0, "The spec valid usage text states 'stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-stride-00504)"}, - {VALIDATION_ERROR_1ac003f2, "The spec valid usage text states 'If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-maxDrawCount-00505)"}, - {VALIDATION_ERROR_1ac003f4, "The spec valid usage text states 'If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-firstInstance-00506)"}, - {VALIDATION_ERROR_1ac003f6, "The spec valid usage text states 'The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-renderPass-00507)"}, - {VALIDATION_ERROR_1ac003f8, "The spec valid usage text states 'The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-subpass-00508)"}, - {VALIDATION_ERROR_1ac003fa, "The spec valid usage text states 'For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00509)"}, - {VALIDATION_ERROR_1ac003fc, "The spec valid usage text states 'For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in descriptorsets-compatibility' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00510)"}, - {VALIDATION_ERROR_1ac003fe, "The spec valid usage text states 'Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00511)"}, - {VALIDATION_ERROR_1ac00400, "The spec valid usage text states 'All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00512)"}, - {VALIDATION_ERROR_1ac00402, "The spec valid usage text states 'A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00513)"}, - {VALIDATION_ERROR_1ac00404, "The spec valid usage text states 'If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00514)"}, - {VALIDATION_ERROR_1ac00406, "The spec valid usage text states 'If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-00515)"}, - {VALIDATION_ERROR_1ac00408, "The spec valid usage text states 'If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-00516)"}, - {VALIDATION_ERROR_1ac0040a, "The spec valid usage text states 'The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-00517)"}, - {VALIDATION_ERROR_1ac0040c, "The spec valid usage text states 'Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00518)"}, - {VALIDATION_ERROR_1ac0040e, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00519)"}, - {VALIDATION_ERROR_1ac00410, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00520)"}, - {VALIDATION_ERROR_1ac00412, "The spec valid usage text states 'If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00521)"}, - {VALIDATION_ERROR_1ac00414, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00522)"}, - {VALIDATION_ERROR_1ac00416, "The spec valid usage text states 'If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-00523)"}, - {VALIDATION_ERROR_1ac00418, "The spec valid usage text states 'Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-linearTilingFeatures-00524)"}, - {VALIDATION_ERROR_1ac0041a, "The spec valid usage text states 'If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-maxMultiviewInstanceIndex-00525)"}, - {VALIDATION_ERROR_1ac00bbc, "The spec valid usage text states 'Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-None-01502)"}, - {VALIDATION_ERROR_1ac00bd6, "The spec valid usage text states 'If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-sampleLocationsEnable-01515)"}, - {VALIDATION_ERROR_1ac00cfa, "The spec valid usage text states 'If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-buffer-01661)"}, - {VALIDATION_ERROR_1ac00cfc, "The spec valid usage text states 'buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-buffer-01662)"}, - {VALIDATION_ERROR_1ac00cfe, "The spec valid usage text states 'If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-01663)"}, - {VALIDATION_ERROR_1ac00d00, "The spec valid usage text states 'countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-01664)"}, - {VALIDATION_ERROR_1ac00e86, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01859)"}, - {VALIDATION_ERROR_1ac00e88, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01860)"}, - {VALIDATION_ERROR_1ac00e8a, "The spec valid usage text states 'If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01861)"}, - {VALIDATION_ERROR_1ac01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-buffer-parameter)"}, - {VALIDATION_ERROR_1ac02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1ac02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-recording)"}, - {VALIDATION_ERROR_1ac02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1ac03401, "The spec valid usage text states 'countBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdDrawIndirectCountAMD-countBuffer-parameter)"}, - {VALIDATION_ERROR_1ae00009, "The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commonparent)"}, - {VALIDATION_ERROR_1ae00654, "The spec valid usage text states 'query must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-query-00810)"}, - {VALIDATION_ERROR_1ae00658, "The spec valid usage text states 'If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass's view mask must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndQuery-query-00812)"}, - {VALIDATION_ERROR_1ae00ebc, "The spec valid usage text states 'commandBuffer must not be a protected command buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-01886)"}, - {VALIDATION_ERROR_1ae00f06, "The spec valid usage text states 'All queries used by the command must be active' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-None-01923)"}, - {VALIDATION_ERROR_1ae02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1ae02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-recording)"}, - {VALIDATION_ERROR_1ae02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1ae29801, "The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndQuery-queryPool-parameter)"}, - {VALIDATION_ERROR_1b000017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-renderpass)"}, - {VALIDATION_ERROR_1b000019, "The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-bufferlevel)"}, - {VALIDATION_ERROR_1b00071c, "The spec valid usage text states 'The current subpass index must be equal to the number of subpasses in the render pass minus one' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-None-00910)"}, - {VALIDATION_ERROR_1b002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1b002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-commandBuffer-recording)"}, - {VALIDATION_ERROR_1b002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdEndRenderPass-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1b200009, "The spec valid usage text states 'Both of commandBuffer, and the elements of pCommandBuffers must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commonparent)"}, - {VALIDATION_ERROR_1b200019, "The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-bufferlevel)"}, - {VALIDATION_ERROR_1b2000ae, "The spec valid usage text states 'commandBuffer must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_PRIMARY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00087)"}, - {VALIDATION_ERROR_1b2000b0, "The spec valid usage text states 'Each element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00088)"}, - {VALIDATION_ERROR_1b2000b2, "The spec valid usage text states 'Each element of pCommandBuffers must be in the pending or executable state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00089)"}, - {VALIDATION_ERROR_1b2000b4, "The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, and it was recorded into any other primary command buffer, that primary command buffer must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00090)"}, - {VALIDATION_ERROR_1b2000b6, "The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00091)"}, - {VALIDATION_ERROR_1b2000b8, "The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not have already been recorded to commandBuffer.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00092)"}, - {VALIDATION_ERROR_1b2000ba, "The spec valid usage text states 'If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not appear more than once in pCommandBuffers.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00093)"}, - {VALIDATION_ERROR_1b2000bc, "The spec valid usage text states 'Each element of pCommandBuffers must have been allocated from a VkCommandPool that was created for the same queue family as the VkCommandPool from which commandBuffer was allocated' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00094)"}, - {VALIDATION_ERROR_1b2000be, "The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of vkCmdBeginRenderPass set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-contents-00095)"}, - {VALIDATION_ERROR_1b2000c0, "The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00096)"}, - {VALIDATION_ERROR_1b2000c2, "The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00097)"}, - {VALIDATION_ERROR_1b2000c4, "The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, the render passes specified in the pname::pBeginInfo::pInheritanceInfo::renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be compatible with the current render pass.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pInheritanceInfo-00098)"}, - {VALIDATION_ERROR_1b2000c6, "The spec valid usage text states 'If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00099)"}, - {VALIDATION_ERROR_1b2000c8, "The spec valid usage text states 'If vkCmdExecuteCommands is not being called within a render pass instance, each element of pCommandBuffers must not have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00100)"}, - {VALIDATION_ERROR_1b2000ca, "The spec valid usage text states 'If the inherited queries feature is not enabled, commandBuffer must not have any queries active' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00101)"}, - {VALIDATION_ERROR_1b2000cc, "The spec valid usage text states 'If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00102)"}, - {VALIDATION_ERROR_1b2000ce, "The spec valid usage text states 'If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00103)"}, - {VALIDATION_ERROR_1b2000d0, "The spec valid usage text states 'If commandBuffer has a VK_QUERY_TYPE_PIPELINE_STATISTICS query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-00104)"}, - {VALIDATION_ERROR_1b2000d2, "The spec valid usage text states 'Each element of pCommandBuffers must not begin any query types that are active in commandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-00105)"}, - {VALIDATION_ERROR_1b200e38, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then each element of pCommandBuffers must be a protected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-01820)"}, - {VALIDATION_ERROR_1b200e3a, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then each element of pCommandBuffers must be an unprotected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-01821)"}, - {VALIDATION_ERROR_1b202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1b202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-recording)"}, - {VALIDATION_ERROR_1b202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1b20261b, "The spec valid usage text states 'commandBufferCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-commandBufferCount-arraylength)"}, - {VALIDATION_ERROR_1b211401, "The spec valid usage text states 'pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdExecuteCommands-pCommandBuffers-parameter)"}, - {VALIDATION_ERROR_1b400009, "The spec valid usage text states 'Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commonparent)"}, - {VALIDATION_ERROR_1b400017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-renderpass)"}, - {VALIDATION_ERROR_1b400030, "The spec valid usage text states 'dstOffset must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstOffset-00024)"}, - {VALIDATION_ERROR_1b400032, "The spec valid usage text states 'dstOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstOffset-00025)"}, - {VALIDATION_ERROR_1b400034, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-size-00026)"}, - {VALIDATION_ERROR_1b400036, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-size-00027)"}, - {VALIDATION_ERROR_1b400038, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-size-00028)"}, - {VALIDATION_ERROR_1b40003a, "The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstBuffer-00029)"}, - {VALIDATION_ERROR_1b40003c, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-00030)"}, - {VALIDATION_ERROR_1b40003e, "The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstBuffer-00031)"}, - {VALIDATION_ERROR_1b400e26, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-01811)"}, - {VALIDATION_ERROR_1b400e28, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-01812)"}, - {VALIDATION_ERROR_1b402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1b402413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-recording)"}, - {VALIDATION_ERROR_1b402415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1b406c01, "The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdFillBuffer-dstBuffer-parameter)"}, - {VALIDATION_ERROR_1b600017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-renderpass)"}, - {VALIDATION_ERROR_1b600019, "The spec valid usage text states 'commandBuffer must be a primary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-bufferlevel)"}, - {VALIDATION_ERROR_1b60071a, "The spec valid usage text states 'The current subpass index must be less than the number of subpasses in the render pass minus one' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-None-00909)"}, - {VALIDATION_ERROR_1b602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1b602413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-commandBuffer-recording)"}, - {VALIDATION_ERROR_1b602415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1b603201, "The spec valid usage text states 'contents must be a valid VkSubpassContents value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdNextSubpass-contents-parameter)"}, - {VALIDATION_ERROR_1b800920, "The spec valid usage text states 'If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01168)"}, - {VALIDATION_ERROR_1b800922, "The spec valid usage text states 'If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-01169)"}, - {VALIDATION_ERROR_1b800924, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01170)"}, - {VALIDATION_ERROR_1b800926, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-01171)"}, - {VALIDATION_ERROR_1b800928, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with a VkSubpassDependency instance in pDependencies that expresses a dependency from the current subpass to itself.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pDependencies-01172)"}, - {VALIDATION_ERROR_1b80092a, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, srcStageMask must contain a subset of the bit values in the srcStageMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01173)"}, - {VALIDATION_ERROR_1b80092c, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, dstStageMask must contain a subset of the bit values in the dstStageMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-01174)"}, - {VALIDATION_ERROR_1b80092e, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the srcAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the srcAccessMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcAccessMask-01175)"}, - {VALIDATION_ERROR_1b800930, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the dstAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the dstAccessMask member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstAccessMask-01176)"}, - {VALIDATION_ERROR_1b800932, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, dependencyFlags must be equal to the dependencyFlags member of that instance of VkSubpassDependency' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dependencyFlags-01177)"}, - {VALIDATION_ERROR_1b800934, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, bufferMemoryBarrierCount must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178)"}, - {VALIDATION_ERROR_1b800936, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the image member of any element of pImageMemoryBarriers must be equal to one of the elements of pAttachments that the current framebuffer was created with, that is also referred to by one of the elements of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-image-01179)"}, - {VALIDATION_ERROR_1b800938, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any element of pImageMemoryBarriers must be equal to the layout member of an element of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with, that refers to the same image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-oldLayout-01180)"}, - {VALIDATION_ERROR_1b80093a, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of an element of pImageMemoryBarriers must be equal' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-oldLayout-01181)"}, - {VALIDATION_ERROR_1b80093c, "The spec valid usage text states 'If vkCmdPipelineBarrier is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pImageMemoryBarriers must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182)"}, - {VALIDATION_ERROR_1b80093e, "The spec valid usage text states 'Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-01183)"}, - {VALIDATION_ERROR_1b800940, "The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184)"}, - {VALIDATION_ERROR_1b800942, "The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185)"}, - {VALIDATION_ERROR_1b800944, "The spec valid usage text states 'If vkCmdPipelineBarrier is called outside of a render pass instance, dependencyFlags must not include VK_DEPENDENCY_VIEW_LOCAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPipelineBarrier-dependencyFlags-01186)"}, - {VALIDATION_ERROR_1b802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1b802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-commandBuffer-recording)"}, - {VALIDATION_ERROR_1b802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1b803e01, "The spec valid usage text states 'dependencyFlags must be a valid combination of VkDependencyFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dependencyFlags-parameter)"}, - {VALIDATION_ERROR_1b807801, "The spec valid usage text states 'dstStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-parameter)"}, - {VALIDATION_ERROR_1b807803, "The spec valid usage text states 'dstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask)"}, - {VALIDATION_ERROR_1b810401, "The spec valid usage text states 'If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter)"}, - {VALIDATION_ERROR_1b818a01, "The spec valid usage text states 'If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter)"}, - {VALIDATION_ERROR_1b81ac01, "The spec valid usage text states 'If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter)"}, - {VALIDATION_ERROR_1b82d401, "The spec valid usage text states 'srcStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-parameter)"}, - {VALIDATION_ERROR_1b82d403, "The spec valid usage text states 'srcStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask)"}, - {VALIDATION_ERROR_1ba00017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-renderpass)"}, - {VALIDATION_ERROR_1ba02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1ba02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-commandBuffer-recording)"}, - {VALIDATION_ERROR_1ba02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1ba1f201, "The spec valid usage text states 'pProcessCommandsInfo must be a valid pointer to a valid VkCmdProcessCommandsInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdProcessCommandsNVX-pProcessCommandsInfo-parameter)"}, - {VALIDATION_ERROR_1bc00009, "The spec valid usage text states 'Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commonparent)"}, - {VALIDATION_ERROR_1bc002e0, "The spec valid usage text states 'offset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-00368)"}, - {VALIDATION_ERROR_1bc002e2, "The spec valid usage text states 'size must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-size-00369)"}, - {VALIDATION_ERROR_1bc002e4, "The spec valid usage text states 'offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-00370)"}, - {VALIDATION_ERROR_1bc002e6, "The spec valid usage text states 'size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-size-00371)"}, - {VALIDATION_ERROR_1bc00e06, "The spec valid usage text states 'For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-01795)"}, - {VALIDATION_ERROR_1bc00e08, "The spec valid usage text states 'For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range's VkPushConstantRange::stageFlags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-offset-01796)"}, - {VALIDATION_ERROR_1bc02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1bc02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commandBuffer-recording)"}, - {VALIDATION_ERROR_1bc02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1bc0be01, "The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-layout-parameter)"}, - {VALIDATION_ERROR_1bc26201, "The spec valid usage text states 'pValues must be a valid pointer to an array of size bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-pValues-parameter)"}, - {VALIDATION_ERROR_1bc2c21b, "The spec valid usage text states 'size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-size-arraylength)"}, - {VALIDATION_ERROR_1bc2dc01, "The spec valid usage text states 'stageFlags must be a valid combination of VkShaderStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-stageFlags-parameter)"}, - {VALIDATION_ERROR_1bc2dc03, "The spec valid usage text states 'stageFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdPushConstants-stageFlags-requiredbitmask)"}, - {VALIDATION_ERROR_1be00009, "The spec valid usage text states 'Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commonparent)"}, - {VALIDATION_ERROR_1be002d6, "The spec valid usage text states 'pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363)"}, - {VALIDATION_ERROR_1be002d8, "The spec valid usage text states 'set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-set-00364)"}, - {VALIDATION_ERROR_1be002da, "The spec valid usage text states 'set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-set-00365)"}, - {VALIDATION_ERROR_1be02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1be02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording)"}, - {VALIDATION_ERROR_1be02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1be0541b, "The spec valid usage text states 'descriptorWriteCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength)"}, - {VALIDATION_ERROR_1be0be01, "The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-layout-parameter)"}, - {VALIDATION_ERROR_1be13601, "The spec valid usage text states 'pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter)"}, - {VALIDATION_ERROR_1be27e01, "The spec valid usage text states 'pipelineBindPoint must be a valid VkPipelineBindPoint value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter)"}, - {VALIDATION_ERROR_1c000009, "The spec valid usage text states 'Each of commandBuffer, descriptorUpdateTemplate, and layout must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent)"}, - {VALIDATION_ERROR_1c0002dc, "The spec valid usage text states 'The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer's parent VkCommandPool's queue family' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366)"}, - {VALIDATION_ERROR_1c000d2c, "The spec valid usage text states 'pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplateKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686)"}, - {VALIDATION_ERROR_1c002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1c002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-recording)"}, - {VALIDATION_ERROR_1c002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1c005201, "The spec valid usage text states 'descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter)"}, - {VALIDATION_ERROR_1c00be01, "The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter)"}, - {VALIDATION_ERROR_1c200017, "The spec valid usage text states 'This command must only be called inside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-renderpass)"}, - {VALIDATION_ERROR_1c200019, "The spec valid usage text states 'commandBuffer must be a secondary VkCommandBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-bufferlevel)"}, - {VALIDATION_ERROR_1c200a62, "The spec valid usage text states 'The provided commandBuffer must not have had a prior space reservation since its creation or the last reset.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01329)"}, - {VALIDATION_ERROR_1c200a64, "The spec valid usage text states 'The state of the commandBuffer must be legal to execute all commands within the sequence provided by the indirectCommandsLayout member of pProcessCommandsInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01330)"}, - {VALIDATION_ERROR_1c202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1c202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-recording)"}, - {VALIDATION_ERROR_1c202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1c221a01, "The spec valid usage text states 'pReserveSpaceInfo must be a valid pointer to a valid VkCmdReserveSpaceForCommandsInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdReserveSpaceForCommandsNVX-pReserveSpaceInfo-parameter)"}, - {VALIDATION_ERROR_1c400009, "The spec valid usage text states 'Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commonparent)"}, - {VALIDATION_ERROR_1c400017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-renderpass)"}, - {VALIDATION_ERROR_1c400902, "The spec valid usage text states 'stageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-01153)"}, - {VALIDATION_ERROR_1c400904, "The spec valid usage text states 'If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-01154)"}, - {VALIDATION_ERROR_1c400906, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-01155)"}, - {VALIDATION_ERROR_1c400908, "The spec valid usage text states 'When this command executes, event must not be waited on by a vkCmdWaitEvents command that is currently executing' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-event-01156)"}, - {VALIDATION_ERROR_1c40090a, "The spec valid usage text states 'commandBuffer's current device mask must include exactly one physical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-01157)"}, - {VALIDATION_ERROR_1c402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1c402413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-recording)"}, - {VALIDATION_ERROR_1c402415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1c407e01, "The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-event-parameter)"}, - {VALIDATION_ERROR_1c42de01, "The spec valid usage text states 'stageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-parameter)"}, - {VALIDATION_ERROR_1c42de03, "The spec valid usage text states 'stageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetEvent-stageMask-requiredbitmask)"}, - {VALIDATION_ERROR_1c600009, "The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commonparent)"}, - {VALIDATION_ERROR_1c600017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-renderpass)"}, - {VALIDATION_ERROR_1c600638, "The spec valid usage text states 'firstQuery must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-firstQuery-00796)"}, - {VALIDATION_ERROR_1c60063a, "The spec valid usage text states 'The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-firstQuery-00797)"}, - {VALIDATION_ERROR_1c602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1c602413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commandBuffer-recording)"}, - {VALIDATION_ERROR_1c602415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1c629801, "The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResetQueryPool-queryPool-parameter)"}, - {VALIDATION_ERROR_1c800009, "The spec valid usage text states 'Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commonparent)"}, - {VALIDATION_ERROR_1c800017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-renderpass)"}, - {VALIDATION_ERROR_1c8001fa, "The spec valid usage text states 'The source region specified by each element of pRegions must be a region that is contained within srcImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-00253)"}, - {VALIDATION_ERROR_1c8001fc, "The spec valid usage text states 'The destination region specified by each element of pRegions must be a region that is contained within dstImage' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-00254)"}, - {VALIDATION_ERROR_1c8001fe, "The spec valid usage text states 'The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-00255)"}, - {VALIDATION_ERROR_1c800200, "The spec valid usage text states 'If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-00256)"}, - {VALIDATION_ERROR_1c800202, "The spec valid usage text states 'srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-00257)"}, - {VALIDATION_ERROR_1c800204, "The spec valid usage text states 'If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00258)"}, - {VALIDATION_ERROR_1c800206, "The spec valid usage text states 'dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00259)"}, - {VALIDATION_ERROR_1c800208, "The spec valid usage text states 'srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-00260)"}, - {VALIDATION_ERROR_1c80020a, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-00261)"}, - {VALIDATION_ERROR_1c80020c, "The spec valid usage text states 'dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-00262)"}, - {VALIDATION_ERROR_1c80020e, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-00263)"}, - {VALIDATION_ERROR_1c800210, "The spec valid usage text states 'If dstImage was created with tiling equal to VK_IMAGE_TILING_LINEAR, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00264)"}, - {VALIDATION_ERROR_1c800212, "The spec valid usage text states 'If dstImage was created with tiling equal to VK_IMAGE_TILING_OPTIMAL, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-00265)"}, - {VALIDATION_ERROR_1c800ad4, "The spec valid usage text states 'srcImage and dstImage must have been created with the same image format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-01386)"}, - {VALIDATION_ERROR_1c800af0, "The spec valid usage text states 'srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-01400)"}, - {VALIDATION_ERROR_1c800af2, "The spec valid usage text states 'dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-01401)"}, - {VALIDATION_ERROR_1c800d5a, "The spec valid usage text states 'The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcSubresource-01709)"}, - {VALIDATION_ERROR_1c800d5c, "The spec valid usage text states 'The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstSubresource-01710)"}, - {VALIDATION_ERROR_1c800d5e, "The spec valid usage text states 'The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcSubresource-01711)"}, - {VALIDATION_ERROR_1c800d60, "The spec valid usage text states 'The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstSubresource-01712)"}, - {VALIDATION_ERROR_1c800e5a, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-01837)"}, - {VALIDATION_ERROR_1c800e5c, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-01838)"}, - {VALIDATION_ERROR_1c800e5e, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-01839)"}, - {VALIDATION_ERROR_1c802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1c802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-recording)"}, - {VALIDATION_ERROR_1c802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1c807201, "The spec valid usage text states 'dstImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImage-parameter)"}, - {VALIDATION_ERROR_1c807401, "The spec valid usage text states 'dstImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-dstImageLayout-parameter)"}, - {VALIDATION_ERROR_1c821001, "The spec valid usage text states 'pRegions must be a valid pointer to an array of regionCount valid VkImageResolve structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-pRegions-parameter)"}, - {VALIDATION_ERROR_1c82ac1b, "The spec valid usage text states 'regionCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-regionCount-arraylength)"}, - {VALIDATION_ERROR_1c82ce01, "The spec valid usage text states 'srcImage must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImage-parameter)"}, - {VALIDATION_ERROR_1c82d001, "The spec valid usage text states 'srcImageLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdResolveImage-srcImageLayout-parameter)"}, - {VALIDATION_ERROR_1ca004c8, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_BLEND_CONSTANTS dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-None-00612)"}, - {VALIDATION_ERROR_1ca02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1ca02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-commandBuffer-recording)"}, - {VALIDATION_ERROR_1ca02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1cc0062a, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-None-00789)"}, - {VALIDATION_ERROR_1cc0062c, "The spec valid usage text states 'If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-depthBiasClamp-00790)"}, - {VALIDATION_ERROR_1cc02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1cc02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-commandBuffer-recording)"}, - {VALIDATION_ERROR_1cc02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBias-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1ce004ae, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-None-00599)"}, - {VALIDATION_ERROR_1ce004b0, "The spec valid usage text states 'Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDepthBounds-minDepthBounds-00600)"}, - {VALIDATION_ERROR_1ce004b2, "The spec valid usage text states 'Unless the VK_EXT_depth_range_unrestricted extension is enabled maxDepthBounds must be between 0.0 and 1.0, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDepthBounds-maxDepthBounds-00601)"}, - {VALIDATION_ERROR_1ce02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1ce02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-commandBuffer-recording)"}, - {VALIDATION_ERROR_1ce02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1d0000d8, "The spec valid usage text states 'deviceMask must be a valid device mask value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00108)"}, - {VALIDATION_ERROR_1d0000da, "The spec valid usage text states 'deviceMask must not be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00109)"}, - {VALIDATION_ERROR_1d0000dc, "The spec valid usage text states 'deviceMask must not include any set bits that were not in the VkDeviceGroupCommandBufferBeginInfo::deviceMask value when the command buffer began recording.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00110)"}, - {VALIDATION_ERROR_1d0000de, "The spec valid usage text states 'If vkCmdSetDeviceMask is called inside a render pass instance, deviceMask must not include any set bits that were not in the VkDeviceGroupRenderPassBeginInfo::deviceMask value when the render pass instance began recording.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-deviceMask-00111)"}, - {VALIDATION_ERROR_1d002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1d002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-commandBuffer-recording)"}, - {VALIDATION_ERROR_1d002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1d20048e, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-None-00583)"}, - {VALIDATION_ERROR_1d200492, "The spec valid usage text states 'The sum of firstDiscardRectangle and discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585)"}, - {VALIDATION_ERROR_1d200496, "The spec valid usage text states 'The x and y member of offset in each VkRect2D element of pDiscardRectangles must be greater than or equal to 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-x-00587)"}, - {VALIDATION_ERROR_1d200498, "The spec valid usage text states 'Evaluation of (offset.x + extent.width) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-offset-00588)"}, - {VALIDATION_ERROR_1d20049a, "The spec valid usage text states 'Evaluation of (offset.y + extent.height) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-offset-00589)"}, - {VALIDATION_ERROR_1d202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1d202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_1d202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1d205c1b, "The spec valid usage text states 'discardRectangleCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength)"}, - {VALIDATION_ERROR_1d214601, "The spec valid usage text states 'pDiscardRectangles must be a valid pointer to an array of discardRectangleCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter)"}, - {VALIDATION_ERROR_1d400009, "The spec valid usage text states 'Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commonparent)"}, - {VALIDATION_ERROR_1d400017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-renderpass)"}, - {VALIDATION_ERROR_1d4008fa, "The spec valid usage text states 'stageMask must not include VK_PIPELINE_STAGE_HOST_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-01149)"}, - {VALIDATION_ERROR_1d4008fc, "The spec valid usage text states 'If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-01150)"}, - {VALIDATION_ERROR_1d4008fe, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-01151)"}, - {VALIDATION_ERROR_1d400900, "The spec valid usage text states 'commandBuffer's current device mask must include exactly one physical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-01152)"}, - {VALIDATION_ERROR_1d402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1d402413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-recording)"}, - {VALIDATION_ERROR_1d402415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1d407e01, "The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-event-parameter)"}, - {VALIDATION_ERROR_1d42de01, "The spec valid usage text states 'stageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-parameter)"}, - {VALIDATION_ERROR_1d42de03, "The spec valid usage text states 'stageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetEvent-stageMask-requiredbitmask)"}, - {VALIDATION_ERROR_1d600626, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-None-00787)"}, - {VALIDATION_ERROR_1d600628, "The spec valid usage text states 'If the wide lines feature is not enabled, lineWidth must be 1.0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-lineWidth-00788)"}, - {VALIDATION_ERROR_1d602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1d602413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-recording)"}, - {VALIDATION_ERROR_1d602415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1d80049c, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-None-00590)"}, - {VALIDATION_ERROR_1d80049e, "The spec valid usage text states 'firstScissor must be less than VkPhysicalDeviceLimits::maxViewports' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-firstScissor-00591)"}, - {VALIDATION_ERROR_1d8004a0, "The spec valid usage text states 'The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-firstScissor-00592)"}, - {VALIDATION_ERROR_1d8004a2, "The spec valid usage text states 'If the multiple viewports feature is not enabled, firstScissor must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-firstScissor-00593)"}, - {VALIDATION_ERROR_1d8004a4, "The spec valid usage text states 'If the multiple viewports feature is not enabled, scissorCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-scissorCount-00594)"}, - {VALIDATION_ERROR_1d8004a6, "The spec valid usage text states 'The x and y members of offset must be greater than or equal to 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-x-00595)"}, - {VALIDATION_ERROR_1d8004a8, "The spec valid usage text states 'Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-offset-00596)"}, - {VALIDATION_ERROR_1d8004aa, "The spec valid usage text states 'Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-offset-00597)"}, - {VALIDATION_ERROR_1d802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1d802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-commandBuffer-recording)"}, - {VALIDATION_ERROR_1d802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1d822601, "The spec valid usage text states 'pScissors must be a valid pointer to an array of scissorCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-pScissors-parameter)"}, - {VALIDATION_ERROR_1d82b61b, "The spec valid usage text states 'scissorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetScissor-scissorCount-arraylength)"}, - {VALIDATION_ERROR_1da004b4, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-None-00602)"}, - {VALIDATION_ERROR_1da02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1da02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-commandBuffer-recording)"}, - {VALIDATION_ERROR_1da02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1da08401, "The spec valid usage text states 'faceMask must be a valid combination of VkStencilFaceFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-faceMask-parameter)"}, - {VALIDATION_ERROR_1da08403, "The spec valid usage text states 'faceMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask)"}, - {VALIDATION_ERROR_1dc004b8, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-None-00604)"}, - {VALIDATION_ERROR_1dc02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1dc02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-commandBuffer-recording)"}, - {VALIDATION_ERROR_1dc02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1dc08401, "The spec valid usage text states 'faceMask must be a valid combination of VkStencilFaceFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-faceMask-parameter)"}, - {VALIDATION_ERROR_1dc08403, "The spec valid usage text states 'faceMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilReference-faceMask-requiredbitmask)"}, - {VALIDATION_ERROR_1de004b6, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-None-00603)"}, - {VALIDATION_ERROR_1de02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1de02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-commandBuffer-recording)"}, - {VALIDATION_ERROR_1de02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1de08401, "The spec valid usage text states 'faceMask must be a valid combination of VkStencilFaceFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-faceMask-parameter)"}, - {VALIDATION_ERROR_1de08403, "The spec valid usage text states 'faceMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask)"}, - {VALIDATION_ERROR_1e00098a, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-None-01221)"}, - {VALIDATION_ERROR_1e00098c, "The spec valid usage text states 'firstViewport must be less than VkPhysicalDeviceLimits::maxViewports' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-firstViewport-01222)"}, - {VALIDATION_ERROR_1e00098e, "The spec valid usage text states 'The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-firstViewport-01223)"}, - {VALIDATION_ERROR_1e000990, "The spec valid usage text states 'If the multiple viewports feature is not enabled, firstViewport must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-firstViewport-01224)"}, - {VALIDATION_ERROR_1e000992, "The spec valid usage text states 'If the multiple viewports feature is not enabled, viewportCount must be 1' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-viewportCount-01225)"}, - {VALIDATION_ERROR_1e002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1e002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-commandBuffer-recording)"}, - {VALIDATION_ERROR_1e002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1e030a1b, "The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-viewportCount-arraylength)"}, - {VALIDATION_ERROR_1e03fa01, "The spec valid usage text states 'pViewports must be a valid pointer to an array of viewportCount VkViewport structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdSetViewport-pViewports-parameter)"}, - {VALIDATION_ERROR_1e200a54, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-None-01322)"}, - {VALIDATION_ERROR_1e200a56, "The spec valid usage text states 'firstViewport must be less than VkPhysicalDeviceLimits::maxViewports' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-firstViewport-01323)"}, - {VALIDATION_ERROR_1e200a58, "The spec valid usage text states 'The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-firstViewport-01324)"}, - {VALIDATION_ERROR_1e202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1e202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-commandBuffer-recording)"}, - {VALIDATION_ERROR_1e202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1e230a1b, "The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-viewportCount-arraylength)"}, - {VALIDATION_ERROR_1e23fc01, "The spec valid usage text states 'pViewportWScalings must be a valid pointer to an array of viewportCount VkViewportWScalingNV structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetViewportWScalingNV-pViewportWScalings-parameter)"}, - {VALIDATION_ERROR_1e400009, "The spec valid usage text states 'Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commonparent)"}, - {VALIDATION_ERROR_1e400017, "The spec valid usage text states 'This command must only be called outside of a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-renderpass)"}, - {VALIDATION_ERROR_1e400040, "The spec valid usage text states 'dstOffset must be less than the size of dstBuffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstOffset-00032)"}, - {VALIDATION_ERROR_1e400042, "The spec valid usage text states 'dataSize must be less than or equal to the size of dstBuffer minus dstOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-00033)"}, - {VALIDATION_ERROR_1e400044, "The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstBuffer-00034)"}, - {VALIDATION_ERROR_1e400046, "The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstBuffer-00035)"}, - {VALIDATION_ERROR_1e400048, "The spec valid usage text states 'dstOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstOffset-00036)"}, - {VALIDATION_ERROR_1e40004a, "The spec valid usage text states 'dataSize must be less than or equal to 65536' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-00037)"}, - {VALIDATION_ERROR_1e40004c, "The spec valid usage text states 'dataSize must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-00038)"}, - {VALIDATION_ERROR_1e400e2a, "The spec valid usage text states 'If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-01813)"}, - {VALIDATION_ERROR_1e400e2c, "The spec valid usage text states 'If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-01814)"}, - {VALIDATION_ERROR_1e402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1e402413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-recording)"}, - {VALIDATION_ERROR_1e402415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1e403c1b, "The spec valid usage text states 'dataSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dataSize-arraylength)"}, - {VALIDATION_ERROR_1e406c01, "The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-dstBuffer-parameter)"}, - {VALIDATION_ERROR_1e412201, "The spec valid usage text states 'pData must be a valid pointer to an array of dataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdUpdateBuffer-pData-parameter)"}, - {VALIDATION_ERROR_1e600009, "The spec valid usage text states 'Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commonparent)"}, - {VALIDATION_ERROR_1e60090c, "The spec valid usage text states 'srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the members of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the members of pEvents was set using vkSetEvent' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01158)"}, - {VALIDATION_ERROR_1e60090e, "The spec valid usage text states 'If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01159)"}, - {VALIDATION_ERROR_1e600910, "The spec valid usage text states 'If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-01160)"}, - {VALIDATION_ERROR_1e600912, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01161)"}, - {VALIDATION_ERROR_1e600914, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-01162)"}, - {VALIDATION_ERROR_1e600916, "The spec valid usage text states 'If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents must not be called inside a render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pEvents-01163)"}, - {VALIDATION_ERROR_1e600918, "The spec valid usage text states 'Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-01164)"}, - {VALIDATION_ERROR_1e60091a, "The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pMemoryBarriers-01165)"}, - {VALIDATION_ERROR_1e60091c, "The spec valid usage text states 'Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pMemoryBarriers-01166)"}, - {VALIDATION_ERROR_1e60091e, "The spec valid usage text states 'commandBuffer's current device mask must include exactly one physical device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-01167)"}, - {VALIDATION_ERROR_1e602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1e602413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-recording)"}, - {VALIDATION_ERROR_1e602415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1e607801, "The spec valid usage text states 'dstStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-parameter)"}, - {VALIDATION_ERROR_1e607803, "The spec valid usage text states 'dstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask)"}, - {VALIDATION_ERROR_1e60801b, "The spec valid usage text states 'eventCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-eventCount-arraylength)"}, - {VALIDATION_ERROR_1e610401, "The spec valid usage text states 'If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter)"}, - {VALIDATION_ERROR_1e616001, "The spec valid usage text states 'pEvents must be a valid pointer to an array of eventCount valid VkEvent handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pEvents-parameter)"}, - {VALIDATION_ERROR_1e618a01, "The spec valid usage text states 'If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter)"}, - {VALIDATION_ERROR_1e61ac01, "The spec valid usage text states 'If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-pMemoryBarriers-parameter)"}, - {VALIDATION_ERROR_1e62d401, "The spec valid usage text states 'srcStageMask must be a valid combination of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-parameter)"}, - {VALIDATION_ERROR_1e62d403, "The spec valid usage text states 'srcStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask)"}, - {VALIDATION_ERROR_1e800009, "The spec valid usage text states 'Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commonparent)"}, - {VALIDATION_ERROR_1e800678, "The spec valid usage text states 'The query identified by queryPool and query must be unavailable' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-queryPool-00828)"}, - {VALIDATION_ERROR_1e80067a, "The spec valid usage text states 'The command pool's queue family must support a non-zero timestampValidBits' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-timestampValidBits-00829)"}, - {VALIDATION_ERROR_1e80067c, "The spec valid usage text states 'All queries used by the command must be unavailable' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteTimestamp-None-00830)"}, - {VALIDATION_ERROR_1e80067e, "The spec valid usage text states 'If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass's view mask must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteTimestamp-query-00831)"}, - {VALIDATION_ERROR_1e800b10, "The spec valid usage text states 'queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-queryPool-01416)"}, - {VALIDATION_ERROR_1e802401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commandBuffer-parameter)"}, - {VALIDATION_ERROR_1e802413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commandBuffer-recording)"}, - {VALIDATION_ERROR_1e802415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_1e828401, "The spec valid usage text states 'pipelineStage must be a valid VkPipelineStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-pipelineStage-parameter)"}, - {VALIDATION_ERROR_1e829801, "The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCmdWriteTimestamp-queryPool-parameter)"}, - {VALIDATION_ERROR_1ea0bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_1ea0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_1ea11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkAndroidSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1ea24801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateAndroidSurfaceKHR-pSurface-parameter)"}, - {VALIDATION_ERROR_1ec0071e, "The spec valid usage text states 'If the flags member of pCreateInfo includes VK_BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-flags-00911)"}, - {VALIDATION_ERROR_1ec05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-device-parameter)"}, - {VALIDATION_ERROR_1ec0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-pAllocator-parameter)"}, - {VALIDATION_ERROR_1ec10001, "The spec valid usage text states 'pBuffer must be a valid pointer to a VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-pBuffer-parameter)"}, - {VALIDATION_ERROR_1ec11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkBufferCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBuffer-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1ee05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-device-parameter)"}, - {VALIDATION_ERROR_1ee0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-pAllocator-parameter)"}, - {VALIDATION_ERROR_1ee11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkBufferViewCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1ee26a01, "The spec valid usage text states 'pView must be a valid pointer to a VkBufferView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateBufferView-pView-parameter)"}, - {VALIDATION_ERROR_1f005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-device-parameter)"}, - {VALIDATION_ERROR_1f00ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-pAllocator-parameter)"}, - {VALIDATION_ERROR_1f011601, "The spec valid usage text states 'pCommandPool must be a valid pointer to a VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-pCommandPool-parameter)"}, - {VALIDATION_ERROR_1f011e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkCommandPoolCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateCommandPool-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1f20056e, "The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-flags-00695)"}, - {VALIDATION_ERROR_1f200570, "The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-flags-00696)"}, - {VALIDATION_ERROR_1f20381b, "The spec valid usage text states 'createInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-createInfoCount-arraylength)"}, - {VALIDATION_ERROR_1f205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-device-parameter)"}, - {VALIDATION_ERROR_1f20ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pAllocator-parameter)"}, - {VALIDATION_ERROR_1f212001, "The spec valid usage text states 'pCreateInfos must be a valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pCreateInfos-parameter)"}, - {VALIDATION_ERROR_1f21e201, "The spec valid usage text states 'pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pPipelines-parameter)"}, - {VALIDATION_ERROR_1f228001, "The spec valid usage text states 'If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pipelineCache-parameter)"}, - {VALIDATION_ERROR_1f228007, "The spec valid usage text states 'If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateComputePipelines-pipelineCache-parent)"}, - {VALIDATION_ERROR_1f40bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-instance-parameter)"}, - {VALIDATION_ERROR_1f40ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_1f410801, "The spec valid usage text states 'pCallback must be a valid pointer to a VkDebugReportCallbackEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-pCallback-parameter)"}, - {VALIDATION_ERROR_1f411e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDebugReportCallbackCreateInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugReportCallbackEXT-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1f605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-device-parameter)"}, - {VALIDATION_ERROR_1f60ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-pAllocator-parameter)"}, - {VALIDATION_ERROR_1f611e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorPoolCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1f612e01, "The spec valid usage text states 'pDescriptorPool must be a valid pointer to a VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorPool-pDescriptorPool-parameter)"}, - {VALIDATION_ERROR_1f805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-device-parameter)"}, - {VALIDATION_ERROR_1f80ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-pAllocator-parameter)"}, - {VALIDATION_ERROR_1f811e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1f822a01, "The spec valid usage text states 'pSetLayout must be a valid pointer to a VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter)"}, - {VALIDATION_ERROR_1fa05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-device-parameter)"}, - {VALIDATION_ERROR_1fa0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-pAllocator-parameter)"}, - {VALIDATION_ERROR_1fa11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorUpdateTemplateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1fa13401, "The spec valid usage text states 'pDescriptorUpdateTemplate must be a valid pointer to a VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDescriptorUpdateTemplate-pDescriptorUpdateTemplate-parameter)"}, - {VALIDATION_ERROR_1fc00ad6, "The spec valid usage text states 'All required extensions for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-ppEnabledExtensionNames-01387)"}, - {VALIDATION_ERROR_1fc0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-pAllocator-parameter)"}, - {VALIDATION_ERROR_1fc11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1fc13801, "The spec valid usage text states 'pDevice must be a valid pointer to a VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-pDevice-parameter)"}, - {VALIDATION_ERROR_1fc27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateDevice-physicalDevice-parameter)"}, - {VALIDATION_ERROR_1fe06001, "The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-display-parameter)"}, - {VALIDATION_ERROR_1fe0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_1fe11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDisplayModeCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_1fe1bc01, "The spec valid usage text states 'pMode must be a valid pointer to a VkDisplayModeKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-pMode-parameter)"}, - {VALIDATION_ERROR_1fe27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayModeKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2000bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_2000ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_20011e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDisplaySurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_20024801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter)"}, - {VALIDATION_ERROR_20205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-device-parameter)"}, - {VALIDATION_ERROR_2020ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-pAllocator-parameter)"}, - {VALIDATION_ERROR_20211e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkEventCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_20215e01, "The spec valid usage text states 'pEvent must be a valid pointer to a VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateEvent-pEvent-parameter)"}, - {VALIDATION_ERROR_20405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-device-parameter)"}, - {VALIDATION_ERROR_2040ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-pAllocator-parameter)"}, - {VALIDATION_ERROR_20411e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkFenceCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_20417001, "The spec valid usage text states 'pFence must be a valid pointer to a VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFence-pFence-parameter)"}, - {VALIDATION_ERROR_20605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-device-parameter)"}, - {VALIDATION_ERROR_2060ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-pAllocator-parameter)"}, - {VALIDATION_ERROR_20611e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_20617801, "The spec valid usage text states 'pFramebuffer must be a valid pointer to a VkFramebuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateFramebuffer-pFramebuffer-parameter)"}, - {VALIDATION_ERROR_208005a0, "The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-flags-00720)"}, - {VALIDATION_ERROR_208005a2, "The spec valid usage text states 'If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-flags-00721)"}, - {VALIDATION_ERROR_2080381b, "The spec valid usage text states 'createInfoCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength)"}, - {VALIDATION_ERROR_20805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-device-parameter)"}, - {VALIDATION_ERROR_2080ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pAllocator-parameter)"}, - {VALIDATION_ERROR_20812001, "The spec valid usage text states 'pCreateInfos must be a valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter)"}, - {VALIDATION_ERROR_2081e201, "The spec valid usage text states 'pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pPipelines-parameter)"}, - {VALIDATION_ERROR_20828001, "The spec valid usage text states 'If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pipelineCache-parameter)"}, - {VALIDATION_ERROR_20828007, "The spec valid usage text states 'If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateGraphicsPipelines-pipelineCache-parent)"}, - {VALIDATION_ERROR_20a0bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-instance-parameter)"}, - {VALIDATION_ERROR_20a0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-pAllocator-parameter)"}, - {VALIDATION_ERROR_20a11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkIOSSurfaceCreateInfoMVK structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_20a24801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIOSSurfaceMVK-pSurface-parameter)"}, - {VALIDATION_ERROR_20c00756, "The spec valid usage text states 'If the flags member of pCreateInfo includes VK_IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-flags-00939)"}, - {VALIDATION_ERROR_20c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-device-parameter)"}, - {VALIDATION_ERROR_20c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-pAllocator-parameter)"}, - {VALIDATION_ERROR_20c11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkImageCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_20c17e01, "The spec valid usage text states 'pImage must be a valid pointer to a VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImage-pImage-parameter)"}, - {VALIDATION_ERROR_20e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-device-parameter)"}, - {VALIDATION_ERROR_20e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-pAllocator-parameter)"}, - {VALIDATION_ERROR_20e11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkImageViewCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_20e26a01, "The spec valid usage text states 'pView must be a valid pointer to a VkImageView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateImageView-pView-parameter)"}, - {VALIDATION_ERROR_21005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter)"}, - {VALIDATION_ERROR_2100ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-pAllocator-parameter)"}, - {VALIDATION_ERROR_21011e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkIndirectCommandsLayoutCreateInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_21019201, "The spec valid usage text states 'pIndirectCommandsLayout must be a valid pointer to a VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateIndirectCommandsLayoutNVX-pIndirectCommandsLayout-parameter)"}, - {VALIDATION_ERROR_21200ad8, "The spec valid usage text states 'All required extensions for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-ppEnabledExtensionNames-01388)"}, - {VALIDATION_ERROR_2120ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-pAllocator-parameter)"}, - {VALIDATION_ERROR_21211e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_21219c01, "The spec valid usage text states 'pInstance must be a valid pointer to a VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateInstance-pInstance-parameter)"}, - {VALIDATION_ERROR_2140bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-instance-parameter)"}, - {VALIDATION_ERROR_2140ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-pAllocator-parameter)"}, - {VALIDATION_ERROR_21411e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkMacOSSurfaceCreateInfoMVK structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_21424801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMacOSSurfaceMVK-pSurface-parameter)"}, - {VALIDATION_ERROR_2160bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_2160ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_21611e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkMirSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_21624801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateMirSurfaceKHR-pSurface-parameter)"}, - {VALIDATION_ERROR_21805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-device-parameter)"}, - {VALIDATION_ERROR_2180ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-pAllocator-parameter)"}, - {VALIDATION_ERROR_21811e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkObjectTableCreateInfoNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_2181d001, "The spec valid usage text states 'pObjectTable must be a valid pointer to a VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateObjectTableNVX-pObjectTable-parameter)"}, - {VALIDATION_ERROR_21a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-device-parameter)"}, - {VALIDATION_ERROR_21a0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-pAllocator-parameter)"}, - {VALIDATION_ERROR_21a11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkPipelineCacheCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_21a1de01, "The spec valid usage text states 'pPipelineCache must be a valid pointer to a VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineCache-pPipelineCache-parameter)"}, - {VALIDATION_ERROR_21c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-device-parameter)"}, - {VALIDATION_ERROR_21c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-pAllocator-parameter)"}, - {VALIDATION_ERROR_21c11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkPipelineLayoutCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_21c1e001, "The spec valid usage text states 'pPipelineLayout must be a valid pointer to a VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreatePipelineLayout-pPipelineLayout-parameter)"}, - {VALIDATION_ERROR_21e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-device-parameter)"}, - {VALIDATION_ERROR_21e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-pAllocator-parameter)"}, - {VALIDATION_ERROR_21e11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkQueryPoolCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_21e1fa01, "The spec valid usage text states 'pQueryPool must be a valid pointer to a VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateQueryPool-pQueryPool-parameter)"}, - {VALIDATION_ERROR_22005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-device-parameter)"}, - {VALIDATION_ERROR_2200ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-pAllocator-parameter)"}, - {VALIDATION_ERROR_22011e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_22021601, "The spec valid usage text states 'pRenderPass must be a valid pointer to a VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateRenderPass-pRenderPass-parameter)"}, - {VALIDATION_ERROR_22205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-device-parameter)"}, - {VALIDATION_ERROR_2220ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-pAllocator-parameter)"}, - {VALIDATION_ERROR_22211e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSamplerCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_22222401, "The spec valid usage text states 'pSampler must be a valid pointer to a VkSampler handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSampler-pSampler-parameter)"}, - {VALIDATION_ERROR_22405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-device-parameter)"}, - {VALIDATION_ERROR_2240ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-pAllocator-parameter)"}, - {VALIDATION_ERROR_22411e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSemaphoreCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_22422801, "The spec valid usage text states 'pSemaphore must be a valid pointer to a VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateSemaphore-pSemaphore-parameter)"}, - {VALIDATION_ERROR_22605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-device-parameter)"}, - {VALIDATION_ERROR_2260ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-pAllocator-parameter)"}, - {VALIDATION_ERROR_22611e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkShaderModuleCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_22622e01, "The spec valid usage text states 'pShaderModule must be a valid pointer to a VkShaderModule handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkCreateShaderModule-pShaderModule-parameter)"}, - {VALIDATION_ERROR_22805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-device-parameter)"}, - {VALIDATION_ERROR_2280ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_22812001, "The spec valid usage text states 'pCreateInfos must be a valid pointer to an array of swapchainCount valid VkSwapchainCreateInfoKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter)"}, - {VALIDATION_ERROR_22825801, "The spec valid usage text states 'pSwapchains must be a valid pointer to an array of swapchainCount VkSwapchainKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter)"}, - {VALIDATION_ERROR_2282f21b, "The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength)"}, - {VALIDATION_ERROR_22a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-device-parameter)"}, - {VALIDATION_ERROR_22a0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_22a11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_22a25201, "The spec valid usage text states 'pSwapchain must be a valid pointer to a VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSwapchainKHR-pSwapchain-parameter)"}, - {VALIDATION_ERROR_22c0bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-instance-parameter)"}, - {VALIDATION_ERROR_22c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-pAllocator-parameter)"}, - {VALIDATION_ERROR_22c11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkViSurfaceCreateInfoNN structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_22c24801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateViSurfaceNN-pSurface-parameter)"}, - {VALIDATION_ERROR_22e0bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_22e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_22e11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkWaylandSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_22e24801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWaylandSurfaceKHR-pSurface-parameter)"}, - {VALIDATION_ERROR_2300bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_2300ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_23011e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkWin32SurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_23024801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateWin32SurfaceKHR-pSurface-parameter)"}, - {VALIDATION_ERROR_2320bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_2320ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_23211e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkXcbSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_23224801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXcbSurfaceKHR-pSurface-parameter)"}, - {VALIDATION_ERROR_2340bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_2340ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_23411e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkXlibSurfaceCreateInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_23424801, "The spec valid usage text states 'pSurface must be a valid pointer to a VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateXlibSurfaceKHR-pSurface-parameter)"}, - {VALIDATION_ERROR_23605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectNameEXT-device-parameter)"}, - {VALIDATION_ERROR_2361c201, "The spec valid usage text states 'pNameInfo must be a valid pointer to a valid VkDebugMarkerObjectNameInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectNameEXT-pNameInfo-parameter)"}, - {VALIDATION_ERROR_23805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectTagEXT-device-parameter)"}, - {VALIDATION_ERROR_23825c01, "The spec valid usage text states 'pTagInfo must be a valid pointer to a valid VkDebugMarkerObjectTagInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugMarkerSetObjectTagEXT-pTagInfo-parameter)"}, - {VALIDATION_ERROR_23a009b2, "The spec valid usage text states 'object must be a Vulkan object or VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-object-01241)"}, - {VALIDATION_ERROR_23a00bb4, "The spec valid usage text states 'If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in debug-report-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-objectType-01498)"}, - {VALIDATION_ERROR_23a09001, "The spec valid usage text states 'flags must be a valid combination of VkDebugReportFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-flags-parameter)"}, - {VALIDATION_ERROR_23a09003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-flags-requiredbitmask)"}, - {VALIDATION_ERROR_23a0bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-instance-parameter)"}, - {VALIDATION_ERROR_23a0da01, "The spec valid usage text states 'objectType must be a valid VkDebugReportObjectTypeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-objectType-parameter)"}, - {VALIDATION_ERROR_23a1a001, "The spec valid usage text states 'pLayerPrefix must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter)"}, - {VALIDATION_ERROR_23a1b801, "The spec valid usage text states 'pMessage must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDebugReportMessageEXT-pMessage-parameter)"}, - {VALIDATION_ERROR_23c00734, "The spec valid usage text states 'All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-00922)"}, - {VALIDATION_ERROR_23c00736, "The spec valid usage text states 'If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-00923)"}, - {VALIDATION_ERROR_23c00738, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-00924)"}, - {VALIDATION_ERROR_23c01a01, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-parameter)"}, - {VALIDATION_ERROR_23c01a07, "The spec valid usage text states 'If buffer is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-buffer-parent)"}, - {VALIDATION_ERROR_23c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-device-parameter)"}, - {VALIDATION_ERROR_23c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBuffer-pAllocator-parameter)"}, - {VALIDATION_ERROR_23e00750, "The spec valid usage text states 'All submitted commands that refer to bufferView must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-00936)"}, - {VALIDATION_ERROR_23e00752, "The spec valid usage text states 'If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-00937)"}, - {VALIDATION_ERROR_23e00754, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-00938)"}, - {VALIDATION_ERROR_23e01c01, "The spec valid usage text states 'If bufferView is not VK_NULL_HANDLE, bufferView must be a valid VkBufferView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-parameter)"}, - {VALIDATION_ERROR_23e01c07, "The spec valid usage text states 'If bufferView is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-bufferView-parent)"}, - {VALIDATION_ERROR_23e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-device-parameter)"}, - {VALIDATION_ERROR_23e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyBufferView-pAllocator-parameter)"}, - {VALIDATION_ERROR_24000052, "The spec valid usage text states 'All VkCommandBuffer objects allocated from commandPool must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-00041)"}, - {VALIDATION_ERROR_24000054, "The spec valid usage text states 'If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-00042)"}, - {VALIDATION_ERROR_24000056, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-00043)"}, - {VALIDATION_ERROR_24002801, "The spec valid usage text states 'If commandPool is not VK_NULL_HANDLE, commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-parameter)"}, - {VALIDATION_ERROR_24002807, "The spec valid usage text states 'If commandPool is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-commandPool-parent)"}, - {VALIDATION_ERROR_24005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-device-parameter)"}, - {VALIDATION_ERROR_2400ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyCommandPool-pAllocator-parameter)"}, - {VALIDATION_ERROR_242009b4, "The spec valid usage text states 'If VkAllocationCallbacks were provided when callback was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-instance-01242)"}, - {VALIDATION_ERROR_242009b6, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when callback was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-instance-01243)"}, - {VALIDATION_ERROR_24201e01, "The spec valid usage text states 'callback must be a valid VkDebugReportCallbackEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-callback-parameter)"}, - {VALIDATION_ERROR_24201e07, "The spec valid usage text states 'callback must have been created, allocated, or retrieved from instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-callback-parent)"}, - {VALIDATION_ERROR_2420bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-instance-parameter)"}, - {VALIDATION_ERROR_2420ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugReportCallbackEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_2440025e, "The spec valid usage text states 'All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-00303)"}, - {VALIDATION_ERROR_24400260, "The spec valid usage text states 'If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-00304)"}, - {VALIDATION_ERROR_24400262, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-00305)"}, - {VALIDATION_ERROR_24404601, "The spec valid usage text states 'If descriptorPool is not VK_NULL_HANDLE, descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-parameter)"}, - {VALIDATION_ERROR_24404607, "The spec valid usage text states 'If descriptorPool is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-descriptorPool-parent)"}, - {VALIDATION_ERROR_24405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-device-parameter)"}, - {VALIDATION_ERROR_2440ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorPool-pAllocator-parameter)"}, - {VALIDATION_ERROR_24600238, "The spec valid usage text states 'If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284)"}, - {VALIDATION_ERROR_2460023a, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285)"}, - {VALIDATION_ERROR_24604c01, "The spec valid usage text states 'If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter)"}, - {VALIDATION_ERROR_24604c07, "The spec valid usage text states 'If descriptorSetLayout is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent)"}, - {VALIDATION_ERROR_24605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-device-parameter)"}, - {VALIDATION_ERROR_2460ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDescriptorSetLayout-pAllocator-parameter)"}, - {VALIDATION_ERROR_248002c8, "The spec valid usage text states 'If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356)"}, - {VALIDATION_ERROR_248002ca, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357)"}, - {VALIDATION_ERROR_24805201, "The spec valid usage text states 'If descriptorUpdateTemplate is not VK_NULL_HANDLE, descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter)"}, - {VALIDATION_ERROR_24805207, "The spec valid usage text states 'If descriptorUpdateTemplate is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent)"}, - {VALIDATION_ERROR_24805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-device-parameter)"}, - {VALIDATION_ERROR_2480ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDescriptorUpdateTemplate-pAllocator-parameter)"}, - {VALIDATION_ERROR_24a002f4, "The spec valid usage text states 'All child objects created on device must have been destroyed prior to destroying device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-00378)"}, - {VALIDATION_ERROR_24a002f6, "The spec valid usage text states 'If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-00379)"}, - {VALIDATION_ERROR_24a002f8, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-00380)"}, - {VALIDATION_ERROR_24a05601, "The spec valid usage text states 'If device is not NULL, device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-device-parameter)"}, - {VALIDATION_ERROR_24a0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyDevice-pAllocator-parameter)"}, - {VALIDATION_ERROR_24c008f2, "The spec valid usage text states 'All submitted commands that refer to event must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-01145)"}, - {VALIDATION_ERROR_24c008f4, "The spec valid usage text states 'If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-01146)"}, - {VALIDATION_ERROR_24c008f6, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-01147)"}, - {VALIDATION_ERROR_24c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-device-parameter)"}, - {VALIDATION_ERROR_24c07e01, "The spec valid usage text states 'If event is not VK_NULL_HANDLE, event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-parameter)"}, - {VALIDATION_ERROR_24c07e07, "The spec valid usage text states 'If event is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-event-parent)"}, - {VALIDATION_ERROR_24c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyEvent-pAllocator-parameter)"}, - {VALIDATION_ERROR_24e008c0, "The spec valid usage text states 'All queue submission commands that refer to fence must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-01120)"}, - {VALIDATION_ERROR_24e008c2, "The spec valid usage text states 'If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-01121)"}, - {VALIDATION_ERROR_24e008c4, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-01122)"}, - {VALIDATION_ERROR_24e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-device-parameter)"}, - {VALIDATION_ERROR_24e08801, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-parameter)"}, - {VALIDATION_ERROR_24e08807, "The spec valid usage text states 'If fence is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-fence-parent)"}, - {VALIDATION_ERROR_24e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFence-pAllocator-parameter)"}, - {VALIDATION_ERROR_250006f8, "The spec valid usage text states 'All submitted commands that refer to framebuffer must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-00892)"}, - {VALIDATION_ERROR_250006fa, "The spec valid usage text states 'If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-00893)"}, - {VALIDATION_ERROR_250006fc, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-00894)"}, - {VALIDATION_ERROR_25005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-device-parameter)"}, - {VALIDATION_ERROR_25009401, "The spec valid usage text states 'If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-parameter)"}, - {VALIDATION_ERROR_25009407, "The spec valid usage text states 'If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-framebuffer-parent)"}, - {VALIDATION_ERROR_2500ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyFramebuffer-pAllocator-parameter)"}, - {VALIDATION_ERROR_252007d0, "The spec valid usage text states 'All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-01000)"}, - {VALIDATION_ERROR_252007d2, "The spec valid usage text states 'If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-01001)"}, - {VALIDATION_ERROR_252007d4, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-01002)"}, - {VALIDATION_ERROR_25205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-device-parameter)"}, - {VALIDATION_ERROR_2520a001, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-parameter)"}, - {VALIDATION_ERROR_2520a007, "The spec valid usage text states 'If image is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-image-parent)"}, - {VALIDATION_ERROR_2520ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImage-pAllocator-parameter)"}, - {VALIDATION_ERROR_25400804, "The spec valid usage text states 'All submitted commands that refer to imageView must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-01026)"}, - {VALIDATION_ERROR_25400806, "The spec valid usage text states 'If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-01027)"}, - {VALIDATION_ERROR_25400808, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-01028)"}, - {VALIDATION_ERROR_25405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-device-parameter)"}, - {VALIDATION_ERROR_2540b001, "The spec valid usage text states 'If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-parameter)"}, - {VALIDATION_ERROR_2540b007, "The spec valid usage text states 'If imageView is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-imageView-parent)"}, - {VALIDATION_ERROR_2540ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyImageView-pAllocator-parameter)"}, - {VALIDATION_ERROR_25600a90, "The spec valid usage text states 'All submitted commands that refer to indirectCommandsLayout must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-01352)"}, - {VALIDATION_ERROR_25600a92, "The spec valid usage text states 'If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01353)"}, - {VALIDATION_ERROR_25600a94, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01354)"}, - {VALIDATION_ERROR_25605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter)"}, - {VALIDATION_ERROR_2560b401, "The spec valid usage text states 'indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter)"}, - {VALIDATION_ERROR_2560b407, "The spec valid usage text states 'indirectCommandsLayout must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent)"}, - {VALIDATION_ERROR_2560ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyIndirectCommandsLayoutNVX-pAllocator-parameter)"}, - {VALIDATION_ERROR_258004ea, "The spec valid usage text states 'All child objects created using instance must have been destroyed prior to destroying instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-00629)"}, - {VALIDATION_ERROR_258004ec, "The spec valid usage text states 'If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-00630)"}, - {VALIDATION_ERROR_258004ee, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-00631)"}, - {VALIDATION_ERROR_2580bc01, "The spec valid usage text states 'If instance is not NULL, instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-instance-parameter)"}, - {VALIDATION_ERROR_2580ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyInstance-pAllocator-parameter)"}, - {VALIDATION_ERROR_25a00aa2, "The spec valid usage text states 'All submitted commands that refer to objectTable must have completed execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-01361)"}, - {VALIDATION_ERROR_25a00aa4, "The spec valid usage text states 'If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-01362)"}, - {VALIDATION_ERROR_25a00aa6, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-01363)"}, - {VALIDATION_ERROR_25a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-device-parameter)"}, - {VALIDATION_ERROR_25a0d801, "The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-parameter)"}, - {VALIDATION_ERROR_25a0d807, "The spec valid usage text states 'objectTable must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-objectTable-parent)"}, - {VALIDATION_ERROR_25a0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyObjectTableNVX-pAllocator-parameter)"}, - {VALIDATION_ERROR_25c005fa, "The spec valid usage text states 'All submitted commands that refer to pipeline must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-00765)"}, - {VALIDATION_ERROR_25c005fc, "The spec valid usage text states 'If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-00766)"}, - {VALIDATION_ERROR_25c005fe, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-00767)"}, - {VALIDATION_ERROR_25c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-device-parameter)"}, - {VALIDATION_ERROR_25c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pAllocator-parameter)"}, - {VALIDATION_ERROR_25c27c01, "The spec valid usage text states 'If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-parameter)"}, - {VALIDATION_ERROR_25c27c07, "The spec valid usage text states 'If pipeline is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipeline-pipeline-parent)"}, - {VALIDATION_ERROR_25e00606, "The spec valid usage text states 'If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-00771)"}, - {VALIDATION_ERROR_25e00608, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-00772)"}, - {VALIDATION_ERROR_25e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-device-parameter)"}, - {VALIDATION_ERROR_25e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pAllocator-parameter)"}, - {VALIDATION_ERROR_25e28001, "The spec valid usage text states 'If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-parameter)"}, - {VALIDATION_ERROR_25e28007, "The spec valid usage text states 'If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineCache-pipelineCache-parent)"}, - {VALIDATION_ERROR_26000256, "The spec valid usage text states 'If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-00299)"}, - {VALIDATION_ERROR_26000258, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-00300)"}, - {VALIDATION_ERROR_26005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-device-parameter)"}, - {VALIDATION_ERROR_2600ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pAllocator-parameter)"}, - {VALIDATION_ERROR_26028201, "The spec valid usage text states 'If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-parameter)"}, - {VALIDATION_ERROR_26028207, "The spec valid usage text states 'If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyPipelineLayout-pipelineLayout-parent)"}, - {VALIDATION_ERROR_26200632, "The spec valid usage text states 'All submitted commands that refer to queryPool must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-00793)"}, - {VALIDATION_ERROR_26200634, "The spec valid usage text states 'If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-00794)"}, - {VALIDATION_ERROR_26200636, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-00795)"}, - {VALIDATION_ERROR_26205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-device-parameter)"}, - {VALIDATION_ERROR_2620ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-pAllocator-parameter)"}, - {VALIDATION_ERROR_26229801, "The spec valid usage text states 'If queryPool is not VK_NULL_HANDLE, queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-parameter)"}, - {VALIDATION_ERROR_26229807, "The spec valid usage text states 'If queryPool is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyQueryPool-queryPool-parent)"}, - {VALIDATION_ERROR_264006d2, "The spec valid usage text states 'All submitted commands that refer to renderPass must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-00873)"}, - {VALIDATION_ERROR_264006d4, "The spec valid usage text states 'If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-00874)"}, - {VALIDATION_ERROR_264006d6, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-00875)"}, - {VALIDATION_ERROR_26405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-device-parameter)"}, - {VALIDATION_ERROR_2640ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-pAllocator-parameter)"}, - {VALIDATION_ERROR_2642ae01, "The spec valid usage text states 'If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-parameter)"}, - {VALIDATION_ERROR_2642ae07, "The spec valid usage text states 'If renderPass is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyRenderPass-renderPass-parent)"}, - {VALIDATION_ERROR_26600874, "The spec valid usage text states 'All submitted commands that refer to sampler must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-01082)"}, - {VALIDATION_ERROR_26600876, "The spec valid usage text states 'If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-01083)"}, - {VALIDATION_ERROR_26600878, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-01084)"}, - {VALIDATION_ERROR_26605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-device-parameter)"}, - {VALIDATION_ERROR_2660ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-pAllocator-parameter)"}, - {VALIDATION_ERROR_2662b201, "The spec valid usage text states 'If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-parameter)"}, - {VALIDATION_ERROR_2662b207, "The spec valid usage text states 'If sampler is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySampler-sampler-parent)"}, - {VALIDATION_ERROR_268008e2, "The spec valid usage text states 'All submitted batches that refer to semaphore must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-01137)"}, - {VALIDATION_ERROR_268008e4, "The spec valid usage text states 'If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-01138)"}, - {VALIDATION_ERROR_268008e6, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-01139)"}, - {VALIDATION_ERROR_26805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-device-parameter)"}, - {VALIDATION_ERROR_2680ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-pAllocator-parameter)"}, - {VALIDATION_ERROR_2682b801, "The spec valid usage text states 'If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-parameter)"}, - {VALIDATION_ERROR_2682b807, "The spec valid usage text states 'If semaphore is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroySemaphore-semaphore-parent)"}, - {VALIDATION_ERROR_26a00888, "The spec valid usage text states 'If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-01092)"}, - {VALIDATION_ERROR_26a0088a, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-01093)"}, - {VALIDATION_ERROR_26a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-device-parameter)"}, - {VALIDATION_ERROR_26a0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-pAllocator-parameter)"}, - {VALIDATION_ERROR_26a2be01, "The spec valid usage text states 'If shaderModule is not VK_NULL_HANDLE, shaderModule must be a valid VkShaderModule handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-parameter)"}, - {VALIDATION_ERROR_26a2be07, "The spec valid usage text states 'If shaderModule is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDestroyShaderModule-shaderModule-parent)"}, - {VALIDATION_ERROR_26c009e4, "The spec valid usage text states 'All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-01266)"}, - {VALIDATION_ERROR_26c009e6, "The spec valid usage text states 'If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-01267)"}, - {VALIDATION_ERROR_26c009e8, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-01268)"}, - {VALIDATION_ERROR_26c0bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-instance-parameter)"}, - {VALIDATION_ERROR_26c0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_26c2ec01, "The spec valid usage text states 'If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-parameter)"}, - {VALIDATION_ERROR_26c2ec07, "The spec valid usage text states 'If surface is a valid handle, it must have been created, allocated, or retrieved from instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySurfaceKHR-surface-parent)"}, - {VALIDATION_ERROR_26e00009, "The spec valid usage text states 'Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-commonparent)"}, - {VALIDATION_ERROR_26e00a04, "The spec valid usage text states 'All uses of presentable images acquired from swapchain must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-01282)"}, - {VALIDATION_ERROR_26e00a06, "The spec valid usage text states 'If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-01283)"}, - {VALIDATION_ERROR_26e00a08, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-01284)"}, - {VALIDATION_ERROR_26e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-device-parameter)"}, - {VALIDATION_ERROR_26e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-pAllocator-parameter)"}, - {VALIDATION_ERROR_26e2f001, "The spec valid usage text states 'If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySwapchainKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_27005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkDeviceWaitIdle-device-parameter)"}, - {VALIDATION_ERROR_27205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDisplayPowerControlEXT-device-parameter)"}, - {VALIDATION_ERROR_27206001, "The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDisplayPowerControlEXT-display-parameter)"}, - {VALIDATION_ERROR_27214e01, "The spec valid usage text states 'pDisplayPowerInfo must be a valid pointer to a valid VkDisplayPowerInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter)"}, - {VALIDATION_ERROR_27400076, "The spec valid usage text states 'commandBuffer must be in the recording state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00059)"}, - {VALIDATION_ERROR_27400078, "The spec valid usage text states 'If commandBuffer is a primary command buffer, there must not be an active render pass instance' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00060)"}, - {VALIDATION_ERROR_2740007a, "The spec valid usage text states 'All queries made active during the recording of commandBuffer must have been made inactive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00061)"}, - {VALIDATION_ERROR_2740007c, "The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-00062)"}, - {VALIDATION_ERROR_27400e2e, "The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-01815)"}, - {VALIDATION_ERROR_27402401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEndCommandBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_27619e01, "The spec valid usage text states 'If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter)"}, - {VALIDATION_ERROR_2761f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter)"}, - {VALIDATION_ERROR_2761f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_27627a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2781f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter)"}, - {VALIDATION_ERROR_2781f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_27827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_27a19e01, "The spec valid usage text states 'If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter)"}, - {VALIDATION_ERROR_27a1f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter)"}, - {VALIDATION_ERROR_27a1f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_27c1f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter)"}, - {VALIDATION_ERROR_27c1f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_27e0bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter)"}, - {VALIDATION_ERROR_27e1d801, "The spec valid usage text states 'pPhysicalDeviceGroupCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter)"}, - {VALIDATION_ERROR_27e1da01, "The spec valid usage text states 'If the value referenced by pPhysicalDeviceGroupCount is not 0, and pPhysicalDeviceGroupProperties is not NULL, pPhysicalDeviceGroupProperties must be a valid pointer to an array of pPhysicalDeviceGroupCount VkPhysicalDeviceGroupProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter)"}, - {VALIDATION_ERROR_2800bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumeratePhysicalDevices-instance-parameter)"}, - {VALIDATION_ERROR_2801d601, "The spec valid usage text states 'pPhysicalDeviceCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter)"}, - {VALIDATION_ERROR_2801dc01, "The spec valid usage text states 'If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter)"}, - {VALIDATION_ERROR_28205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFlushMappedMemoryRanges-device-parameter)"}, - {VALIDATION_ERROR_2820c81b, "The spec valid usage text states 'memoryRangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength)"}, - {VALIDATION_ERROR_2821b201, "The spec valid usage text states 'pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter)"}, - {VALIDATION_ERROR_2840005e, "The spec valid usage text states 'All elements of pCommandBuffers must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-pCommandBuffers-00047)"}, - {VALIDATION_ERROR_28400060, "The spec valid usage text states 'pCommandBuffers must be a valid pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-pCommandBuffers-00048)"}, - {VALIDATION_ERROR_2840261b, "The spec valid usage text states 'commandBufferCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-commandBufferCount-arraylength)"}, - {VALIDATION_ERROR_28402801, "The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-commandPool-parameter)"}, - {VALIDATION_ERROR_28402807, "The spec valid usage text states 'commandPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-commandPool-parent)"}, - {VALIDATION_ERROR_28405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-device-parameter)"}, - {VALIDATION_ERROR_28411407, "The spec valid usage text states 'Each element of pCommandBuffers that is a valid handle must have been created, allocated, or retrieved from commandPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeCommandBuffers-pCommandBuffers-parent)"}, - {VALIDATION_ERROR_2860026a, "The spec valid usage text states 'All submitted commands that refer to any element of pDescriptorSets must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-00309)"}, - {VALIDATION_ERROR_2860026c, "The spec valid usage text states 'pDescriptorSets must be a valid pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-00310)"}, - {VALIDATION_ERROR_2860026e, "The spec valid usage text states 'Each valid handle in pDescriptorSets must have been allocated from descriptorPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-00311)"}, - {VALIDATION_ERROR_28600270, "The spec valid usage text states 'descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorPool-00312)"}, - {VALIDATION_ERROR_28604601, "The spec valid usage text states 'descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorPool-parameter)"}, - {VALIDATION_ERROR_28604607, "The spec valid usage text states 'descriptorPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorPool-parent)"}, - {VALIDATION_ERROR_28604a1b, "The spec valid usage text states 'descriptorSetCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength)"}, - {VALIDATION_ERROR_28605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-device-parameter)"}, - {VALIDATION_ERROR_28613007, "The spec valid usage text states 'Each element of pDescriptorSets that is a valid handle must have been created, allocated, or retrieved from descriptorPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeDescriptorSets-pDescriptorSets-parent)"}, - {VALIDATION_ERROR_2880054a, "The spec valid usage text states 'All submitted commands that refer to memory (via images or buffers) must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-memory-00677)"}, - {VALIDATION_ERROR_28805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-device-parameter)"}, - {VALIDATION_ERROR_2880c601, "The spec valid usage text states 'If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-memory-parameter)"}, - {VALIDATION_ERROR_2880c607, "The spec valid usage text states 'If memory is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-memory-parent)"}, - {VALIDATION_ERROR_2880ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkFreeMemory-pAllocator-parameter)"}, - {VALIDATION_ERROR_28a01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-buffer-parameter)"}, - {VALIDATION_ERROR_28a01a07, "The spec valid usage text states 'buffer must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-buffer-parent)"}, - {VALIDATION_ERROR_28a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-device-parameter)"}, - {VALIDATION_ERROR_28a1b401, "The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter)"}, - {VALIDATION_ERROR_28c00566, "The spec valid usage text states 'heapIndex must be less than memoryHeapCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691)"}, - {VALIDATION_ERROR_28c00568, "The spec valid usage text states 'localDeviceIndex must be a valid device index' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692)"}, - {VALIDATION_ERROR_28c0056a, "The spec valid usage text states 'remoteDeviceIndex must be a valid device index' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693)"}, - {VALIDATION_ERROR_28c0056c, "The spec valid usage text states 'localDeviceIndex must not equal remoteDeviceIndex' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694)"}, - {VALIDATION_ERROR_28c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter)"}, - {VALIDATION_ERROR_28c1d401, "The spec valid usage text states 'pPeerMemoryFeatures must be a valid pointer to a VkPeerMemoryFeatureFlags value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter)"}, - {VALIDATION_ERROR_28c1d403, "The spec valid usage text states 'pPeerMemoryFeatures must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-requiredbitmask)"}, - {VALIDATION_ERROR_28e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter)"}, - {VALIDATION_ERROR_28e13c01, "The spec valid usage text states 'pDeviceGroupPresentCapabilities must be a valid pointer to a VkDeviceGroupPresentCapabilitiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter)"}, - {VALIDATION_ERROR_29000009, "The spec valid usage text states 'Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent)"}, - {VALIDATION_ERROR_29005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter)"}, - {VALIDATION_ERROR_2901be01, "The spec valid usage text states 'pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter)"}, - {VALIDATION_ERROR_2902ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter)"}, - {VALIDATION_ERROR_29200564, "The spec valid usage text states 'memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-memory-00690)"}, - {VALIDATION_ERROR_29205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-device-parameter)"}, - {VALIDATION_ERROR_2920c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-memory-parameter)"}, - {VALIDATION_ERROR_2920c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-memory-parent)"}, - {VALIDATION_ERROR_29211801, "The spec valid usage text states 'pCommittedMemoryInBytes must be a valid pointer to a VkDeviceSize value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter)"}, - {VALIDATION_ERROR_29405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceProcAddr-device-parameter)"}, - {VALIDATION_ERROR_2941c001, "The spec valid usage text states 'pName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceProcAddr-pName-parameter)"}, - {VALIDATION_ERROR_29600300, "The spec valid usage text states 'queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-queueFamilyIndex-00384)"}, - {VALIDATION_ERROR_29600302, "The spec valid usage text states 'queueIndex must be less than the number of queues created for the specified queue family index when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-queueIndex-00385)"}, - {VALIDATION_ERROR_29600e62, "The spec valid usage text states 'VkDeviceQueueCreateInfo::flags must have been set to zero when device was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-flags-01841)"}, - {VALIDATION_ERROR_29605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-device-parameter)"}, - {VALIDATION_ERROR_2961fc01, "The spec valid usage text states 'pQueue must be a valid pointer to a VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetDeviceQueue-pQueue-parameter)"}, - {VALIDATION_ERROR_29806001, "The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-display-parameter)"}, - {VALIDATION_ERROR_2981f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModePropertiesKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter)"}, - {VALIDATION_ERROR_2981f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_29827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_29a0ce01, "The spec valid usage text states 'mode must be a valid VkDisplayModeKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter)"}, - {VALIDATION_ERROR_29a10a01, "The spec valid usage text states 'pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilitiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter)"}, - {VALIDATION_ERROR_29a27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_29c009c2, "The spec valid usage text states 'planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249)"}, - {VALIDATION_ERROR_29c14a01, "The spec valid usage text states 'pDisplayCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter)"}, - {VALIDATION_ERROR_29c15201, "The spec valid usage text states 'If the value referenced by pDisplayCount is not 0, and pDisplays is not NULL, pDisplays must be a valid pointer to an array of pDisplayCount VkDisplayKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter)"}, - {VALIDATION_ERROR_29c27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_29e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetEventStatus-device-parameter)"}, - {VALIDATION_ERROR_29e07e01, "The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetEventStatus-event-parameter)"}, - {VALIDATION_ERROR_29e07e07, "The spec valid usage text states 'event must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetEventStatus-event-parent)"}, - {VALIDATION_ERROR_2a005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceStatus-device-parameter)"}, - {VALIDATION_ERROR_2a008801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceStatus-fence-parameter)"}, - {VALIDATION_ERROR_2a008807, "The spec valid usage text states 'fence must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceStatus-fence-parent)"}, - {VALIDATION_ERROR_2a200c68, "The spec valid usage text states 'image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements-image-01588)"}, - {VALIDATION_ERROR_2a205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-device-parameter)"}, - {VALIDATION_ERROR_2a20a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-image-parameter)"}, - {VALIDATION_ERROR_2a20a007, "The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-image-parent)"}, - {VALIDATION_ERROR_2a21b401, "The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter)"}, - {VALIDATION_ERROR_2a405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-device-parameter)"}, - {VALIDATION_ERROR_2a40a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-image-parameter)"}, - {VALIDATION_ERROR_2a40a007, "The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-image-parent)"}, - {VALIDATION_ERROR_2a423601, "The spec valid usage text states 'pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirementCount-parameter)"}, - {VALIDATION_ERROR_2a423801, "The spec valid usage text states 'If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirements-parameter)"}, - {VALIDATION_ERROR_2a6007c8, "The spec valid usage text states 'image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-00996)"}, - {VALIDATION_ERROR_2a6007ca, "The spec valid usage text states 'The aspectMask member of pSubresource must only have a single bit set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-aspectMask-00997)"}, - {VALIDATION_ERROR_2a600c5a, "The spec valid usage text states 'If the format of image is a multi-planar format with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSubresourceLayout-format-01581)"}, - {VALIDATION_ERROR_2a600c5c, "The spec valid usage text states 'If the format of image is a multi-planar format with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSubresourceLayout-format-01582)"}, - {VALIDATION_ERROR_2a600d68, "The spec valid usage text states 'The mipLevel member of pSubresource must be less than the mipLevels specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-mipLevel-01716)"}, - {VALIDATION_ERROR_2a600d6a, "The spec valid usage text states 'The arrayLayer member of pSubresource must be less than the arrayLayers specified in VkImageCreateInfo when image was created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-arrayLayer-01717)"}, - {VALIDATION_ERROR_2a600ece, "The spec valid usage text states 'If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-01895)"}, - {VALIDATION_ERROR_2a605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-device-parameter)"}, - {VALIDATION_ERROR_2a60a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-parameter)"}, - {VALIDATION_ERROR_2a60a007, "The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-image-parent)"}, - {VALIDATION_ERROR_2a61a201, "The spec valid usage text states 'pLayout must be a valid pointer to a VkSubresourceLayout structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-pLayout-parameter)"}, - {VALIDATION_ERROR_2a624401, "The spec valid usage text states 'pSubresource must be a valid pointer to a valid VkImageSubresource structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-pSubresource-parameter)"}, - {VALIDATION_ERROR_2a80bc01, "The spec valid usage text states 'If instance is not NULL, instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetInstanceProcAddr-instance-parameter)"}, - {VALIDATION_ERROR_2a81c001, "The spec valid usage text states 'pName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetInstanceProcAddr-pName-parameter)"}, - {VALIDATION_ERROR_2aa05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdKHR-device-parameter)"}, - {VALIDATION_ERROR_2aa16c01, "The spec valid usage text states 'pFd must be a valid pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdKHR-pFd-parameter)"}, - {VALIDATION_ERROR_2aa39e01, "The spec valid usage text states 'pGetFdInfo must be a valid pointer to a valid VkMemoryGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter)"}, - {VALIDATION_ERROR_2ac00542, "The spec valid usage text states 'fd must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-fd-00673)"}, - {VALIDATION_ERROR_2ac00544, "The spec valid usage text states 'handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-handleType-00674)"}, - {VALIDATION_ERROR_2ac05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-device-parameter)"}, - {VALIDATION_ERROR_2ac09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter)"}, - {VALIDATION_ERROR_2ac1ae01, "The spec valid usage text states 'pMemoryFdProperties must be a valid pointer to a VkMemoryFdPropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter)"}, - {VALIDATION_ERROR_2ae05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-device-parameter)"}, - {VALIDATION_ERROR_2ae17c01, "The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter)"}, - {VALIDATION_ERROR_2ae3a001, "The spec valid usage text states 'pGetWin32HandleInfo must be a valid pointer to a valid VkMemoryGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter)"}, - {VALIDATION_ERROR_2b000a5c, "The spec valid usage text states 'handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-01326)"}, - {VALIDATION_ERROR_2b005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-device-parameter)"}, - {VALIDATION_ERROR_2b009c01, "The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-parameter)"}, - {VALIDATION_ERROR_2b009c03, "The spec valid usage text states 'handleType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask)"}, - {VALIDATION_ERROR_2b00c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-memory-parameter)"}, - {VALIDATION_ERROR_2b00c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-memory-parent)"}, - {VALIDATION_ERROR_2b017c01, "The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-pHandle-parameter)"}, - {VALIDATION_ERROR_2b200532, "The spec valid usage text states 'handle must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665)"}, - {VALIDATION_ERROR_2b200534, "The spec valid usage text states 'handleType must not be one of the handle types defined as opaque.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666)"}, - {VALIDATION_ERROR_2b205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter)"}, - {VALIDATION_ERROR_2b209c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter)"}, - {VALIDATION_ERROR_2b21b601, "The spec valid usage text states 'pMemoryWin32HandleProperties must be a valid pointer to a VkMemoryWin32HandlePropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter)"}, - {VALIDATION_ERROR_2b400009, "The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-commonparent)"}, - {VALIDATION_ERROR_2b405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-device-parameter)"}, - {VALIDATION_ERROR_2b41ec01, "The spec valid usage text states 'pPresentationTimingCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter)"}, - {VALIDATION_ERROR_2b41ee01, "The spec valid usage text states 'If the value referenced by pPresentationTimingCount is not 0, and pPresentationTimings is not NULL, pPresentationTimings must be a valid pointer to an array of pPresentationTimingCount VkPastPresentationTimingGOOGLE structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter)"}, - {VALIDATION_ERROR_2b42f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter)"}, - {VALIDATION_ERROR_2b61f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlanePropertiesKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter)"}, - {VALIDATION_ERROR_2b61f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_2b627a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2b81f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter)"}, - {VALIDATION_ERROR_2b81f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_2b827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ba16201, "The spec valid usage text states 'pExternalBufferInfo must be a valid pointer to a valid VkPhysicalDeviceExternalBufferInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter)"}, - {VALIDATION_ERROR_2ba16401, "The spec valid usage text states 'pExternalBufferProperties must be a valid pointer to a VkExternalBufferProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter)"}, - {VALIDATION_ERROR_2ba27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2bc08201, "The spec valid usage text states 'externalHandleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter)"}, - {VALIDATION_ERROR_2bc09001, "The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter)"}, - {VALIDATION_ERROR_2bc09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter)"}, - {VALIDATION_ERROR_2bc16601, "The spec valid usage text states 'pExternalImageFormatProperties must be a valid pointer to a VkExternalImageFormatPropertiesNV structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter)"}, - {VALIDATION_ERROR_2bc27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2bc2fa01, "The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter)"}, - {VALIDATION_ERROR_2bc30401, "The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter)"}, - {VALIDATION_ERROR_2bc30601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter)"}, - {VALIDATION_ERROR_2bc30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask)"}, - {VALIDATION_ERROR_2be16801, "The spec valid usage text states 'pExternalSemaphoreInfo must be a valid pointer to a valid VkPhysicalDeviceExternalSemaphoreInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter)"}, - {VALIDATION_ERROR_2be16a01, "The spec valid usage text states 'pExternalSemaphoreProperties must be a valid pointer to a VkExternalSemaphoreProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter)"}, - {VALIDATION_ERROR_2be27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2c016e01, "The spec valid usage text states 'pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter)"}, - {VALIDATION_ERROR_2c027a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2c216e01, "The spec valid usage text states 'pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter)"}, - {VALIDATION_ERROR_2c227a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2c409201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties-format-parameter)"}, - {VALIDATION_ERROR_2c417601, "The spec valid usage text states 'pFormatProperties must be a valid pointer to a VkFormatProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter)"}, - {VALIDATION_ERROR_2c427a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2c609201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter)"}, - {VALIDATION_ERROR_2c617601, "The spec valid usage text states 'pFormatProperties must be a valid pointer to a VkFormatProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter)"}, - {VALIDATION_ERROR_2c627a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2c816e01, "The spec valid usage text states 'pFeatures must be a valid pointer to a VkDeviceGeneratedCommandsFeaturesNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pFeatures-parameter)"}, - {VALIDATION_ERROR_2c81a401, "The spec valid usage text states 'pLimits must be a valid pointer to a VkDeviceGeneratedCommandsLimitsNVX structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pLimits-parameter)"}, - {VALIDATION_ERROR_2c827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ca09001, "The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter)"}, - {VALIDATION_ERROR_2ca09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter)"}, - {VALIDATION_ERROR_2ca18401, "The spec valid usage text states 'pImageFormatProperties must be a valid pointer to a VkImageFormatProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter)"}, - {VALIDATION_ERROR_2ca27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ca2fa01, "The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter)"}, - {VALIDATION_ERROR_2ca30401, "The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter)"}, - {VALIDATION_ERROR_2ca30601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter)"}, - {VALIDATION_ERROR_2ca30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask)"}, - {VALIDATION_ERROR_2cc00e98, "The spec valid usage text states 'If the pNext chain of pImageFormatProperties contains an instance of VkAndroidHardwareBufferUsageANDROID, the pNext chain of pImageFormatInfo must contain an instance of VkPhysicalDeviceExternalImageFormatInfo with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868)"}, - {VALIDATION_ERROR_2cc18201, "The spec valid usage text states 'pImageFormatInfo must be a valid pointer to a valid VkPhysicalDeviceImageFormatInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter)"}, - {VALIDATION_ERROR_2cc18401, "The spec valid usage text states 'pImageFormatProperties must be a valid pointer to a VkImageFormatProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter)"}, - {VALIDATION_ERROR_2cc27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ce1b001, "The spec valid usage text states 'pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter)"}, - {VALIDATION_ERROR_2ce27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2d01b001, "The spec valid usage text states 'pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter)"}, - {VALIDATION_ERROR_2d027a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2d2009e2, "The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-queueFamilyIndex-01265)"}, - {VALIDATION_ERROR_2d203001, "The spec valid usage text states 'connection must be a valid pointer to a MirConnection value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-connection-parameter)"}, - {VALIDATION_ERROR_2d227a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2d400009, "The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent)"}, - {VALIDATION_ERROR_2d420a01, "The spec valid usage text states 'pRectCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter)"}, - {VALIDATION_ERROR_2d420e01, "The spec valid usage text states 'If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter)"}, - {VALIDATION_ERROR_2d427a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2d42ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter)"}, - {VALIDATION_ERROR_2d61f401, "The spec valid usage text states 'pProperties must be a valid pointer to a VkPhysicalDeviceProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties-pProperties-parameter)"}, - {VALIDATION_ERROR_2d627a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2d81f401, "The spec valid usage text states 'pProperties must be a valid pointer to a VkPhysicalDeviceProperties2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter)"}, - {VALIDATION_ERROR_2d827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2da20001, "The spec valid usage text states 'If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter)"}, - {VALIDATION_ERROR_2da20201, "The spec valid usage text states 'pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter)"}, - {VALIDATION_ERROR_2da27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2dc20001, "The spec valid usage text states 'If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties2 structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter)"}, - {VALIDATION_ERROR_2dc20201, "The spec valid usage text states 'pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter)"}, - {VALIDATION_ERROR_2dc27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2de0088c, "The spec valid usage text states 'samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094)"}, - {VALIDATION_ERROR_2de09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter)"}, - {VALIDATION_ERROR_2de1f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter)"}, - {VALIDATION_ERROR_2de1f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_2de27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2de2b401, "The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter)"}, - {VALIDATION_ERROR_2de2fa01, "The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter)"}, - {VALIDATION_ERROR_2de30401, "The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter)"}, - {VALIDATION_ERROR_2de30601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter)"}, - {VALIDATION_ERROR_2de30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask)"}, - {VALIDATION_ERROR_2e017401, "The spec valid usage text states 'pFormatInfo must be a valid pointer to a valid VkPhysicalDeviceSparseImageFormatInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pFormatInfo-parameter)"}, - {VALIDATION_ERROR_2e01f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties2 structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pProperties-parameter)"}, - {VALIDATION_ERROR_2e01f601, "The spec valid usage text states 'pPropertyCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pPropertyCount-parameter)"}, - {VALIDATION_ERROR_2e027a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2e200009, "The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent)"}, - {VALIDATION_ERROR_2e224a01, "The spec valid usage text states 'pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2EXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter)"}, - {VALIDATION_ERROR_2e227a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2e22ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter)"}, - {VALIDATION_ERROR_2e424a01, "The spec valid usage text states 'pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter)"}, - {VALIDATION_ERROR_2e425001, "The spec valid usage text states 'pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter)"}, - {VALIDATION_ERROR_2e427a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2e600009, "The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent)"}, - {VALIDATION_ERROR_2e624a01, "The spec valid usage text states 'pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilitiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter)"}, - {VALIDATION_ERROR_2e627a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2e62ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter)"}, - {VALIDATION_ERROR_2e824c01, "The spec valid usage text states 'pSurfaceFormatCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter)"}, - {VALIDATION_ERROR_2e824e01, "The spec valid usage text states 'If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormat2KHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter)"}, - {VALIDATION_ERROR_2e825001, "The spec valid usage text states 'pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter)"}, - {VALIDATION_ERROR_2e827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ea00009, "The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent)"}, - {VALIDATION_ERROR_2ea24c01, "The spec valid usage text states 'pSurfaceFormatCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter)"}, - {VALIDATION_ERROR_2ea24e01, "The spec valid usage text states 'If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormatKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter)"}, - {VALIDATION_ERROR_2ea27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ea2ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter)"}, - {VALIDATION_ERROR_2ec00009, "The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent)"}, - {VALIDATION_ERROR_2ec1e801, "The spec valid usage text states 'pPresentModeCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter)"}, - {VALIDATION_ERROR_2ec1ea01, "The spec valid usage text states 'If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter)"}, - {VALIDATION_ERROR_2ec27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ec2ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter)"}, - {VALIDATION_ERROR_2ee00009, "The spec valid usage text states 'Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent)"}, - {VALIDATION_ERROR_2ee009ea, "The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269)"}, - {VALIDATION_ERROR_2ee24601, "The spec valid usage text states 'pSupported must be a valid pointer to a VkBool32 value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter)"}, - {VALIDATION_ERROR_2ee27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ee2ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter)"}, - {VALIDATION_ERROR_2f000a34, "The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306)"}, - {VALIDATION_ERROR_2f006001, "The spec valid usage text states 'display must be a valid pointer to a wl_display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-display-parameter)"}, - {VALIDATION_ERROR_2f027a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2f200a3a, "The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309)"}, - {VALIDATION_ERROR_2f227a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2f400a40, "The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312)"}, - {VALIDATION_ERROR_2f403001, "The spec valid usage text states 'connection must be a valid pointer to a xcb_connection_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-connection-parameter)"}, - {VALIDATION_ERROR_2f427a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2f600a46, "The spec valid usage text states 'queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315)"}, - {VALIDATION_ERROR_2f606601, "The spec valid usage text states 'dpy must be a valid pointer to a Display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-dpy-parameter)"}, - {VALIDATION_ERROR_2f627a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2f805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-device-parameter)"}, - {VALIDATION_ERROR_2f812201, "The spec valid usage text states 'If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pData-parameter)"}, - {VALIDATION_ERROR_2f812401, "The spec valid usage text states 'pDataSize must be a valid pointer to a size_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pDataSize-parameter)"}, - {VALIDATION_ERROR_2f828001, "The spec valid usage text states 'pipelineCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pipelineCache-parameter)"}, - {VALIDATION_ERROR_2f828007, "The spec valid usage text states 'pipelineCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPipelineCacheData-pipelineCache-parent)"}, - {VALIDATION_ERROR_2fa0065a, "The spec valid usage text states 'firstQuery must be less than the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-firstQuery-00813)"}, - {VALIDATION_ERROR_2fa0065c, "The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is not set in flags then pData and stride must be multiples of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-flags-00814)"}, - {VALIDATION_ERROR_2fa0065e, "The spec valid usage text states 'If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-flags-00815)"}, - {VALIDATION_ERROR_2fa00660, "The spec valid usage text states 'The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-firstQuery-00816)"}, - {VALIDATION_ERROR_2fa00662, "The spec valid usage text states 'dataSize must be large enough to contain the result of each query, as described here' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-dataSize-00817)"}, - {VALIDATION_ERROR_2fa00664, "The spec valid usage text states 'If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-queryType-00818)"}, - {VALIDATION_ERROR_2fa03c1b, "The spec valid usage text states 'dataSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-dataSize-arraylength)"}, - {VALIDATION_ERROR_2fa05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-device-parameter)"}, - {VALIDATION_ERROR_2fa09001, "The spec valid usage text states 'flags must be a valid combination of VkQueryResultFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-flags-parameter)"}, - {VALIDATION_ERROR_2fa12201, "The spec valid usage text states 'pData must be a valid pointer to an array of dataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-pData-parameter)"}, - {VALIDATION_ERROR_2fa29801, "The spec valid usage text states 'queryPool must be a valid VkQueryPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-queryPool-parameter)"}, - {VALIDATION_ERROR_2fa29807, "The spec valid usage text states 'queryPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetQueryPoolResults-queryPool-parent)"}, - {VALIDATION_ERROR_2fc06601, "The spec valid usage text states 'dpy must be a valid pointer to a Display value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRandROutputDisplayEXT-dpy-parameter)"}, - {VALIDATION_ERROR_2fc14801, "The spec valid usage text states 'pDisplay must be a valid pointer to a VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRandROutputDisplayEXT-pDisplay-parameter)"}, - {VALIDATION_ERROR_2fc27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2fe00009, "The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-commonparent)"}, - {VALIDATION_ERROR_2fe05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter)"}, - {VALIDATION_ERROR_2fe15001, "The spec valid usage text states 'pDisplayTimingProperties must be a valid pointer to a VkRefreshCycleDurationGOOGLE structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-pDisplayTimingProperties-parameter)"}, - {VALIDATION_ERROR_2fe2f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter)"}, - {VALIDATION_ERROR_30005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-device-parameter)"}, - {VALIDATION_ERROR_30017a01, "The spec valid usage text states 'pGranularity must be a valid pointer to a VkExtent2D structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-pGranularity-parameter)"}, - {VALIDATION_ERROR_3002ae01, "The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-renderPass-parameter)"}, - {VALIDATION_ERROR_3002ae07, "The spec valid usage text states 'renderPass must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-renderPass-parent)"}, - {VALIDATION_ERROR_30205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-device-parameter)"}, - {VALIDATION_ERROR_30216c01, "The spec valid usage text states 'pFd must be a valid pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-pFd-parameter)"}, - {VALIDATION_ERROR_30239e01, "The spec valid usage text states 'pGetFdInfo must be a valid pointer to a valid VkSemaphoreGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter)"}, - {VALIDATION_ERROR_30405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-device-parameter)"}, - {VALIDATION_ERROR_30417c01, "The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter)"}, - {VALIDATION_ERROR_3043a001, "The spec valid usage text states 'pGetWin32HandleInfo must be a valid pointer to a valid VkSemaphoreGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter)"}, - {VALIDATION_ERROR_30600009, "The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-commonparent)"}, - {VALIDATION_ERROR_306009ba, "The spec valid usage text states 'One or more present commands on swapchain must have been processed by the presentation engine.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-swapchain-01245)"}, - {VALIDATION_ERROR_30603601, "The spec valid usage text states 'counter must be a valid VkSurfaceCounterFlagBitsEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-counter-parameter)"}, - {VALIDATION_ERROR_30605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-device-parameter)"}, - {VALIDATION_ERROR_30611c01, "The spec valid usage text states 'pCounterValue must be a valid pointer to a uint64_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter)"}, - {VALIDATION_ERROR_3062f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-swapchain-parameter)"}, - {VALIDATION_ERROR_30800009, "The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-commonparent)"}, - {VALIDATION_ERROR_30805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-device-parameter)"}, - {VALIDATION_ERROR_30825401, "The spec valid usage text states 'pSwapchainImageCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter)"}, - {VALIDATION_ERROR_30825601, "The spec valid usage text states 'If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter)"}, - {VALIDATION_ERROR_3082f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_30a00009, "The spec valid usage text states 'Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-commonparent)"}, - {VALIDATION_ERROR_30a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-device-parameter)"}, - {VALIDATION_ERROR_30a2f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_30c008ec, "The spec valid usage text states 'semaphore must not be associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-semaphore-01142)"}, - {VALIDATION_ERROR_30c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-device-parameter)"}, - {VALIDATION_ERROR_30c18e01, "The spec valid usage text states 'pImportSemaphoreFdInfo must be a valid pointer to a valid VkImportSemaphoreFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter)"}, - {VALIDATION_ERROR_30e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHR-device-parameter)"}, - {VALIDATION_ERROR_30e19001, "The spec valid usage text states 'pImportSemaphoreWin32HandleInfo must be a valid pointer to a valid VkImportSemaphoreWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter)"}, - {VALIDATION_ERROR_31005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-device-parameter)"}, - {VALIDATION_ERROR_3100c81b, "The spec valid usage text states 'memoryRangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength)"}, - {VALIDATION_ERROR_3101b201, "The spec valid usage text states 'pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter)"}, - {VALIDATION_ERROR_3120054c, "The spec valid usage text states 'memory must not be currently mapped' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-00678)"}, - {VALIDATION_ERROR_3120054e, "The spec valid usage text states 'offset must be less than the size of memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-offset-00679)"}, - {VALIDATION_ERROR_31200550, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-size-00680)"}, - {VALIDATION_ERROR_31200552, "The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of the memory minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-size-00681)"}, - {VALIDATION_ERROR_31200554, "The spec valid usage text states 'memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-00682)"}, - {VALIDATION_ERROR_31200556, "The spec valid usage text states 'memory must not have been allocated with multiple instances.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMapMemory-memory-00683)"}, - {VALIDATION_ERROR_31205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-device-parameter)"}, - {VALIDATION_ERROR_31209005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-flags-zerobitmask)"}, - {VALIDATION_ERROR_3120c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-parameter)"}, - {VALIDATION_ERROR_3120c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-memory-parent)"}, - {VALIDATION_ERROR_31228c01, "The spec valid usage text states 'ppData must be a valid pointer to a pointer value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMapMemory-ppData-parameter)"}, - {VALIDATION_ERROR_31400604, "The spec valid usage text states 'dstCache must not appear in the list of source caches' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-dstCache-00770)"}, - {VALIDATION_ERROR_31405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-device-parameter)"}, - {VALIDATION_ERROR_31406e01, "The spec valid usage text states 'dstCache must be a valid VkPipelineCache handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-dstCache-parameter)"}, - {VALIDATION_ERROR_31406e07, "The spec valid usage text states 'dstCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-dstCache-parent)"}, - {VALIDATION_ERROR_31423c01, "The spec valid usage text states 'pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkPipelineCache handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-pSrcCaches-parameter)"}, - {VALIDATION_ERROR_31423c07, "The spec valid usage text states 'Each element of pSrcCaches must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-pSrcCaches-parent)"}, - {VALIDATION_ERROR_3142ca1b, "The spec valid usage text states 'srcCacheCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkMergePipelineCaches-srcCacheCount-arraylength)"}, - {VALIDATION_ERROR_31600009, "The spec valid usage text states 'Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-commonparent)"}, - {VALIDATION_ERROR_31600011, "The spec valid usage text states 'The queue must support sparse binding operations' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-queuetype)"}, - {VALIDATION_ERROR_316008b2, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-fence-01113)"}, - {VALIDATION_ERROR_316008b4, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-fence-01114)"}, - {VALIDATION_ERROR_316008b6, "The spec valid usage text states 'Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pSignalSemaphores-01115)"}, - {VALIDATION_ERROR_316008b8, "The spec valid usage text states 'When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, no other queue must be waiting on the same semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pWaitSemaphores-01116)"}, - {VALIDATION_ERROR_316008ba, "The spec valid usage text states 'All elements of the pWaitSemaphores member of all elements of pBindInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pWaitSemaphores-01117)"}, - {VALIDATION_ERROR_31608801, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-fence-parameter)"}, - {VALIDATION_ERROR_3160f801, "The spec valid usage text states 'If bindInfoCount is not 0, pBindInfo must be a valid pointer to an array of bindInfoCount valid VkBindSparseInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-pBindInfo-parameter)"}, - {VALIDATION_ERROR_31629c01, "The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueBindSparse-queue-parameter)"}, - {VALIDATION_ERROR_31800a18, "The spec valid usage text states 'Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pSwapchains-01292)"}, - {VALIDATION_ERROR_31800a1a, "The spec valid usage text states 'If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pSwapchains-01293)"}, - {VALIDATION_ERROR_31800a1c, "The spec valid usage text states 'When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, no other queue must be waiting on the same semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pWaitSemaphores-01294)"}, - {VALIDATION_ERROR_31800a1e, "The spec valid usage text states 'All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pWaitSemaphores-01295)"}, - {VALIDATION_ERROR_3181e601, "The spec valid usage text states 'pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pPresentInfo-parameter)"}, - {VALIDATION_ERROR_31829c01, "The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-queue-parameter)"}, - {VALIDATION_ERROR_31a00009, "The spec valid usage text states 'Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-commonparent)"}, - {VALIDATION_ERROR_31a0007e, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be unsignaled' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-fence-00063)"}, - {VALIDATION_ERROR_31a00080, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-fence-00064)"}, - {VALIDATION_ERROR_31a00082, "The spec valid usage text states 'Any calls to vkCmdSetEvent, vkCmdResetEvent or vkCmdWaitEvents that have been recorded into any of the command buffer elements of the pCommandBuffers member of any element of pSubmits, must not reference any VkEvent that is referenced by any of those commands in a command buffer that has been submitted to another queue and is still in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00065)"}, - {VALIDATION_ERROR_31a00084, "The spec valid usage text states 'Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the table of supported pipeline stages.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pWaitDstStageMask-00066)"}, - {VALIDATION_ERROR_31a00086, "The spec valid usage text states 'Each element of the pSignalSemaphores member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pSignalSemaphores-00067)"}, - {VALIDATION_ERROR_31a00088, "The spec valid usage text states 'When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, no other queue must be waiting on the same semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pWaitSemaphores-00068)"}, - {VALIDATION_ERROR_31a0008a, "The spec valid usage text states 'All elements of the pWaitSemaphores member of all elements of pSubmits must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pWaitSemaphores-00069)"}, - {VALIDATION_ERROR_31a0008c, "The spec valid usage text states 'Each element of the pCommandBuffers member of each element of pSubmits must be in the pending or executable state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00070)"}, - {VALIDATION_ERROR_31a0008e, "The spec valid usage text states 'If any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00071)"}, - {VALIDATION_ERROR_31a00090, "The spec valid usage text states 'Any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits must be in the pending or executable state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00072)"}, - {VALIDATION_ERROR_31a00092, "The spec valid usage text states 'If any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00073)"}, - {VALIDATION_ERROR_31a00094, "The spec valid usage text states 'Each element of the pCommandBuffers member of each element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pCommandBuffers-00074)"}, - {VALIDATION_ERROR_31a08801, "The spec valid usage text states 'If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-fence-parameter)"}, - {VALIDATION_ERROR_31a24001, "The spec valid usage text states 'If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-pSubmits-parameter)"}, - {VALIDATION_ERROR_31a29c01, "The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueSubmit-queue-parameter)"}, - {VALIDATION_ERROR_31c29c01, "The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkQueueWaitIdle-queue-parameter)"}, - {VALIDATION_ERROR_31e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-device-parameter)"}, - {VALIDATION_ERROR_31e0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_31e13a01, "The spec valid usage text states 'pDeviceEventInfo must be a valid pointer to a valid VkDeviceEventInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter)"}, - {VALIDATION_ERROR_31e17001, "The spec valid usage text states 'pFence must be a valid pointer to a VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDeviceEventEXT-pFence-parameter)"}, - {VALIDATION_ERROR_32005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-device-parameter)"}, - {VALIDATION_ERROR_32006001, "The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-display-parameter)"}, - {VALIDATION_ERROR_3200ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_32014c01, "The spec valid usage text states 'pDisplayEventInfo must be a valid pointer to a valid VkDisplayEventInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter)"}, - {VALIDATION_ERROR_32017001, "The spec valid usage text states 'pFence must be a valid pointer to a VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterDisplayEventEXT-pFence-parameter)"}, - {VALIDATION_ERROR_32200aa8, "The spec valid usage text states 'The contents of pObjectTableEntry must yield plausible bindings supported by the device.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectTableEntry-01364)"}, - {VALIDATION_ERROR_32200aaa, "The spec valid usage text states 'At any pObjectIndices there must not be a registered resource already.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectIndices-01365)"}, - {VALIDATION_ERROR_32200aac, "The spec valid usage text states 'Any value inside pObjectIndices must be below the appropriate VkObjectTableCreateInfoNVX::pObjectEntryCounts limits provided at objectTable creation time.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectIndices-01366)"}, - {VALIDATION_ERROR_32205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-device-parameter)"}, - {VALIDATION_ERROR_3220d61b, "The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-objectCount-arraylength)"}, - {VALIDATION_ERROR_3220d801, "The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-objectTable-parameter)"}, - {VALIDATION_ERROR_3220d807, "The spec valid usage text states 'objectTable must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-objectTable-parent)"}, - {VALIDATION_ERROR_3221cc01, "The spec valid usage text states 'pObjectIndices must be a valid pointer to an array of objectCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-pObjectIndices-parameter)"}, - {VALIDATION_ERROR_32229201, "The spec valid usage text states 'ppObjectTableEntries must be a valid pointer to an array of objectCount valid VkObjectTableEntryNVX structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkRegisterObjectsNVX-ppObjectTableEntries-parameter)"}, - {VALIDATION_ERROR_32406001, "The spec valid usage text states 'display must be a valid VkDisplayKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkReleaseDisplayEXT-display-parameter)"}, - {VALIDATION_ERROR_32427a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkReleaseDisplayEXT-physicalDevice-parameter)"}, - {VALIDATION_ERROR_3260005a, "The spec valid usage text states 'commandBuffer must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-commandBuffer-00045)"}, - {VALIDATION_ERROR_3260005c, "The spec valid usage text states 'commandBuffer must have been allocated from a pool that was created with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-commandBuffer-00046)"}, - {VALIDATION_ERROR_32602401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-commandBuffer-parameter)"}, - {VALIDATION_ERROR_32609001, "The spec valid usage text states 'flags must be a valid combination of VkCommandBufferResetFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandBuffer-flags-parameter)"}, - {VALIDATION_ERROR_32800050, "The spec valid usage text states 'All VkCommandBuffer objects allocated from commandPool must not be in the pending state' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-commandPool-00040)"}, - {VALIDATION_ERROR_32802801, "The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-commandPool-parameter)"}, - {VALIDATION_ERROR_32802807, "The spec valid usage text states 'commandPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-commandPool-parent)"}, - {VALIDATION_ERROR_32805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-device-parameter)"}, - {VALIDATION_ERROR_32809001, "The spec valid usage text states 'flags must be a valid combination of VkCommandPoolResetFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetCommandPool-flags-parameter)"}, - {VALIDATION_ERROR_32a00272, "The spec valid usage text states 'All uses of descriptorPool (via any allocated descriptor sets) must have completed execution' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-descriptorPool-00313)"}, - {VALIDATION_ERROR_32a04601, "The spec valid usage text states 'descriptorPool must be a valid VkDescriptorPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-descriptorPool-parameter)"}, - {VALIDATION_ERROR_32a04607, "The spec valid usage text states 'descriptorPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-descriptorPool-parent)"}, - {VALIDATION_ERROR_32a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-device-parameter)"}, - {VALIDATION_ERROR_32a09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetDescriptorPool-flags-zerobitmask)"}, - {VALIDATION_ERROR_32c008f8, "The spec valid usage text states 'event must not be waited on by a vkCmdWaitEvents command that is currently executing' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-event-01148)"}, - {VALIDATION_ERROR_32c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-device-parameter)"}, - {VALIDATION_ERROR_32c07e01, "The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-event-parameter)"}, - {VALIDATION_ERROR_32c07e07, "The spec valid usage text states 'event must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetEvent-event-parent)"}, - {VALIDATION_ERROR_32e008c6, "The spec valid usage text states 'Each element of pFences must not be currently associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-pFences-01123)"}, - {VALIDATION_ERROR_32e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-device-parameter)"}, - {VALIDATION_ERROR_32e08a1b, "The spec valid usage text states 'fenceCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-fenceCount-arraylength)"}, - {VALIDATION_ERROR_32e17201, "The spec valid usage text states 'pFences must be a valid pointer to an array of fenceCount valid VkFence handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-pFences-parameter)"}, - {VALIDATION_ERROR_32e17207, "The spec valid usage text states 'Each element of pFences must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkResetFences-pFences-parent)"}, - {VALIDATION_ERROR_33005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkSetEvent-device-parameter)"}, - {VALIDATION_ERROR_33007e01, "The spec valid usage text states 'event must be a valid VkEvent handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkSetEvent-event-parameter)"}, - {VALIDATION_ERROR_33007e07, "The spec valid usage text states 'event must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkSetEvent-event-parent)"}, - {VALIDATION_ERROR_33200009, "The spec valid usage text states 'Both of device, and the elements of pSwapchains must have been created, allocated, or retrieved from the same VkInstance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-commonparent)"}, - {VALIDATION_ERROR_33205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-device-parameter)"}, - {VALIDATION_ERROR_3321ba01, "The spec valid usage text states 'pMetadata must be a valid pointer to an array of swapchainCount valid VkHdrMetadataEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-pMetadata-parameter)"}, - {VALIDATION_ERROR_33225801, "The spec valid usage text states 'pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-pSwapchains-parameter)"}, - {VALIDATION_ERROR_3322f21b, "The spec valid usage text states 'swapchainCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength)"}, - {VALIDATION_ERROR_33402801, "The spec valid usage text states 'commandPool must be a valid VkCommandPool handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-commandPool-parameter)"}, - {VALIDATION_ERROR_33402807, "The spec valid usage text states 'commandPool must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-commandPool-parent)"}, - {VALIDATION_ERROR_33405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-device-parameter)"}, - {VALIDATION_ERROR_33409005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkTrimCommandPool-flags-zerobitmask)"}, - {VALIDATION_ERROR_33600562, "The spec valid usage text states 'memory must be currently mapped' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-memory-00689)"}, - {VALIDATION_ERROR_33605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-device-parameter)"}, - {VALIDATION_ERROR_3360c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-memory-parameter)"}, - {VALIDATION_ERROR_3360c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUnmapMemory-memory-parent)"}, - {VALIDATION_ERROR_33800aba, "The spec valid usage text states 'At any pObjectIndices there must be a registered resource already.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectIndices-01373)"}, - {VALIDATION_ERROR_33800abc, "The spec valid usage text states 'The pObjectEntryTypes of the resource at pObjectIndices must match.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-01374)"}, - {VALIDATION_ERROR_33800abe, "The spec valid usage text states 'All operations on the device using the registered resource must have been completed.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-None-01375)"}, - {VALIDATION_ERROR_33805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-device-parameter)"}, - {VALIDATION_ERROR_3380d61b, "The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-objectCount-arraylength)"}, - {VALIDATION_ERROR_3380d801, "The spec valid usage text states 'objectTable must be a valid VkObjectTableNVX handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-objectTable-parameter)"}, - {VALIDATION_ERROR_3380d807, "The spec valid usage text states 'objectTable must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-objectTable-parent)"}, - {VALIDATION_ERROR_3381c801, "The spec valid usage text states 'pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-parameter)"}, - {VALIDATION_ERROR_3381cc01, "The spec valid usage text states 'pObjectIndices must be a valid pointer to an array of objectCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUnregisterObjectsNVX-pObjectIndices-parameter)"}, - {VALIDATION_ERROR_33a00d2a, "The spec valid usage text states 'pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-pData-01685)"}, - {VALIDATION_ERROR_33a04801, "The spec valid usage text states 'descriptorSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter)"}, - {VALIDATION_ERROR_33a05201, "The spec valid usage text states 'descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter)"}, - {VALIDATION_ERROR_33a05207, "The spec valid usage text states 'descriptorUpdateTemplate must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent)"}, - {VALIDATION_ERROR_33a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSetWithTemplate-device-parameter)"}, - {VALIDATION_ERROR_33c00274, "The spec valid usage text states 'The dstSet member of each element of pDescriptorWrites or pDescriptorCopies must not be used by any command that was recorded to a command buffer which is in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-dstSet-00314)"}, - {VALIDATION_ERROR_33c017ce, "The spec valid usage text states 'Descriptor bindings updated by this command which were created without the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT bits set must not be used by any command that was recorded to a command buffer which is in the pending state.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkUpdateDescriptorSets-None-03047)"}, - {VALIDATION_ERROR_33c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-device-parameter)"}, - {VALIDATION_ERROR_33c12c01, "The spec valid usage text states 'If descriptorCopyCount is not 0, pDescriptorCopies must be a valid pointer to an array of descriptorCopyCount valid VkCopyDescriptorSet structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter)"}, - {VALIDATION_ERROR_33c13601, "The spec valid usage text states 'If descriptorWriteCount is not 0, pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter)"}, - {VALIDATION_ERROR_33e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-device-parameter)"}, - {VALIDATION_ERROR_33e08a1b, "The spec valid usage text states 'fenceCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-fenceCount-arraylength)"}, - {VALIDATION_ERROR_33e17201, "The spec valid usage text states 'pFences must be a valid pointer to an array of fenceCount valid VkFence handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-pFences-parameter)"}, - {VALIDATION_ERROR_33e17207, "The spec valid usage text states 'Each element of pFences must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-pFences-parent)"}, - {VALIDATION_ERROR_3401c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceSubgroupProperties, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-pNext-pNext)"}, - {VALIDATION_ERROR_3402b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-sType-sType)"}, - {VALIDATION_ERROR_3402b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-sType-unique)"}, - {VALIDATION_ERROR_3421c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFormatProperties2-pNext-pNext)"}, - {VALIDATION_ERROR_3422b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFormatProperties2-sType-sType)"}, - {VALIDATION_ERROR_3441c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkSamplerYcbcrConversionImageFormatProperties, or VkTextureLODGatherFormatPropertiesAMD' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatProperties2-pNext-pNext)"}, - {VALIDATION_ERROR_3442b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatProperties2-sType-sType)"}, - {VALIDATION_ERROR_3442b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatProperties2-sType-unique)"}, - {VALIDATION_ERROR_3461c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext)"}, - {VALIDATION_ERROR_3462b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-sType-sType)"}, - {VALIDATION_ERROR_3481c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkSharedPresentSurfaceCapabilitiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2KHR-pNext-pNext)"}, - {VALIDATION_ERROR_3482b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceCapabilities2KHR-sType-sType)"}, - {VALIDATION_ERROR_34a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext)"}, - {VALIDATION_ERROR_34a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType)"}, - {VALIDATION_ERROR_34c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalBufferProperties-pNext-pNext)"}, - {VALIDATION_ERROR_34c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalBufferProperties-sType-sType)"}, - {VALIDATION_ERROR_3521c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalSemaphoreProperties-pNext-pNext)"}, - {VALIDATION_ERROR_3522b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalSemaphoreProperties-sType-sType)"}, - {VALIDATION_ERROR_3541c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkQueueFamilyProperties2-pNext-pNext)"}, - {VALIDATION_ERROR_3542b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkQueueFamilyProperties2-sType-sType)"}, - {VALIDATION_ERROR_3561c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageFormatProperties2-pNext-pNext)"}, - {VALIDATION_ERROR_3562b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageFormatProperties2-sType-sType)"}, - {VALIDATION_ERROR_3581c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceFormat2KHR-pNext-pNext)"}, - {VALIDATION_ERROR_3582b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSurfaceFormat2KHR-sType-sType)"}, - {VALIDATION_ERROR_35c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewProperties-sType-sType)"}, - {VALIDATION_ERROR_3602b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalImageFormatProperties-sType-sType)"}, - {VALIDATION_ERROR_3622b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceIDProperties-sType-sType)"}, - {VALIDATION_ERROR_3642b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType)"}, - {VALIDATION_ERROR_37e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType)"}, - {VALIDATION_ERROR_3822b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType)"}, - {VALIDATION_ERROR_3842b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_3862b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_38800b20, "The spec valid usage text states 'If the non-premultiplied source color property is not supported, srcPremultiplied must be VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424)"}, - {VALIDATION_ERROR_38800b22, "The spec valid usage text states 'If the non-premultiplied destination color property is not supported, dstPremultiplied must be VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425)"}, - {VALIDATION_ERROR_38800b24, "The spec valid usage text states 'If the correlated overlap property is not supported, blendOverlap must be VK_BLEND_OVERLAP_UNCORRELATED_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426)"}, - {VALIDATION_ERROR_3882b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_38834a01, "The spec valid usage text states 'blendOverlap must be a valid VkBlendOverlapEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter)"}, - {VALIDATION_ERROR_38a00afa, "The spec valid usage text states 'If coverageModulationTableEnable is VK_TRUE, coverageModulationTableCount must be equal to the number of rasterization samples divided by the number of color samples in the subpass.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405)"}, - {VALIDATION_ERROR_38a09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask)"}, - {VALIDATION_ERROR_38a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_38a34c01, "The spec valid usage text states 'coverageModulationMode must be a valid VkCoverageModulationModeNV value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter)"}, - {VALIDATION_ERROR_38a34e1b, "The spec valid usage text states 'coverageModulationTableCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableCount-arraylength)"}, - {VALIDATION_ERROR_38c00af8, "The spec valid usage text states 'If coverageToColorEnable is VK_TRUE, then the render pass subpass indicated by VkGraphicsPipelineCreateInfo::renderPass and VkGraphicsPipelineCreateInfo::subpass must have a color attachment at the location selected by coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404)"}, - {VALIDATION_ERROR_38c09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageToColorStateCreateInfoNV-flags-zerobitmask)"}, - {VALIDATION_ERROR_38c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineCoverageToColorStateCreateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_38e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerReductionModeCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_38e35001, "The spec valid usage text states 'reductionMode must be a valid VkSamplerReductionModeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerReductionModeCreateInfoEXT-reductionMode-parameter)"}, - {VALIDATION_ERROR_39400b4c, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalFenceProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceCreateInfo-handleTypes-01446)"}, - {VALIDATION_ERROR_39409e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceCreateInfo-handleTypes-parameter)"}, - {VALIDATION_ERROR_3942b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_39609c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter)"}, - {VALIDATION_ERROR_3961c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext)"}, - {VALIDATION_ERROR_3962b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType)"}, - {VALIDATION_ERROR_3981c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFenceProperties-pNext-pNext)"}, - {VALIDATION_ERROR_3982b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFenceProperties-sType-sType)"}, - {VALIDATION_ERROR_39a27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter)"}, - {VALIDATION_ERROR_39a3a201, "The spec valid usage text states 'pExternalFenceInfo must be a valid pointer to a valid VkPhysicalDeviceExternalFenceInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter)"}, - {VALIDATION_ERROR_39a3a401, "The spec valid usage text states 'pExternalFenceProperties must be a valid pointer to a VkExternalFenceProperties structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter)"}, - {VALIDATION_ERROR_39c00b70, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportFenceFdInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-handleType-01464)"}, - {VALIDATION_ERROR_39c00c0a, "The spec valid usage text states 'fd must obey any requirements listed for handleType in external fence handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-fd-01541)"}, - {VALIDATION_ERROR_39c08801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-fence-parameter)"}, - {VALIDATION_ERROR_39c09001, "The spec valid usage text states 'flags must be a valid combination of VkFenceImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-flags-parameter)"}, - {VALIDATION_ERROR_39c09c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_39c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_39c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_39e00b5a, "The spec valid usage text states 'handleType must have been included in VkExportFenceCreateInfo::handleTypes when fence's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01453)"}, - {VALIDATION_ERROR_39e00b5c, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01454)"}, - {VALIDATION_ERROR_39e00b5e, "The spec valid usage text states 'fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload's handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-fence-01455)"}, - {VALIDATION_ERROR_39e00b60, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01456)"}, - {VALIDATION_ERROR_39e08801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-fence-parameter)"}, - {VALIDATION_ERROR_39e09c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_39e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_39e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3a000b6e, "The spec valid usage text states 'fence must not be associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceFdKHR-fence-01463)"}, - {VALIDATION_ERROR_3a005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceFdKHR-device-parameter)"}, - {VALIDATION_ERROR_3a03a801, "The spec valid usage text states 'pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter)"}, - {VALIDATION_ERROR_3a205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceFdKHR-device-parameter)"}, - {VALIDATION_ERROR_3a216c01, "The spec valid usage text states 'pFd must be a valid pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceFdKHR-pFd-parameter)"}, - {VALIDATION_ERROR_3a239e01, "The spec valid usage text states 'pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceFdKHR-pGetFdInfo-parameter)"}, - {VALIDATION_ERROR_3a400b62, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportFenceWin32HandleInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457)"}, - {VALIDATION_ERROR_3a400b66, "The spec valid usage text states 'If handleType is not VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459)"}, - {VALIDATION_ERROR_3a400b68, "The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460)"}, - {VALIDATION_ERROR_3a400b6a, "The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461)"}, - {VALIDATION_ERROR_3a400b6c, "The spec valid usage text states 'If handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handle-01462)"}, - {VALIDATION_ERROR_3a400c06, "The spec valid usage text states 'If handle is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handle-01539)"}, - {VALIDATION_ERROR_3a400c08, "The spec valid usage text states 'If name is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-name-01540)"}, - {VALIDATION_ERROR_3a408801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter)"}, - {VALIDATION_ERROR_3a409001, "The spec valid usage text states 'flags must be a valid combination of VkFenceImportFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter)"}, - {VALIDATION_ERROR_3a409c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_3a41c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_3a42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3a600b4e, "The spec valid usage text states 'If VkExportFenceCreateInfo::handleTypes does not include VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, VkExportFenceWin32HandleInfoKHR must not be in the pNext chain of VkFenceCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447)"}, - {VALIDATION_ERROR_3a60f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter)"}, - {VALIDATION_ERROR_3a62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3a800b50, "The spec valid usage text states 'handleType must have been included in VkExportFenceCreateInfo::handleTypes when the fence's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448)"}, - {VALIDATION_ERROR_3a800b52, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetFenceWin32HandleKHR must be called no more than once for each valid unique combination of fence and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449)"}, - {VALIDATION_ERROR_3a800b54, "The spec valid usage text states 'fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload's handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-fence-01450)"}, - {VALIDATION_ERROR_3a800b56, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451)"}, - {VALIDATION_ERROR_3a800b58, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452)"}, - {VALIDATION_ERROR_3a808801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter)"}, - {VALIDATION_ERROR_3a809c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_3a81c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_3a82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3aa05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceWin32HandleKHR-device-parameter)"}, - {VALIDATION_ERROR_3aa3aa01, "The spec valid usage text states 'pImportFenceWin32HandleInfo must be a valid pointer to a valid VkImportFenceWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter)"}, - {VALIDATION_ERROR_3ac05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-device-parameter)"}, - {VALIDATION_ERROR_3ac17c01, "The spec valid usage text states 'pHandle must be a valid pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-pHandle-parameter)"}, - {VALIDATION_ERROR_3ac3a001, "The spec valid usage text states 'pGetWin32HandleInfo must be a valid pointer to a valid VkFenceGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter)"}, - {VALIDATION_ERROR_3ae008d8, "The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when semaphore's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01132)"}, - {VALIDATION_ERROR_3ae008da, "The spec valid usage text states 'semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload's handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133)"}, - {VALIDATION_ERROR_3ae008dc, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01134)"}, - {VALIDATION_ERROR_3ae008de, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01135)"}, - {VALIDATION_ERROR_3ae008e0, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-01136)"}, - {VALIDATION_ERROR_3ae09c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_3ae1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_3ae2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3ae2b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter)"}, - {VALIDATION_ERROR_3b0008cc, "The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when the semaphore's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126)"}, - {VALIDATION_ERROR_3b0008ce, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHR must be called no more than once for each valid unique combination of semaphore and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127)"}, - {VALIDATION_ERROR_3b0008d0, "The spec valid usage text states 'semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload's handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128)"}, - {VALIDATION_ERROR_3b0008d2, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129)"}, - {VALIDATION_ERROR_3b0008d4, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130)"}, - {VALIDATION_ERROR_3b0008d6, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131)"}, - {VALIDATION_ERROR_3b009c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_3b01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_3b02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3b02b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter)"}, - {VALIDATION_ERROR_3b20053e, "The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-handleType-00671)"}, - {VALIDATION_ERROR_3b200540, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-handleType-00672)"}, - {VALIDATION_ERROR_3b209c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_3b20c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-memory-parameter)"}, - {VALIDATION_ERROR_3b21c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_3b22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3b40052c, "The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662)"}, - {VALIDATION_ERROR_3b40052e, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHR must be called no more than once for each valid unique combination of memory and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663)"}, - {VALIDATION_ERROR_3b400530, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664)"}, - {VALIDATION_ERROR_3b409c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter)"}, - {VALIDATION_ERROR_3b40c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter)"}, - {VALIDATION_ERROR_3b41c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext)"}, - {VALIDATION_ERROR_3b42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3b62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedRequirements-sType-sType)"}, - {VALIDATION_ERROR_3b800009, "The spec valid usage text states 'Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-commonparent)"}, - {VALIDATION_ERROR_3b800b30, "The spec valid usage text states 'At least one of image and buffer must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01432)"}, - {VALIDATION_ERROR_3b800b32, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01433)"}, - {VALIDATION_ERROR_3b800b34, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must have been created without VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in VkImageCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01434)"}, - {VALIDATION_ERROR_3b800b36, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01435)"}, - {VALIDATION_ERROR_3b800b38, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must have been created without VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in VkBufferCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01436)"}, - {VALIDATION_ERROR_3b800e0a, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must not have been created with VK_IMAGE_CREATE_DISJOINT_BIT set in VkImageCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01797)"}, - {VALIDATION_ERROR_3b800ea8, "The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01876)"}, - {VALIDATION_ERROR_3b800eaa, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01877)"}, - {VALIDATION_ERROR_3b800eac, "The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-01878)"}, - {VALIDATION_ERROR_3b800eae, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-01879)"}, - {VALIDATION_ERROR_3b801a01, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter)"}, - {VALIDATION_ERROR_3b80a001, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-image-parameter)"}, - {VALIDATION_ERROR_3b82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfo-sType-sType)"}, - {VALIDATION_ERROR_3ba01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter)"}, - {VALIDATION_ERROR_3ba1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext)"}, - {VALIDATION_ERROR_3ba2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2-sType-sType)"}, - {VALIDATION_ERROR_3bc00c6a, "The spec valid usage text states 'If image was created with a multi-planar format and the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01589)"}, - {VALIDATION_ERROR_3bc00c6c, "The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01590)"}, - {VALIDATION_ERROR_3bc00c6e, "The spec valid usage text states 'If image was created with a single-plane format, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01591)"}, - {VALIDATION_ERROR_3bc00ed2, "The spec valid usage text states 'If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-01897)"}, - {VALIDATION_ERROR_3bc0a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-image-parameter)"}, - {VALIDATION_ERROR_3bc1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkImagePlaneMemoryRequirementsInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-pNext-pNext)"}, - {VALIDATION_ERROR_3bc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2-sType-sType)"}, - {VALIDATION_ERROR_3be0a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter)"}, - {VALIDATION_ERROR_3be1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSparseMemoryRequirementsInfo2-pNext-pNext)"}, - {VALIDATION_ERROR_3be2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType)"}, - {VALIDATION_ERROR_3c01c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkMemoryDedicatedRequirements' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryRequirements2-pNext-pNext)"}, - {VALIDATION_ERROR_3c02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryRequirements2-sType-sType)"}, - {VALIDATION_ERROR_3c21c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageMemoryRequirements2-pNext-pNext)"}, - {VALIDATION_ERROR_3c22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSparseImageMemoryRequirements2-sType-sType)"}, - {VALIDATION_ERROR_3c405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements2-device-parameter)"}, - {VALIDATION_ERROR_3c41b401, "The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter)"}, - {VALIDATION_ERROR_3c439c01, "The spec valid usage text states 'pInfo must be a valid pointer to a valid VkImageMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageMemoryRequirements2-pInfo-parameter)"}, - {VALIDATION_ERROR_3c605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2-device-parameter)"}, - {VALIDATION_ERROR_3c61b401, "The spec valid usage text states 'pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter)"}, - {VALIDATION_ERROR_3c639c01, "The spec valid usage text states 'pInfo must be a valid pointer to a valid VkBufferMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2-pInfo-parameter)"}, - {VALIDATION_ERROR_3c805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-device-parameter)"}, - {VALIDATION_ERROR_3c823601, "The spec valid usage text states 'pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirementCount-parameter)"}, - {VALIDATION_ERROR_3c823801, "The spec valid usage text states 'If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements2 structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirements-parameter)"}, - {VALIDATION_ERROR_3c839c01, "The spec valid usage text states 'pInfo must be a valid pointer to a valid VkImageSparseMemoryRequirementsInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetImageSparseMemoryRequirements2-pInfo-parameter)"}, - {VALIDATION_ERROR_3ca2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType)"}, - {VALIDATION_ERROR_3cc00b2e, "The spec valid usage text states 'If variablePointers is enabled then variablePointersStorageBuffer must also be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceVariablePointerFeatures-variablePointers-01431)"}, - {VALIDATION_ERROR_3cc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceVariablePointerFeatures-sType-sType)"}, - {VALIDATION_ERROR_3ce00bec, "The spec valid usage text states 'sampleLocationsPerPixel must be a bit value that is set in VkPhysicalDeviceSampleLocationsPropertiesEXT::sampleLocationSampleCounts' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526)"}, - {VALIDATION_ERROR_3ce00bee, "The spec valid usage text states 'sampleLocationsCount must equal sampleLocationsPerPixel {times} sampleLocationGridSize.width {times} sampleLocationGridSize.height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527)"}, - {VALIDATION_ERROR_3ce2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_3ce3b201, "The spec valid usage text states 'sampleLocationsPerPixel must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter)"}, - {VALIDATION_ERROR_3ce3b41b, "The spec valid usage text states 'sampleLocationsCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength)"}, - {VALIDATION_ERROR_3ce3b601, "The spec valid usage text states 'pSampleLocations must be a valid pointer to an array of sampleLocationsCount VkSampleLocationEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter)"}, - {VALIDATION_ERROR_3d02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_3d03ba01, "The spec valid usage text states 'If attachmentInitialSampleLocationsCount is not 0, pAttachmentInitialSampleLocations must be a valid pointer to an array of attachmentInitialSampleLocationsCount valid VkAttachmentSampleLocationsEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter)"}, - {VALIDATION_ERROR_3d03e801, "The spec valid usage text states 'If postSubpassSampleLocationsCount is not 0, pPostSubpassSampleLocations must be a valid pointer to an array of postSubpassSampleLocationsCount valid VkSubpassSampleLocationsEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter)"}, - {VALIDATION_ERROR_3d22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_3d23c601, "The spec valid usage text states 'sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter)"}, - {VALIDATION_ERROR_3d42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_3d61c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMultisamplePropertiesEXT-pNext-pNext)"}, - {VALIDATION_ERROR_3d62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMultisamplePropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_3d827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter)"}, - {VALIDATION_ERROR_3d82b401, "The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter)"}, - {VALIDATION_ERROR_3d83ca01, "The spec valid usage text states 'pMultisampleProperties must be a valid pointer to a VkMultisamplePropertiesEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter)"}, - {VALIDATION_ERROR_3da00bfc, "The spec valid usage text states 'If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetValidationCacheDataEXT when pInitialData was originally retrieved' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534)"}, - {VALIDATION_ERROR_3da00bfe, "The spec valid usage text states 'If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetValidationCacheDataEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535)"}, - {VALIDATION_ERROR_3da09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-flags-zerobitmask)"}, - {VALIDATION_ERROR_3da19601, "The spec valid usage text states 'If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-pInitialData-parameter)"}, - {VALIDATION_ERROR_3da1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_3da2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkValidationCacheCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_3dc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_3dc3c401, "The spec valid usage text states 'validationCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkShaderModuleValidationCacheCreateInfoEXT-validationCache-parameter)"}, - {VALIDATION_ERROR_3de05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-device-parameter)"}, - {VALIDATION_ERROR_3de0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_3de11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkValidationCacheCreateInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_3de3c201, "The spec valid usage text states 'pValidationCache must be a valid pointer to a VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateValidationCacheEXT-pValidationCache-parameter)"}, - {VALIDATION_ERROR_3e005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-device-parameter)"}, - {VALIDATION_ERROR_3e012201, "The spec valid usage text states 'If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-pData-parameter)"}, - {VALIDATION_ERROR_3e012401, "The spec valid usage text states 'pDataSize must be a valid pointer to a size_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-pDataSize-parameter)"}, - {VALIDATION_ERROR_3e03c401, "The spec valid usage text states 'validationCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-validationCache-parameter)"}, - {VALIDATION_ERROR_3e03c407, "The spec valid usage text states 'validationCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetValidationCacheDataEXT-validationCache-parent)"}, - {VALIDATION_ERROR_3e200bf0, "The spec valid usage text states 'The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-None-01528)"}, - {VALIDATION_ERROR_3e200bf2, "The spec valid usage text states 'The sampleLocationsPerPixel member of pSampleLocationsInfo must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529)"}, - {VALIDATION_ERROR_3e200bf4, "The spec valid usage text states 'If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE then the current render pass must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sample locations state pointed to by pSampleLocationsInfo' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530)"}, - {VALIDATION_ERROR_3e202401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_3e202413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_3e202415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_3e23c801, "The spec valid usage text states 'pSampleLocationsInfo must be a valid pointer to a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter)"}, - {VALIDATION_ERROR_3e400c02, "The spec valid usage text states 'If VkAllocationCallbacks were provided when validationCache was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-01537)"}, - {VALIDATION_ERROR_3e400c04, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when validationCache was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-01538)"}, - {VALIDATION_ERROR_3e405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-device-parameter)"}, - {VALIDATION_ERROR_3e40ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_3e43c401, "The spec valid usage text states 'If validationCache is not VK_NULL_HANDLE, validationCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-parameter)"}, - {VALIDATION_ERROR_3e43c407, "The spec valid usage text states 'If validationCache is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyValidationCacheEXT-validationCache-parent)"}, - {VALIDATION_ERROR_3e600c00, "The spec valid usage text states 'dstCache must not appear in the list of source caches' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-dstCache-01536)"}, - {VALIDATION_ERROR_3e605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-device-parameter)"}, - {VALIDATION_ERROR_3e606e01, "The spec valid usage text states 'dstCache must be a valid VkValidationCacheEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-dstCache-parameter)"}, - {VALIDATION_ERROR_3e606e07, "The spec valid usage text states 'dstCache must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-dstCache-parent)"}, - {VALIDATION_ERROR_3e623c01, "The spec valid usage text states 'pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkValidationCacheEXT handles' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter)"}, - {VALIDATION_ERROR_3e623c07, "The spec valid usage text states 'Each element of pSrcCaches must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-pSrcCaches-parent)"}, - {VALIDATION_ERROR_3e62ca1b, "The spec valid usage text states 'srcCacheCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkMergeValidationCachesEXT-srcCacheCount-arraylength)"}, - {VALIDATION_ERROR_3e800bf6, "The spec valid usage text states 'attachmentIndex must be less than the attachmentCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531)"}, - {VALIDATION_ERROR_3e83c601, "The spec valid usage text states 'sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter)"}, - {VALIDATION_ERROR_3ea00bf8, "The spec valid usage text states 'subpassIndex must be less than the subpassCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532)"}, - {VALIDATION_ERROR_3ea3c601, "The spec valid usage text states 'sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter)"}, - {VALIDATION_ERROR_3ec2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDevicePointClippingProperties-sType-sType)"}, - {VALIDATION_ERROR_3ee00c01, "The spec valid usage text states 'aspectMask must be a valid combination of VkImageAspectFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-aspectMask-parameter)"}, - {VALIDATION_ERROR_3ee00c03, "The spec valid usage text states 'aspectMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask)"}, - {VALIDATION_ERROR_3ee00c40, "The spec valid usage text states 'There must be an input attachment at pCreateInfo::pSubpasses[subpass].pInputAttachments[inputAttachmentIndex].' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-pCreateInfo-01568)"}, - {VALIDATION_ERROR_3ee00c42, "The spec valid usage text states 'The specified input attachment must have more than one aspect mask.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-None-01569)"}, - {VALIDATION_ERROR_3ee00c44, "The spec valid usage text states 'aspectMask must be a subset of the aspect masks in the specified input attachment.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkInputAttachmentAspectReference-aspectMask-01570)"}, - {VALIDATION_ERROR_3f02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_3f03ce1b, "The spec valid usage text states 'aspectReferenceCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength)"}, - {VALIDATION_ERROR_3f03d001, "The spec valid usage text states 'pAspectReferences must be a valid pointer to an array of aspectReferenceCount valid VkInputAttachmentAspectReference structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter)"}, - {VALIDATION_ERROR_3f200c66, "The spec valid usage text states 'usage must not include any set bits that were not set in the usage member of the VkImageCreateInfo structure used to create the image this image view is created from.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-usage-01587)"}, - {VALIDATION_ERROR_3f22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_3f230601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-usage-parameter)"}, - {VALIDATION_ERROR_3f230603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask)"}, - {VALIDATION_ERROR_3f42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_3f43d201, "The spec valid usage text states 'domainOrigin must be a valid VkTessellationDomainOrigin value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter)"}, - {VALIDATION_ERROR_3f600c54, "The spec valid usage text states 'If viewFormatCount is not 0, all of the formats in the pViewFormats array must be compatible with the format specified in the format field of VkImageCreateInfo, as described in the compatibility table.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01578)"}, - {VALIDATION_ERROR_3f600c56, "The spec valid usage text states 'If VkImageCreateInfo::flags does not contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, viewFormatCount must be 0 or 1.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-flags-01579)"}, - {VALIDATION_ERROR_3f600c58, "The spec valid usage text states 'If viewFormatCount is not 0, VkImageCreateInfo::format must be in pViewFormats.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01580)"}, - {VALIDATION_ERROR_3f62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_3f63e401, "The spec valid usage text states 'If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageFormatListCreateInfoKHR-pViewFormats-parameter)"}, - {VALIDATION_ERROR_3f800ce2, "The spec valid usage text states 'format must not be VK_FORMAT_UNDEFINED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01649)"}, - {VALIDATION_ERROR_3f800ce4, "The spec valid usage text states 'format must support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01650)"}, - {VALIDATION_ERROR_3f800ce6, "The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_COSITED_EVEN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651)"}, - {VALIDATION_ERROR_3f800ce8, "The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_MIDPOINT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652)"}, - {VALIDATION_ERROR_3f800cea, "The spec valid usage text states 'format must represent unsigned normalized values (i.e. the format must be a UNORM format)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01653)"}, - {VALIDATION_ERROR_3f800cec, "The spec valid usage text states 'If the format has a _422 or _420 suffix:' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-None-01654)"}, - {VALIDATION_ERROR_3f800cee, "The spec valid usage text states 'If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to channels of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a channel which contains zero or one as a consequence of conversion to RGBA' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655)"}, - {VALIDATION_ERROR_3f800cf0, "The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, forceExplicitReconstruction must be FALSE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656)"}, - {VALIDATION_ERROR_3f800cf2, "The spec valid usage text states 'If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, chromaFilter must be VK_FILTER_NEAREST' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657)"}, - {VALIDATION_ERROR_3f800ee0, "The spec valid usage text states 'If an external format conversion is being created, format must be VK_FORMAT_UNDEFINED, otherwise it must not be VK_FORMAT_UNDEFINED.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-01904)"}, - {VALIDATION_ERROR_3f802c01, "The spec valid usage text states 'components must be a valid VkComponentMapping structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter)"}, - {VALIDATION_ERROR_3f809201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter)"}, - {VALIDATION_ERROR_3f81c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkExternalFormatANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext)"}, - {VALIDATION_ERROR_3f82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_3f83d401, "The spec valid usage text states 'ycbcrModel must be a valid VkSamplerYcbcrModelConversion value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter)"}, - {VALIDATION_ERROR_3f83d601, "The spec valid usage text states 'ycbcrRange must be a valid VkSamplerYcbcrRange value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter)"}, - {VALIDATION_ERROR_3f83d801, "The spec valid usage text states 'xChromaOffset must be a valid VkChromaLocation value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter)"}, - {VALIDATION_ERROR_3f83da01, "The spec valid usage text states 'yChromaOffset must be a valid VkChromaLocation value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter)"}, - {VALIDATION_ERROR_3f83dc01, "The spec valid usage text states 'chromaFilter must be a valid VkFilter value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter)"}, - {VALIDATION_ERROR_3fa00cd4, "The spec valid usage text states 'planeAspect must be a single valid plane aspect for the image format (that is, planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT for \"_2PLANE\" formats and planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT for \"_3PLANE\" formats)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-planeAspect-01642)"}, - {VALIDATION_ERROR_3fa00cd6, "The spec valid usage text states 'A single call to vkBindImageMemory2 must bind all or none of the planes of an image (i.e. bindings to all planes of an image must be made in a single vkBindImageMemory2 call), as separate bindings' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-None-01643)"}, - {VALIDATION_ERROR_3fa2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-sType-sType)"}, - {VALIDATION_ERROR_3fa3de01, "The spec valid usage text states 'planeAspect must be a valid VkImageAspectFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter)"}, - {VALIDATION_ERROR_3fc00c70, "The spec valid usage text states 'planeAspect must be an aspect that exists in the format; that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-01592)"}, - {VALIDATION_ERROR_3fc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType)"}, - {VALIDATION_ERROR_3fc3de01, "The spec valid usage text states 'planeAspect must be a valid VkImageAspectFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter)"}, - {VALIDATION_ERROR_3fe00ce0, "The spec valid usage text states 'The sampler Y'CBCR conversion feature must be enabled' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-None-01648)"}, - {VALIDATION_ERROR_3fe05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-device-parameter)"}, - {VALIDATION_ERROR_3fe0ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-pAllocator-parameter)"}, - {VALIDATION_ERROR_3fe11e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_3fe3e001, "The spec valid usage text states 'pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter)"}, - {VALIDATION_ERROR_40000c8c, "The spec valid usage text states 'deviceIndexCount must either be zero or equal to the number of physical devices in the logical device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606)"}, - {VALIDATION_ERROR_40000c8e, "The spec valid usage text states 'All elements of pDeviceIndices must be valid device indices' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607)"}, - {VALIDATION_ERROR_40013e01, "The spec valid usage text states 'If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter)"}, - {VALIDATION_ERROR_4002b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType)"}, - {VALIDATION_ERROR_40200cc2, "The spec valid usage text states 'At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633)"}, - {VALIDATION_ERROR_40200cc4, "The spec valid usage text states 'deviceIndexCount must either be zero or equal to the number of physical devices in the logical device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634)"}, - {VALIDATION_ERROR_40200cc6, "The spec valid usage text states 'All elements of pDeviceIndices must be valid device indices.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635)"}, - {VALIDATION_ERROR_40200cc8, "The spec valid usage text states 'splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636)"}, - {VALIDATION_ERROR_40200cca, "The spec valid usage text states 'Elements of pSplitInstanceBindRegions that correspond to the same instance of an image must not overlap.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637)"}, - {VALIDATION_ERROR_40200ccc, "The spec valid usage text states 'The offset.x member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of all non-metadata aspects of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638)"}, - {VALIDATION_ERROR_40200cce, "The spec valid usage text states 'The offset.y member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of all non-metadata aspects of the image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639)"}, - {VALIDATION_ERROR_40200cd0, "The spec valid usage text states 'The extent.width member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block width of all non-metadata aspects of the image, or else extent.width + offset.x must equal the width of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640)"}, - {VALIDATION_ERROR_40200cd2, "The spec valid usage text states 'The extent.height member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block height of all non-metadata aspects of the image, or else extent.height offset.y must equal the width of the image subresource' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641)"}, - {VALIDATION_ERROR_40213e01, "The spec valid usage text states 'If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter)"}, - {VALIDATION_ERROR_4022b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType)"}, - {VALIDATION_ERROR_4023fe01, "The spec valid usage text states 'If splitInstanceBindRegionCount is not 0, pSplitInstanceBindRegions must be a valid pointer to an array of splitInstanceBindRegionCount VkRect2D structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter)"}, - {VALIDATION_ERROR_40405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-device-parameter)"}, - {VALIDATION_ERROR_4040ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-pAllocator-parameter)"}, - {VALIDATION_ERROR_4043e201, "The spec valid usage text states 'If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter)"}, - {VALIDATION_ERROR_4043e207, "The spec valid usage text states 'If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent)"}, - {VALIDATION_ERROR_4062b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType)"}, - {VALIDATION_ERROR_4082b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType)"}, - {VALIDATION_ERROR_40a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionInfo-sType-sType)"}, - {VALIDATION_ERROR_40a3e601, "The spec valid usage text states 'conversion must be a valid VkSamplerYcbcrConversion handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkSamplerYcbcrConversionInfo-conversion-parameter)"}, - {VALIDATION_ERROR_40c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_40c3ea01, "The spec valid usage text states 'globalPriority must be a valid VkQueueGlobalPriorityEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter)"}, - {VALIDATION_ERROR_40e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-device-parameter)"}, - {VALIDATION_ERROR_40e27c01, "The spec valid usage text states 'pipeline must be a valid VkPipeline handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pipeline-parameter)"}, - {VALIDATION_ERROR_40e27c07, "The spec valid usage text states 'pipeline must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pipeline-parent)"}, - {VALIDATION_ERROR_40e39c01, "The spec valid usage text states 'If the value referenced by pInfoSize is not 0, and pInfo is not NULL, pInfo must be a valid pointer to an array of pInfoSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pInfo-parameter)"}, - {VALIDATION_ERROR_40e3ec01, "The spec valid usage text states 'shaderStage must be a valid VkShaderStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-shaderStage-parameter)"}, - {VALIDATION_ERROR_40e3ee01, "The spec valid usage text states 'infoType must be a valid VkShaderInfoTypeAMD value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-infoType-parameter)"}, - {VALIDATION_ERROR_40e3f001, "The spec valid usage text states 'pInfoSize must be a valid pointer to a size_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetShaderInfoAMD-pInfoSize-parameter)"}, - {VALIDATION_ERROR_41200da6, "The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryPropertiesKHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747)"}, - {VALIDATION_ERROR_41200da8, "The spec valid usage text states 'If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748)"}, - {VALIDATION_ERROR_41200daa, "The spec valid usage text states 'pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749)"}, - {VALIDATION_ERROR_41200dac, "The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750)"}, - {VALIDATION_ERROR_41200dae, "The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host mapped foreign memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751)"}, - {VALIDATION_ERROR_41209c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter)"}, - {VALIDATION_ERROR_4122b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_4141c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext)"}, - {VALIDATION_ERROR_4142b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryHostPointerPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_4162b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_41800db0, "The spec valid usage text states 'handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752)"}, - {VALIDATION_ERROR_41800db2, "The spec valid usage text states 'pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753)"}, - {VALIDATION_ERROR_41800db4, "The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to host memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754)"}, - {VALIDATION_ERROR_41800db6, "The spec valid usage text states 'If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to host mapped foreign memory' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755)"}, - {VALIDATION_ERROR_41805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter)"}, - {VALIDATION_ERROR_41809c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter)"}, - {VALIDATION_ERROR_4183f401, "The spec valid usage text states 'pMemoryHostPointerProperties must be a valid pointer to a VkMemoryHostPointerPropertiesEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter)"}, - {VALIDATION_ERROR_41a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_41c00dd2, "The spec valid usage text states 'extraPrimitiveOverestimationSize must be in the range of 0.0 to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769)"}, - {VALIDATION_ERROR_41c09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask)"}, - {VALIDATION_ERROR_41c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_41c3f801, "The spec valid usage text states 'conservativeRasterizationMode must be a valid VkConservativeRasterizationModeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter)"}, - {VALIDATION_ERROR_41e00009, "The spec valid usage text states 'Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commonparent)"}, - {VALIDATION_ERROR_41e00e0c, "The spec valid usage text states 'dstOffset must be less than or equal to the size of dstBuffer minus 4.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798)"}, - {VALIDATION_ERROR_41e00e0e, "The spec valid usage text states 'dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799)"}, - {VALIDATION_ERROR_41e00e10, "The spec valid usage text states 'If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800)"}, - {VALIDATION_ERROR_41e00e12, "The spec valid usage text states 'dstOffset must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801)"}, - {VALIDATION_ERROR_41e02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter)"}, - {VALIDATION_ERROR_41e02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording)"}, - {VALIDATION_ERROR_41e02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_41e06c01, "The spec valid usage text states 'dstBuffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter)"}, - {VALIDATION_ERROR_41e28401, "The spec valid usage text states 'pipelineStage must be a valid VkPipelineStageFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter)"}, - {VALIDATION_ERROR_4201c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountLayoutSupportEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutSupport-pNext-pNext)"}, - {VALIDATION_ERROR_4202b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutSupport-sType-sType)"}, - {VALIDATION_ERROR_42200e64, "The spec valid usage text states 'queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842)"}, - {VALIDATION_ERROR_42200e66, "The spec valid usage text states 'queueIndex must be less than the number of queues created for the specified queue family index and VkDeviceQueueCreateFlags member flags equal to this flags value when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-queueIndex-01843)"}, - {VALIDATION_ERROR_42209001, "The spec valid usage text states 'flags must be a valid combination of VkDeviceQueueCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-flags-parameter)"}, - {VALIDATION_ERROR_42209003, "The spec valid usage text states 'flags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-flags-requiredbitmask)"}, - {VALIDATION_ERROR_4221c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-pNext-pNext)"}, - {VALIDATION_ERROR_4222b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceQueueInfo2-sType-sType)"}, - {VALIDATION_ERROR_4242b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType)"}, - {VALIDATION_ERROR_4262b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType)"}, - {VALIDATION_ERROR_4282b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType)"}, - {VALIDATION_ERROR_42a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderDrawParameterFeatures-sType-sType)"}, - {VALIDATION_ERROR_42c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSubgroupProperties-sType-sType)"}, - {VALIDATION_ERROR_42e00e30, "The spec valid usage text states 'If the protected memory feature is not enabled, protectedSubmit must not be VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-protectedSubmit-01816)"}, - {VALIDATION_ERROR_42e00e32, "The spec valid usage text states 'If protectedSubmit is VK_TRUE, then each element of the pCommandBuffers array must be a protected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-protectedSubmit-01817)"}, - {VALIDATION_ERROR_42e00e34, "The spec valid usage text states 'If protectedSubmit is VK_FALSE, then each element of the pCommandBuffers array must be an unprotected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-protectedSubmit-01818)"}, - {VALIDATION_ERROR_42e00e36, "The spec valid usage text states 'If the VkSubmitInfo::pNext chain does not include a VkProtectedSubmitInfo structure, then each element of the command buffer of the pCommandBuffers array must be an unprotected command buffer.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-pNext-01819)"}, - {VALIDATION_ERROR_42e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkProtectedSubmitInfo-sType-sType)"}, - {VALIDATION_ERROR_43040001, "The spec valid usage text states 'pApiVersion must be a valid pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkEnumerateInstanceVersion-pApiVersion-parameter)"}, - {VALIDATION_ERROR_43205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDescriptorSetLayoutSupport-device-parameter)"}, - {VALIDATION_ERROR_43211e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_43240201, "The spec valid usage text states 'pSupport must be a valid pointer to a VkDescriptorSetLayoutSupport structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter)"}, - {VALIDATION_ERROR_43405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceQueue2-device-parameter)"}, - {VALIDATION_ERROR_4341fc01, "The spec valid usage text states 'pQueue must be a valid pointer to a VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceQueue2-pQueue-parameter)"}, - {VALIDATION_ERROR_43440401, "The spec valid usage text states 'pQueueInfo must be a valid pointer to a valid VkDeviceQueueInfo2 structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetDeviceQueue2-pQueueInfo-parameter)"}, - {VALIDATION_ERROR_43600ee2, "The spec valid usage text states 'objectType must not be VK_OBJECT_TYPE_UNKNOWN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectType-01905)"}, - {VALIDATION_ERROR_43600ee4, "The spec valid usage text states 'objectHandle must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01906)"}, - {VALIDATION_ERROR_43600ee6, "The spec valid usage text states 'objectHandle must be a Vulkan object of the type associated with objectType as defined in debugging-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01907)"}, - {VALIDATION_ERROR_4360da01, "The spec valid usage text states 'objectType must be a valid VkObjectType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter)"}, - {VALIDATION_ERROR_4361c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_4361ce01, "The spec valid usage text states 'If pObjectName is not NULL, pObjectName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter)"}, - {VALIDATION_ERROR_4362b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_43800ee8, "The spec valid usage text states 'objectType must not be VK_OBJECT_TYPE_UNKNOWN' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908)"}, - {VALIDATION_ERROR_43800eea, "The spec valid usage text states 'objectHandle must not be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01909)"}, - {VALIDATION_ERROR_43800eec, "The spec valid usage text states 'objectHandle must be a Vulkan object of the type associated with objectType as defined in debugging-object-types.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910)"}, - {VALIDATION_ERROR_4380da01, "The spec valid usage text states 'objectType must be a valid VkObjectType value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter)"}, - {VALIDATION_ERROR_4381c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext)"}, - {VALIDATION_ERROR_43825a01, "The spec valid usage text states 'pTag must be a valid pointer to an array of tagSize bytes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter)"}, - {VALIDATION_ERROR_4382b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_4382f41b, "The spec valid usage text states 'tagSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength)"}, - {VALIDATION_ERROR_43a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsLabelEXT-pNext-pNext)"}, - {VALIDATION_ERROR_43a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsLabelEXT-sType-sType)"}, - {VALIDATION_ERROR_43a40801, "The spec valid usage text states 'pLabelName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsLabelEXT-pLabelName-parameter)"}, - {VALIDATION_ERROR_43c09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask)"}, - {VALIDATION_ERROR_43c0d61b, "The spec valid usage text states 'objectCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-objectCount-arraylength)"}, - {VALIDATION_ERROR_43c1b801, "The spec valid usage text states 'pMessage must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter)"}, - {VALIDATION_ERROR_43c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext)"}, - {VALIDATION_ERROR_43c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType)"}, - {VALIDATION_ERROR_43c42201, "The spec valid usage text states 'If pMessageIdName is not NULL, pMessageIdName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter)"}, - {VALIDATION_ERROR_43e00ef4, "The spec valid usage text states 'pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914)"}, - {VALIDATION_ERROR_43e09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask)"}, - {VALIDATION_ERROR_43e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_43e40a01, "The spec valid usage text states 'messageSeverity must be a valid combination of VkDebugUtilsMessageSeverityFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter)"}, - {VALIDATION_ERROR_43e40a03, "The spec valid usage text states 'messageSeverity must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask)"}, - {VALIDATION_ERROR_43e40c01, "The spec valid usage text states 'messageType must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter)"}, - {VALIDATION_ERROR_43e40c03, "The spec valid usage text states 'messageType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask)"}, - {VALIDATION_ERROR_4400bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter)"}, - {VALIDATION_ERROR_4400ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_44011e01, "The spec valid usage text states 'pCreateInfo must be a valid pointer to a valid VkDebugUtilsMessengerCreateInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter)"}, - {VALIDATION_ERROR_44041001, "The spec valid usage text states 'pMessenger must be a valid pointer to a VkDebugUtilsMessengerEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter)"}, - {VALIDATION_ERROR_4420bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter)"}, - {VALIDATION_ERROR_44240a01, "The spec valid usage text states 'messageSeverity must be a valid VkDebugUtilsMessageSeverityFlagBitsEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter)"}, - {VALIDATION_ERROR_44241201, "The spec valid usage text states 'messageTypes must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter)"}, - {VALIDATION_ERROR_44241203, "The spec valid usage text states 'messageTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask)"}, - {VALIDATION_ERROR_44242801, "The spec valid usage text states 'pCallbackData must be a valid pointer to a valid VkDebugUtilsMessengerCallbackDataEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter)"}, - {VALIDATION_ERROR_4442b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_4462b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_4464141b, "The spec valid usage text states 'vertexBindingDivisorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength)"}, - {VALIDATION_ERROR_44641601, "The spec valid usage text states 'pVertexBindingDivisors must be a valid pointer to an array of vertexBindingDivisorCount VkVertexInputBindingDivisorDescriptionEXT structures' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter)"}, - {VALIDATION_ERROR_44800ecc, "The spec valid usage text states 'externalFormat must be 0 or a value returned in the externalFormat member of VkAndroidHardwareBufferFormatPropertiesANDROID by an earlier call to vkGetAndroidHardwareBufferPropertiesANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFormatANDROID-externalFormat-01894)"}, - {VALIDATION_ERROR_4482b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkExternalFormatANDROID-sType-sType)"}, - {VALIDATION_ERROR_44a00eb0, "The spec valid usage text states 'If buffer is not NULL, Android hardware buffers must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880)"}, - {VALIDATION_ERROR_44a00eb2, "The spec valid usage text states 'If buffer is not NULL, it must be a valid Android hardware buffer object with format and usage compatible with Vulkan as described by VkExternalMemoryHandleTypeFlagBits.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881)"}, - {VALIDATION_ERROR_44a01a01, "The spec valid usage text states 'buffer must be a valid pointer to a AHardwareBuffer value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-parameter)"}, - {VALIDATION_ERROR_44a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType)"}, - {VALIDATION_ERROR_44c00eb4, "The spec valid usage text states 'VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882)"}, - {VALIDATION_ERROR_44c00eb6, "The spec valid usage text states 'If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo with non-NULL image member, then that image must already be bound to memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883)"}, - {VALIDATION_ERROR_44e00ef0, "The spec valid usage text states 'There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912)"}, - {VALIDATION_ERROR_44e00ef2, "The spec valid usage text states 'If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913)"}, - {VALIDATION_ERROR_44e02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_44e02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_44e02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_45000ef6, "The spec valid usage text states 'If VkAllocationCallbacks were provided when messenger was created, a compatible set of callbacks must be provided here' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915)"}, - {VALIDATION_ERROR_45000ef8, "The spec valid usage text states 'If no VkAllocationCallbacks were provided when messenger was created, pAllocator must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916)"}, - {VALIDATION_ERROR_4500bc01, "The spec valid usage text states 'instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter)"}, - {VALIDATION_ERROR_4500ec01, "The spec valid usage text states 'If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-parameter)"}, - {VALIDATION_ERROR_45042601, "The spec valid usage text states 'messenger must be a valid VkDebugUtilsMessengerEXT handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter)"}, - {VALIDATION_ERROR_45042607, "The spec valid usage text states 'messenger must have been created, allocated, or retrieved from instance' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent)"}, - {VALIDATION_ERROR_45200eb8, "The spec valid usage text states 'buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884)"}, - {VALIDATION_ERROR_45201a01, "The spec valid usage text states 'buffer must be a valid pointer to a valid AHardwareBuffer value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-parameter)"}, - {VALIDATION_ERROR_45205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter)"}, - {VALIDATION_ERROR_4521f401, "The spec valid usage text states 'pProperties must be a valid pointer to a VkAndroidHardwareBufferPropertiesANDROID structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetAndroidHardwareBufferPropertiesANDROID-pProperties-parameter)"}, - {VALIDATION_ERROR_45400eee, "The spec valid usage text states 'There must be an outstanding vkQueueBeginDebugUtilsLabelEXT command prior to the vkQueueEndDebugUtilsLabelEXT on the queue' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueEndDebugUtilsLabelEXT-None-01911)"}, - {VALIDATION_ERROR_45429c01, "The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter)"}, - {VALIDATION_ERROR_4562b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidHardwareBufferUsageANDROID-sType-sType)"}, - {VALIDATION_ERROR_45a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter)"}, - {VALIDATION_ERROR_45a10001, "The spec valid usage text states 'pBuffer must be a valid pointer to a valid pointer to a AHardwareBuffer value' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryAndroidHardwareBufferANDROID-pBuffer-parameter)"}, - {VALIDATION_ERROR_45a39c01, "The spec valid usage text states 'pInfo must be a valid pointer to a valid VkMemoryGetAndroidHardwareBufferInfoANDROID structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkGetMemoryAndroidHardwareBufferANDROID-pInfo-parameter)"}, - {VALIDATION_ERROR_45c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkAndroidHardwareBufferFormatPropertiesANDROID-sType-sType)"}, - {VALIDATION_ERROR_45e02401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_45e02413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_45e02415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_45e42401, "The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter)"}, - {VALIDATION_ERROR_46002401, "The spec valid usage text states 'commandBuffer must be a valid VkCommandBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter)"}, - {VALIDATION_ERROR_46002413, "The spec valid usage text states 'commandBuffer must be in the recording state' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording)"}, - {VALIDATION_ERROR_46002415, "The spec valid usage text states 'The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool)"}, - {VALIDATION_ERROR_46042401, "The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter)"}, - {VALIDATION_ERROR_46229c01, "The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter)"}, - {VALIDATION_ERROR_46242401, "The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter)"}, - {VALIDATION_ERROR_46429c01, "The spec valid usage text states 'queue must be a valid VkQueue handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter)"}, - {VALIDATION_ERROR_46442401, "The spec valid usage text states 'pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter)"}, - {VALIDATION_ERROR_46605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectNameEXT-device-parameter)"}, - {VALIDATION_ERROR_4661c201, "The spec valid usage text states 'pNameInfo must be a valid pointer to a valid VkDebugUtilsObjectNameInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter)"}, - {VALIDATION_ERROR_46805601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectTagEXT-device-parameter)"}, - {VALIDATION_ERROR_46825c01, "The spec valid usage text states 'pTagInfo must be a valid pointer to a valid VkDebugUtilsObjectTagInfoEXT structure' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter)"}, - {VALIDATION_ERROR_46a01774, "The spec valid usage text states 'If bindingCount is not zero, bindingCount must equal VkDescriptorSetLayoutCreateInfo::bindingCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-bindingCount-03002)"}, - {VALIDATION_ERROR_46a01776, "The spec valid usage text states 'If VkDescriptorSetLayoutCreateInfo::flags includes VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT, or VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-flags-03003)"}, - {VALIDATION_ERROR_46a01778, "The spec valid usage text states 'If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03004)"}, - {VALIDATION_ERROR_46a0177a, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformBufferUpdateAfterBind-03005)"}, - {VALIDATION_ERROR_46a0177c, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingSampledImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingSampledImageUpdateAfterBind-03006)"}, - {VALIDATION_ERROR_46a0177e, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageImageUpdateAfterBind-03007)"}, - {VALIDATION_ERROR_46a01780, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageBufferUpdateAfterBind-03008)"}, - {VALIDATION_ERROR_46a01782, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformTexelBufferUpdateAfterBind-03009)"}, - {VALIDATION_ERROR_46a01784, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageTexelBufferUpdateAfterBind-03010)"}, - {VALIDATION_ERROR_46a01786, "The spec valid usage text states 'All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-None-03011)"}, - {VALIDATION_ERROR_46a01788, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUpdateUnusedWhilePending is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUpdateUnusedWhilePending-03012)"}, - {VALIDATION_ERROR_46a0178a, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingPartiallyBound is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingPartiallyBound-03013)"}, - {VALIDATION_ERROR_46a0178c, "The spec valid usage text states 'If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingVariableDescriptorCount is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingVariableDescriptorCount-03014)"}, - {VALIDATION_ERROR_46a0178e, "The spec valid usage text states 'If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, that element's descriptorType must not be VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03015)"}, - {VALIDATION_ERROR_46a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_46a42a01, "The spec valid usage text states 'If bindingCount is not 0, pBindingFlags must be a valid pointer to an array of bindingCount valid combinations of VkDescriptorBindingFlagBitsEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-parameter)"}, - {VALIDATION_ERROR_46a42a03, "The spec valid usage text states 'Each element of pBindingFlags must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-requiredbitmask)"}, - {VALIDATION_ERROR_46c017ca, "The spec valid usage text states 'If descriptorSetCount is not zero, descriptorSetCount must equal VkDescriptorSetAllocateInfo::descriptorSetCount' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-descriptorSetCount-03045)"}, - {VALIDATION_ERROR_46c017cc, "The spec valid usage text states 'If VkDescriptorSetAllocateInfo::pSetLayouts[i] has a variable descriptor count binding, then pDescriptorCounts[i] must be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pSetLayouts-03046)"}, - {VALIDATION_ERROR_46c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-sType-sType)"}, - {VALIDATION_ERROR_46c42c01, "The spec valid usage text states 'If descriptorSetCount is not 0, pDescriptorCounts must be a valid pointer to an array of descriptorSetCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pDescriptorCounts-parameter)"}, - {VALIDATION_ERROR_46e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDescriptorSetVariableDescriptorCountLayoutSupportEXT-sType-sType)"}, - {VALIDATION_ERROR_4702b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceDescriptorIndexingFeaturesEXT-sType-sType)"}, - {VALIDATION_ERROR_4722b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceDescriptorIndexingPropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_4742b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType)"}, - {VALIDATION_ERROR_47600e9a, "The spec valid usage text states 'binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869)"}, - {VALIDATION_ERROR_47600e9c, "The spec valid usage text states 'divisor must be a value between 0 and VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870)"}, - {VALIDATION_ERROR_47600e9e, "The spec valid usage text states 'VkVertexInputBindingDescription::inputRate must be of type VK_VERTEX_INPUT_RATE_INSTANCE for this binding.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871)"}, -}; - - -// Mapping from spec validation error text string to unique validation error enum -static std::unordered_map validation_error_text_map{ - {"VUID-VkAcquireNextImageInfoKHR-commonparent", VALIDATION_ERROR_00000009}, - {"VUID-VkAcquireNextImageInfoKHR-semaphore-01288", VALIDATION_ERROR_00000a10}, - {"VUID-VkAcquireNextImageInfoKHR-fence-01289", VALIDATION_ERROR_00000a12}, - {"VUID-VkAcquireNextImageInfoKHR-deviceMask-01290", VALIDATION_ERROR_00000a14}, - {"VUID-VkAcquireNextImageInfoKHR-deviceMask-01291", VALIDATION_ERROR_00000a16}, - {"VUID-VkAcquireNextImageInfoKHR-swapchain-01675", VALIDATION_ERROR_00000d16}, - {"VUID-VkAcquireNextImageInfoKHR-semaphore-01781", VALIDATION_ERROR_00000dea}, - {"VUID-VkAcquireNextImageInfoKHR-semaphore-01782", VALIDATION_ERROR_00000dec}, - {"VUID-VkAcquireNextImageInfoKHR-semaphore-01804", VALIDATION_ERROR_00000e18}, - {"VUID-VkAcquireNextImageInfoKHR-fence-parameter", VALIDATION_ERROR_00008801}, - {"VUID-VkAcquireNextImageInfoKHR-pNext-pNext", VALIDATION_ERROR_0001c40d}, - {"VUID-VkAcquireNextImageInfoKHR-sType-sType", VALIDATION_ERROR_0002b00b}, - {"VUID-VkAcquireNextImageInfoKHR-semaphore-parameter", VALIDATION_ERROR_0002b801}, - {"VUID-VkAcquireNextImageInfoKHR-swapchain-parameter", VALIDATION_ERROR_0002f001}, - {"VUID-VkAllocationCallbacks-pfnAllocation-00632", VALIDATION_ERROR_002004f0}, - {"VUID-VkAllocationCallbacks-pfnReallocation-00633", VALIDATION_ERROR_002004f2}, - {"VUID-VkAllocationCallbacks-pfnFree-00634", VALIDATION_ERROR_002004f4}, - {"VUID-VkAllocationCallbacks-pfnInternalAllocation-00635", VALIDATION_ERROR_002004f6}, - {"VUID-VkAndroidSurfaceCreateInfoKHR-window-01248", VALIDATION_ERROR_004009c0}, - {"VUID-VkAndroidSurfaceCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_00409005}, - {"VUID-VkAndroidSurfaceCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_0041c40d}, - {"VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType", VALIDATION_ERROR_0042b00b}, - {"VUID-VkApplicationInfo-pApplicationName-parameter", VALIDATION_ERROR_0060f001}, - {"VUID-VkApplicationInfo-pEngineName-parameter", VALIDATION_ERROR_00615c01}, - {"VUID-VkApplicationInfo-pNext-pNext", VALIDATION_ERROR_0061c40d}, - {"VUID-VkApplicationInfo-sType-sType", VALIDATION_ERROR_0062b00b}, - {"VUID-VkAttachmentDescription-finalLayout-00843", VALIDATION_ERROR_00800696}, - {"VUID-VkAttachmentDescription-finalLayout-parameter", VALIDATION_ERROR_00808e01}, - {"VUID-VkAttachmentDescription-flags-parameter", VALIDATION_ERROR_00809001}, - {"VUID-VkAttachmentDescription-format-parameter", VALIDATION_ERROR_00809201}, - {"VUID-VkAttachmentDescription-initialLayout-parameter", VALIDATION_ERROR_0080b801}, - {"VUID-VkAttachmentDescription-loadOp-parameter", VALIDATION_ERROR_0080c201}, - {"VUID-VkAttachmentDescription-samples-parameter", VALIDATION_ERROR_0082b401}, - {"VUID-VkAttachmentDescription-stencilLoadOp-parameter", VALIDATION_ERROR_0082e001}, - {"VUID-VkAttachmentDescription-stencilStoreOp-parameter", VALIDATION_ERROR_0082e201}, - {"VUID-VkAttachmentDescription-storeOp-parameter", VALIDATION_ERROR_0082e401}, - {"VUID-VkAttachmentReference-layout-00857", VALIDATION_ERROR_00a006b2}, - {"VUID-VkAttachmentReference-layout-parameter", VALIDATION_ERROR_00a0be01}, - {"VUID-VkBindBufferMemoryInfo-commonparent", VALIDATION_ERROR_00c00009}, - {"VUID-VkBindBufferMemoryInfo-buffer-01593", VALIDATION_ERROR_00c00c72}, - {"VUID-VkBindBufferMemoryInfo-buffer-01594", VALIDATION_ERROR_00c00c74}, - {"VUID-VkBindBufferMemoryInfo-memoryOffset-01595", VALIDATION_ERROR_00c00c76}, - {"VUID-VkBindBufferMemoryInfo-buffer-01596", VALIDATION_ERROR_00c00c78}, - {"VUID-VkBindBufferMemoryInfo-buffer-01597", VALIDATION_ERROR_00c00c7a}, - {"VUID-VkBindBufferMemoryInfo-buffer-01598", VALIDATION_ERROR_00c00c7c}, - {"VUID-VkBindBufferMemoryInfo-memory-01599", VALIDATION_ERROR_00c00c7e}, - {"VUID-VkBindBufferMemoryInfo-memoryOffset-01600", VALIDATION_ERROR_00c00c80}, - {"VUID-VkBindBufferMemoryInfo-size-01601", VALIDATION_ERROR_00c00c82}, - {"VUID-VkBindBufferMemoryInfo-buffer-01602", VALIDATION_ERROR_00c00c84}, - {"VUID-VkBindBufferMemoryInfo-buffer-01603", VALIDATION_ERROR_00c00c86}, - {"VUID-VkBindBufferMemoryInfo-buffer-01604", VALIDATION_ERROR_00c00c88}, - {"VUID-VkBindBufferMemoryInfo-pNext-01605", VALIDATION_ERROR_00c00c8a}, - {"VUID-VkBindBufferMemoryInfo-memory-01900", VALIDATION_ERROR_00c00ed8}, - {"VUID-VkBindBufferMemoryInfo-buffer-parameter", VALIDATION_ERROR_00c01a01}, - {"VUID-VkBindBufferMemoryInfo-memory-parameter", VALIDATION_ERROR_00c0c601}, - {"VUID-VkBindBufferMemoryInfo-pNext-pNext", VALIDATION_ERROR_00c1c40d}, - {"VUID-VkBindBufferMemoryInfo-sType-sType", VALIDATION_ERROR_00c2b00b}, - {"VUID-VkBindImageMemoryInfo-commonparent", VALIDATION_ERROR_00e00009}, - {"VUID-VkBindImageMemoryInfo-image-01609", VALIDATION_ERROR_00e00c92}, - {"VUID-VkBindImageMemoryInfo-image-01610", VALIDATION_ERROR_00e00c94}, - {"VUID-VkBindImageMemoryInfo-memoryOffset-01611", VALIDATION_ERROR_00e00c96}, - {"VUID-VkBindImageMemoryInfo-memory-01612", VALIDATION_ERROR_00e00c98}, - {"VUID-VkBindImageMemoryInfo-memoryOffset-01613", VALIDATION_ERROR_00e00c9a}, - {"VUID-VkBindImageMemoryInfo-memory-01614", VALIDATION_ERROR_00e00c9c}, - {"VUID-VkBindImageMemoryInfo-pNext-01615", VALIDATION_ERROR_00e00c9e}, - {"VUID-VkBindImageMemoryInfo-pNext-01616", VALIDATION_ERROR_00e00ca0}, - {"VUID-VkBindImageMemoryInfo-pNext-01617", VALIDATION_ERROR_00e00ca2}, - {"VUID-VkBindImageMemoryInfo-pNext-01618", VALIDATION_ERROR_00e00ca4}, - {"VUID-VkBindImageMemoryInfo-pNext-01619", VALIDATION_ERROR_00e00ca6}, - {"VUID-VkBindImageMemoryInfo-pNext-01620", VALIDATION_ERROR_00e00ca8}, - {"VUID-VkBindImageMemoryInfo-pNext-01621", VALIDATION_ERROR_00e00caa}, - {"VUID-VkBindImageMemoryInfo-image-01622", VALIDATION_ERROR_00e00cac}, - {"VUID-VkBindImageMemoryInfo-image-01623", VALIDATION_ERROR_00e00cae}, - {"VUID-VkBindImageMemoryInfo-image-01624", VALIDATION_ERROR_00e00cb0}, - {"VUID-VkBindImageMemoryInfo-memory-01625", VALIDATION_ERROR_00e00cb2}, - {"VUID-VkBindImageMemoryInfo-pNext-01626", VALIDATION_ERROR_00e00cb4}, - {"VUID-VkBindImageMemoryInfo-pNext-01627", VALIDATION_ERROR_00e00cb6}, - {"VUID-VkBindImageMemoryInfo-pNext-01628", VALIDATION_ERROR_00e00cb8}, - {"VUID-VkBindImageMemoryInfo-pNext-01629", VALIDATION_ERROR_00e00cba}, - {"VUID-VkBindImageMemoryInfo-image-01630", VALIDATION_ERROR_00e00cbc}, - {"VUID-VkBindImageMemoryInfo-pNext-01631", VALIDATION_ERROR_00e00cbe}, - {"VUID-VkBindImageMemoryInfo-pNext-01632", VALIDATION_ERROR_00e00cc0}, - {"VUID-VkBindImageMemoryInfo-memory-01903", VALIDATION_ERROR_00e00ede}, - {"VUID-VkBindImageMemoryInfo-image-parameter", VALIDATION_ERROR_00e0a001}, - {"VUID-VkBindImageMemoryInfo-pNext-pNext", VALIDATION_ERROR_00e1c40d}, - {"VUID-VkBindImageMemoryInfo-sType-sType", VALIDATION_ERROR_00e2b00b}, - {"VUID-VkBindImageMemoryInfo-sType-unique", VALIDATION_ERROR_00e2b00f}, - {"VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644", VALIDATION_ERROR_01000cd8}, - {"VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType", VALIDATION_ERROR_0102b00b}, - {"VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter", VALIDATION_ERROR_0102f001}, - {"VUID-VkBindSparseInfo-commonparent", VALIDATION_ERROR_01200009}, - {"VUID-VkBindSparseInfo-pBufferBinds-parameter", VALIDATION_ERROR_01210201}, - {"VUID-VkBindSparseInfo-pImageBinds-parameter", VALIDATION_ERROR_01218001}, - {"VUID-VkBindSparseInfo-pImageOpaqueBinds-parameter", VALIDATION_ERROR_01218c01}, - {"VUID-VkBindSparseInfo-pNext-pNext", VALIDATION_ERROR_0121c40d}, - {"VUID-VkBindSparseInfo-pSignalSemaphores-parameter", VALIDATION_ERROR_01223401}, - {"VUID-VkBindSparseInfo-pWaitSemaphores-parameter", VALIDATION_ERROR_01227601}, - {"VUID-VkBindSparseInfo-sType-sType", VALIDATION_ERROR_0122b00b}, - {"VUID-VkBufferCreateInfo-size-00912", VALIDATION_ERROR_01400720}, - {"VUID-VkBufferCreateInfo-sharingMode-00913", VALIDATION_ERROR_01400722}, - {"VUID-VkBufferCreateInfo-sharingMode-00914", VALIDATION_ERROR_01400724}, - {"VUID-VkBufferCreateInfo-flags-00915", VALIDATION_ERROR_01400726}, - {"VUID-VkBufferCreateInfo-flags-00916", VALIDATION_ERROR_01400728}, - {"VUID-VkBufferCreateInfo-flags-00917", VALIDATION_ERROR_0140072a}, - {"VUID-VkBufferCreateInfo-flags-00918", VALIDATION_ERROR_0140072c}, - {"VUID-VkBufferCreateInfo-pNext-00920", VALIDATION_ERROR_01400730}, - {"VUID-VkBufferCreateInfo-sharingMode-01391", VALIDATION_ERROR_01400ade}, - {"VUID-VkBufferCreateInfo-sharingMode-01419", VALIDATION_ERROR_01400b16}, - {"VUID-VkBufferCreateInfo-pNext-01571", VALIDATION_ERROR_01400c46}, - {"VUID-VkBufferCreateInfo-flags-01887", VALIDATION_ERROR_01400ebe}, - {"VUID-VkBufferCreateInfo-None-01888", VALIDATION_ERROR_01400ec0}, - {"VUID-VkBufferCreateInfo-flags-parameter", VALIDATION_ERROR_01409001}, - {"VUID-VkBufferCreateInfo-pNext-pNext", VALIDATION_ERROR_0141c40d}, - {"VUID-VkBufferCreateInfo-sType-sType", VALIDATION_ERROR_0142b00b}, - {"VUID-VkBufferCreateInfo-sType-unique", VALIDATION_ERROR_0142b00f}, - {"VUID-VkBufferCreateInfo-sharingMode-parameter", VALIDATION_ERROR_0142c001}, - {"VUID-VkBufferCreateInfo-usage-parameter", VALIDATION_ERROR_01430601}, - {"VUID-VkBufferCreateInfo-usage-requiredbitmask", VALIDATION_ERROR_01430603}, - {"VUID-VkBufferImageCopy-bufferOffset-00193", VALIDATION_ERROR_01600182}, - {"VUID-VkBufferImageCopy-bufferOffset-00194", VALIDATION_ERROR_01600184}, - {"VUID-VkBufferImageCopy-bufferRowLength-00195", VALIDATION_ERROR_01600186}, - {"VUID-VkBufferImageCopy-bufferImageHeight-00196", VALIDATION_ERROR_01600188}, - {"VUID-VkBufferImageCopy-imageOffset-00197", VALIDATION_ERROR_0160018a}, - {"VUID-VkBufferImageCopy-imageOffset-00198", VALIDATION_ERROR_0160018c}, - {"VUID-VkBufferImageCopy-srcImage-00199", VALIDATION_ERROR_0160018e}, - {"VUID-VkBufferImageCopy-imageOffset-00200", VALIDATION_ERROR_01600190}, - {"VUID-VkBufferImageCopy-srcImage-00201", VALIDATION_ERROR_01600192}, - {"VUID-VkBufferImageCopy-bufferRowLength-00203", VALIDATION_ERROR_01600196}, - {"VUID-VkBufferImageCopy-bufferImageHeight-00204", VALIDATION_ERROR_01600198}, - {"VUID-VkBufferImageCopy-imageOffset-00205", VALIDATION_ERROR_0160019a}, - {"VUID-VkBufferImageCopy-bufferOffset-00206", VALIDATION_ERROR_0160019c}, - {"VUID-VkBufferImageCopy-imageExtent-00207", VALIDATION_ERROR_0160019e}, - {"VUID-VkBufferImageCopy-imageExtent-00208", VALIDATION_ERROR_016001a0}, - {"VUID-VkBufferImageCopy-imageExtent-00209", VALIDATION_ERROR_016001a2}, - {"VUID-VkBufferImageCopy-aspectMask-00211", VALIDATION_ERROR_016001a6}, - {"VUID-VkBufferImageCopy-aspectMask-00212", VALIDATION_ERROR_016001a8}, - {"VUID-VkBufferImageCopy-baseArrayLayer-00213", VALIDATION_ERROR_016001aa}, - {"VUID-VkBufferImageCopy-None-00214", VALIDATION_ERROR_016001ac}, - {"VUID-VkBufferImageCopy-bufferOffset-01558", VALIDATION_ERROR_01600c2c}, - {"VUID-VkBufferImageCopy-bufferOffset-01559", VALIDATION_ERROR_01600c2e}, - {"VUID-VkBufferImageCopy-aspectMask-01560", VALIDATION_ERROR_01600c30}, - {"VUID-VkBufferImageCopy-None-01735", VALIDATION_ERROR_01600d8e}, - {"VUID-VkBufferImageCopy-None-01736", VALIDATION_ERROR_01600d90}, - {"VUID-VkBufferImageCopy-None-01737", VALIDATION_ERROR_01600d92}, - {"VUID-VkBufferImageCopy-None-01738", VALIDATION_ERROR_01600d94}, - {"VUID-VkBufferImageCopy-None-01739", VALIDATION_ERROR_01600d96}, - {"VUID-VkBufferImageCopy-None-01740", VALIDATION_ERROR_01600d98}, - {"VUID-VkBufferImageCopy-None-01741", VALIDATION_ERROR_01600d9a}, - {"VUID-VkBufferImageCopy-imageSubresource-parameter", VALIDATION_ERROR_0160aa01}, - {"VUID-VkBufferMemoryBarrier-offset-01187", VALIDATION_ERROR_01800946}, - {"VUID-VkBufferMemoryBarrier-size-01188", VALIDATION_ERROR_01800948}, - {"VUID-VkBufferMemoryBarrier-size-01189", VALIDATION_ERROR_0180094a}, - {"VUID-VkBufferMemoryBarrier-buffer-01190", VALIDATION_ERROR_0180094c}, - {"VUID-VkBufferMemoryBarrier-buffer-01191", VALIDATION_ERROR_0180094e}, - {"VUID-VkBufferMemoryBarrier-buffer-01192", VALIDATION_ERROR_01800950}, - {"VUID-VkBufferMemoryBarrier-buffer-01193", VALIDATION_ERROR_01800952}, - {"VUID-VkBufferMemoryBarrier-buffer-01196", VALIDATION_ERROR_01800958}, - {"VUID-VkBufferMemoryBarrier-buffer-01763", VALIDATION_ERROR_01800dc6}, - {"VUID-VkBufferMemoryBarrier-buffer-01764", VALIDATION_ERROR_01800dc8}, - {"VUID-VkBufferMemoryBarrier-buffer-01765", VALIDATION_ERROR_01800dca}, - {"VUID-VkBufferMemoryBarrier-buffer-01931", VALIDATION_ERROR_01800f16}, - {"VUID-VkBufferMemoryBarrier-buffer-parameter", VALIDATION_ERROR_01801a01}, - {"VUID-VkBufferMemoryBarrier-dstAccessMask-parameter", VALIDATION_ERROR_01806801}, - {"VUID-VkBufferMemoryBarrier-pNext-pNext", VALIDATION_ERROR_0181c40d}, - {"VUID-VkBufferMemoryBarrier-sType-sType", VALIDATION_ERROR_0182b00b}, - {"VUID-VkBufferMemoryBarrier-srcAccessMask-parameter", VALIDATION_ERROR_0182c401}, - {"VUID-VkBufferViewCreateInfo-offset-00925", VALIDATION_ERROR_01a0073a}, - {"VUID-VkBufferViewCreateInfo-offset-00926", VALIDATION_ERROR_01a0073c}, - {"VUID-VkBufferViewCreateInfo-range-00928", VALIDATION_ERROR_01a00740}, - {"VUID-VkBufferViewCreateInfo-range-00929", VALIDATION_ERROR_01a00742}, - {"VUID-VkBufferViewCreateInfo-range-00930", VALIDATION_ERROR_01a00744}, - {"VUID-VkBufferViewCreateInfo-offset-00931", VALIDATION_ERROR_01a00746}, - {"VUID-VkBufferViewCreateInfo-buffer-00932", VALIDATION_ERROR_01a00748}, - {"VUID-VkBufferViewCreateInfo-buffer-00933", VALIDATION_ERROR_01a0074a}, - {"VUID-VkBufferViewCreateInfo-buffer-00934", VALIDATION_ERROR_01a0074c}, - {"VUID-VkBufferViewCreateInfo-buffer-00935", VALIDATION_ERROR_01a0074e}, - {"VUID-VkBufferViewCreateInfo-buffer-parameter", VALIDATION_ERROR_01a01a01}, - {"VUID-VkBufferViewCreateInfo-flags-zerobitmask", VALIDATION_ERROR_01a09005}, - {"VUID-VkBufferViewCreateInfo-format-parameter", VALIDATION_ERROR_01a09201}, - {"VUID-VkBufferViewCreateInfo-pNext-pNext", VALIDATION_ERROR_01a1c40d}, - {"VUID-VkBufferViewCreateInfo-sType-sType", VALIDATION_ERROR_01a2b00b}, - {"VUID-VkClearAttachment-aspectMask-00019", VALIDATION_ERROR_01c00026}, - {"VUID-VkClearAttachment-aspectMask-00020", VALIDATION_ERROR_01c00028}, - {"VUID-VkClearAttachment-clearValue-00021", VALIDATION_ERROR_01c0002a}, - {"VUID-VkClearAttachment-aspectMask-parameter", VALIDATION_ERROR_01c00c01}, - {"VUID-VkClearAttachment-aspectMask-requiredbitmask", VALIDATION_ERROR_01c00c03}, - {"VUID-VkClearAttachment-commandBuffer-01809", VALIDATION_ERROR_01c00e22}, - {"VUID-VkClearAttachment-commandBuffer-01810", VALIDATION_ERROR_01c00e24}, - {"VUID-VkClearDepthStencilValue-depth-00022", VALIDATION_ERROR_01e0002c}, - {"VUID-VkClearValue-depthStencil-00023", VALIDATION_ERROR_0200002e}, - {"VUID-VkCmdProcessCommandsInfoNVX-commonparent", VALIDATION_ERROR_02200009}, - {"VUID-VkCmdProcessCommandsInfoNVX-objectTable-01331", VALIDATION_ERROR_02200a66}, - {"VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-01332", VALIDATION_ERROR_02200a68}, - {"VUID-VkCmdProcessCommandsInfoNVX-tokenType-01333", VALIDATION_ERROR_02200a6a}, - {"VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01334", VALIDATION_ERROR_02200a6c}, - {"VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01335", VALIDATION_ERROR_02200a6e}, - {"VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01336", VALIDATION_ERROR_02200a70}, - {"VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01337", VALIDATION_ERROR_02200a72}, - {"VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01338", VALIDATION_ERROR_02200a74}, - {"VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01339", VALIDATION_ERROR_02200a76}, - {"VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01340", VALIDATION_ERROR_02200a78}, - {"VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01341", VALIDATION_ERROR_02200a7a}, - {"VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter", VALIDATION_ERROR_0220b401}, - {"VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-arraylength", VALIDATION_ERROR_0220b61b}, - {"VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter", VALIDATION_ERROR_0220d801}, - {"VUID-VkCmdProcessCommandsInfoNVX-pIndirectCommandsTokens-parameter", VALIDATION_ERROR_02219401}, - {"VUID-VkCmdProcessCommandsInfoNVX-pNext-pNext", VALIDATION_ERROR_0221c40d}, - {"VUID-VkCmdProcessCommandsInfoNVX-sType-sType", VALIDATION_ERROR_0222b00b}, - {"VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter", VALIDATION_ERROR_0222ba01}, - {"VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter", VALIDATION_ERROR_0222bc01}, - {"VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter", VALIDATION_ERROR_0222f601}, - {"VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent", VALIDATION_ERROR_02400009}, - {"VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter", VALIDATION_ERROR_0240b401}, - {"VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter", VALIDATION_ERROR_0240d801}, - {"VUID-VkCmdReserveSpaceForCommandsInfoNVX-pNext-pNext", VALIDATION_ERROR_0241c40d}, - {"VUID-VkCmdReserveSpaceForCommandsInfoNVX-sType-sType", VALIDATION_ERROR_0242b00b}, - {"VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044", VALIDATION_ERROR_02600058}, - {"VUID-VkCommandBufferAllocateInfo-commandPool-parameter", VALIDATION_ERROR_02602801}, - {"VUID-VkCommandBufferAllocateInfo-level-parameter", VALIDATION_ERROR_0260c001}, - {"VUID-VkCommandBufferAllocateInfo-pNext-pNext", VALIDATION_ERROR_0261c40d}, - {"VUID-VkCommandBufferAllocateInfo-sType-sType", VALIDATION_ERROR_0262b00b}, - {"VUID-VkCommandBufferBeginInfo-flags-00053", VALIDATION_ERROR_0280006a}, - {"VUID-VkCommandBufferBeginInfo-flags-00054", VALIDATION_ERROR_0280006c}, - {"VUID-VkCommandBufferBeginInfo-flags-00055", VALIDATION_ERROR_0280006e}, - {"VUID-VkCommandBufferBeginInfo-flags-parameter", VALIDATION_ERROR_02809001}, - {"VUID-VkCommandBufferBeginInfo-pNext-pNext", VALIDATION_ERROR_0281c40d}, - {"VUID-VkCommandBufferBeginInfo-sType-sType", VALIDATION_ERROR_0282b00b}, - {"VUID-VkCommandBufferInheritanceInfo-commonparent", VALIDATION_ERROR_02a00009}, - {"VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056", VALIDATION_ERROR_02a00070}, - {"VUID-VkCommandBufferInheritanceInfo-queryFlags-00057", VALIDATION_ERROR_02a00072}, - {"VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058", VALIDATION_ERROR_02a00074}, - {"VUID-VkCommandBufferInheritanceInfo-pNext-pNext", VALIDATION_ERROR_02a1c40d}, - {"VUID-VkCommandBufferInheritanceInfo-sType-sType", VALIDATION_ERROR_02a2b00b}, - {"VUID-VkCommandPoolCreateInfo-queueFamilyIndex-00039", VALIDATION_ERROR_02c0004e}, - {"VUID-VkCommandPoolCreateInfo-flags-parameter", VALIDATION_ERROR_02c09001}, - {"VUID-VkCommandPoolCreateInfo-pNext-pNext", VALIDATION_ERROR_02c1c40d}, - {"VUID-VkCommandPoolCreateInfo-sType-sType", VALIDATION_ERROR_02c2b00b}, - {"VUID-VkComponentMapping-a-parameter", VALIDATION_ERROR_02e00001}, - {"VUID-VkComponentMapping-b-parameter", VALIDATION_ERROR_02e01001}, - {"VUID-VkComponentMapping-g-parameter", VALIDATION_ERROR_02e09a01}, - {"VUID-VkComponentMapping-r-parameter", VALIDATION_ERROR_02e2a201}, - {"VUID-VkComputePipelineCreateInfo-commonparent", VALIDATION_ERROR_03000009}, - {"VUID-VkComputePipelineCreateInfo-flags-00697", VALIDATION_ERROR_03000572}, - {"VUID-VkComputePipelineCreateInfo-flags-00698", VALIDATION_ERROR_03000574}, - {"VUID-VkComputePipelineCreateInfo-flags-00699", VALIDATION_ERROR_03000576}, - {"VUID-VkComputePipelineCreateInfo-flags-00700", VALIDATION_ERROR_03000578}, - {"VUID-VkComputePipelineCreateInfo-stage-00701", VALIDATION_ERROR_0300057a}, - {"VUID-VkComputePipelineCreateInfo-stage-00702", VALIDATION_ERROR_0300057c}, - {"VUID-VkComputePipelineCreateInfo-layout-00703", VALIDATION_ERROR_0300057e}, - {"VUID-VkComputePipelineCreateInfo-layout-01687", VALIDATION_ERROR_03000d2e}, - {"VUID-VkComputePipelineCreateInfo-flags-parameter", VALIDATION_ERROR_03009001}, - {"VUID-VkComputePipelineCreateInfo-layout-parameter", VALIDATION_ERROR_0300be01}, - {"VUID-VkComputePipelineCreateInfo-pNext-pNext", VALIDATION_ERROR_0301c40d}, - {"VUID-VkComputePipelineCreateInfo-sType-sType", VALIDATION_ERROR_0302b00b}, - {"VUID-VkComputePipelineCreateInfo-stage-parameter", VALIDATION_ERROR_0302d801}, - {"VUID-VkCopyDescriptorSet-commonparent", VALIDATION_ERROR_03200009}, - {"VUID-VkCopyDescriptorSet-srcBinding-00345", VALIDATION_ERROR_032002b2}, - {"VUID-VkCopyDescriptorSet-srcArrayElement-00346", VALIDATION_ERROR_032002b4}, - {"VUID-VkCopyDescriptorSet-dstBinding-00347", VALIDATION_ERROR_032002b6}, - {"VUID-VkCopyDescriptorSet-dstArrayElement-00348", VALIDATION_ERROR_032002b8}, - {"VUID-VkCopyDescriptorSet-srcSet-00349", VALIDATION_ERROR_032002ba}, - {"VUID-VkCopyDescriptorSet-srcSet-01918", VALIDATION_ERROR_03200efc}, - {"VUID-VkCopyDescriptorSet-srcSet-01919", VALIDATION_ERROR_03200efe}, - {"VUID-VkCopyDescriptorSet-srcSet-01920", VALIDATION_ERROR_03200f00}, - {"VUID-VkCopyDescriptorSet-srcSet-01921", VALIDATION_ERROR_03200f02}, - {"VUID-VkCopyDescriptorSet-dstSet-parameter", VALIDATION_ERROR_03207601}, - {"VUID-VkCopyDescriptorSet-pNext-pNext", VALIDATION_ERROR_0321c40d}, - {"VUID-VkCopyDescriptorSet-sType-sType", VALIDATION_ERROR_0322b00b}, - {"VUID-VkCopyDescriptorSet-srcSet-parameter", VALIDATION_ERROR_0322d201}, - {"VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079", VALIDATION_ERROR_0340009e}, - {"VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080", VALIDATION_ERROR_034000a0}, - {"VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter", VALIDATION_ERROR_03423201}, - {"VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter", VALIDATION_ERROR_03427401}, - {"VUID-VkD3D12FenceSubmitInfoKHR-sType-sType", VALIDATION_ERROR_0342b00b}, - {"VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter", VALIDATION_ERROR_0361a801}, - {"VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext", VALIDATION_ERROR_0361c40d}, - {"VUID-VkDebugMarkerMarkerInfoEXT-sType-sType", VALIDATION_ERROR_0362b00b}, - {"VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490", VALIDATION_ERROR_03800ba4}, - {"VUID-VkDebugMarkerObjectNameInfoEXT-object-01491", VALIDATION_ERROR_03800ba6}, - {"VUID-VkDebugMarkerObjectNameInfoEXT-object-01492", VALIDATION_ERROR_03800ba8}, - {"VUID-VkDebugMarkerObjectNameInfoEXT-objectType-parameter", VALIDATION_ERROR_0380da01}, - {"VUID-VkDebugMarkerObjectNameInfoEXT-pNext-pNext", VALIDATION_ERROR_0381c40d}, - {"VUID-VkDebugMarkerObjectNameInfoEXT-pObjectName-parameter", VALIDATION_ERROR_0381ce01}, - {"VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType", VALIDATION_ERROR_0382b00b}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493", VALIDATION_ERROR_03a00baa}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-object-01494", VALIDATION_ERROR_03a00bac}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-object-01495", VALIDATION_ERROR_03a00bae}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-objectType-parameter", VALIDATION_ERROR_03a0da01}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-pNext-pNext", VALIDATION_ERROR_03a1c40d}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-pTag-parameter", VALIDATION_ERROR_03a25a01}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType", VALIDATION_ERROR_03a2b00b}, - {"VUID-VkDebugMarkerObjectTagInfoEXT-tagSize-arraylength", VALIDATION_ERROR_03a2f41b}, - {"VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-01385", VALIDATION_ERROR_03c00ad2}, - {"VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter", VALIDATION_ERROR_03c09001}, - {"VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType", VALIDATION_ERROR_03c2b00b}, - {"VUID-VkDedicatedAllocationBufferCreateInfoNV-sType-sType", VALIDATION_ERROR_03e2b00b}, - {"VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994", VALIDATION_ERROR_040007c4}, - {"VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType", VALIDATION_ERROR_0402b00b}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-commonparent", VALIDATION_ERROR_04200009}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649", VALIDATION_ERROR_04200512}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650", VALIDATION_ERROR_04200514}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651", VALIDATION_ERROR_04200516}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652", VALIDATION_ERROR_04200518}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653", VALIDATION_ERROR_0420051a}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654", VALIDATION_ERROR_0420051c}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655", VALIDATION_ERROR_0420051e}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter", VALIDATION_ERROR_04201a01}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter", VALIDATION_ERROR_0420a001}, - {"VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType", VALIDATION_ERROR_0422b00b}, - {"VUID-VkDescriptorBufferInfo-offset-00340", VALIDATION_ERROR_044002a8}, - {"VUID-VkDescriptorBufferInfo-range-00341", VALIDATION_ERROR_044002aa}, - {"VUID-VkDescriptorBufferInfo-range-00342", VALIDATION_ERROR_044002ac}, - {"VUID-VkDescriptorBufferInfo-buffer-parameter", VALIDATION_ERROR_04401a01}, - {"VUID-VkDescriptorImageInfo-commonparent", VALIDATION_ERROR_04600009}, - {"VUID-VkDescriptorImageInfo-imageView-00343", VALIDATION_ERROR_046002ae}, - {"VUID-VkDescriptorImageInfo-imageLayout-00344", VALIDATION_ERROR_046002b0}, - {"VUID-VkDescriptorImageInfo-sampler-01563", VALIDATION_ERROR_04600c36}, - {"VUID-VkDescriptorImageInfo-sampler-01564", VALIDATION_ERROR_04600c38}, - {"VUID-VkDescriptorPoolCreateInfo-maxSets-00301", VALIDATION_ERROR_0480025a}, - {"VUID-VkDescriptorPoolCreateInfo-flags-parameter", VALIDATION_ERROR_04809001}, - {"VUID-VkDescriptorPoolCreateInfo-pNext-pNext", VALIDATION_ERROR_0481c40d}, - {"VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter", VALIDATION_ERROR_0481e401}, - {"VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength", VALIDATION_ERROR_0482881b}, - {"VUID-VkDescriptorPoolCreateInfo-sType-sType", VALIDATION_ERROR_0482b00b}, - {"VUID-VkDescriptorPoolSize-descriptorCount-00302", VALIDATION_ERROR_04a0025c}, - {"VUID-VkDescriptorPoolSize-type-parameter", VALIDATION_ERROR_04a30401}, - {"VUID-VkDescriptorSetAllocateInfo-commonparent", VALIDATION_ERROR_04c00009}, - {"VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-00306", VALIDATION_ERROR_04c00264}, - {"VUID-VkDescriptorSetAllocateInfo-descriptorPool-00307", VALIDATION_ERROR_04c00266}, - {"VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308", VALIDATION_ERROR_04c00268}, - {"VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044", VALIDATION_ERROR_04c017c8}, - {"VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter", VALIDATION_ERROR_04c04601}, - {"VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength", VALIDATION_ERROR_04c04a1b}, - {"VUID-VkDescriptorSetAllocateInfo-pNext-pNext", VALIDATION_ERROR_04c1c40d}, - {"VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter", VALIDATION_ERROR_04c22c01}, - {"VUID-VkDescriptorSetAllocateInfo-sType-sType", VALIDATION_ERROR_04c2b00b}, - {"VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", VALIDATION_ERROR_04e00234}, - {"VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283", VALIDATION_ERROR_04e00236}, - {"VUID-VkDescriptorSetLayoutBinding-descriptorType-01510", VALIDATION_ERROR_04e00bcc}, - {"VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter", VALIDATION_ERROR_04e04e01}, - {"VUID-VkDescriptorSetLayoutCreateInfo-binding-00279", VALIDATION_ERROR_0500022e}, - {"VUID-VkDescriptorSetLayoutCreateInfo-flags-00280", VALIDATION_ERROR_05000230}, - {"VUID-VkDescriptorSetLayoutCreateInfo-flags-00281", VALIDATION_ERROR_05000232}, - {"VUID-VkDescriptorSetLayoutCreateInfo-flags-03000", VALIDATION_ERROR_05001770}, - {"VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001", VALIDATION_ERROR_05001772}, - {"VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter", VALIDATION_ERROR_05009001}, - {"VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter", VALIDATION_ERROR_0500fc01}, - {"VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext", VALIDATION_ERROR_0501c40d}, - {"VUID-VkDescriptorSetLayoutCreateInfo-sType-sType", VALIDATION_ERROR_0502b00b}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent", VALIDATION_ERROR_05200009}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350", VALIDATION_ERROR_052002bc}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351", VALIDATION_ERROR_052002be}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352", VALIDATION_ERROR_052002c0}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353", VALIDATION_ERROR_052002c2}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter", VALIDATION_ERROR_05204c01}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorUpdateEntryCount-arraylength", VALIDATION_ERROR_0520501b}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_05209005}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-pDescriptorUpdateEntries-parameter", VALIDATION_ERROR_05213201}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-pNext-pNext", VALIDATION_ERROR_0521c40d}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-sType-sType", VALIDATION_ERROR_0522b00b}, - {"VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-parameter", VALIDATION_ERROR_0522f801}, - {"VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354", VALIDATION_ERROR_054002c4}, - {"VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355", VALIDATION_ERROR_054002c6}, - {"VUID-VkDescriptorUpdateTemplateEntry-descriptorType-parameter", VALIDATION_ERROR_05404e01}, - {"VUID-VkDeviceCreateInfo-queueFamilyIndex-00372", VALIDATION_ERROR_056002e8}, - {"VUID-VkDeviceCreateInfo-pNext-00373", VALIDATION_ERROR_056002ea}, - {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374", VALIDATION_ERROR_056002ec}, - {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840", VALIDATION_ERROR_05600e60}, - {"VUID-VkDeviceCreateInfo-flags-zerobitmask", VALIDATION_ERROR_05609005}, - {"VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter", VALIDATION_ERROR_05615a01}, - {"VUID-VkDeviceCreateInfo-pNext-pNext", VALIDATION_ERROR_0561c40d}, - {"VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter", VALIDATION_ERROR_0561fe01}, - {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter", VALIDATION_ERROR_05628e01}, - {"VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter", VALIDATION_ERROR_05629001}, - {"VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength", VALIDATION_ERROR_0562a01b}, - {"VUID-VkDeviceCreateInfo-sType-sType", VALIDATION_ERROR_0562b00b}, - {"VUID-VkDeviceCreateInfo-sType-unique", VALIDATION_ERROR_0562b00f}, - {"VUID-VkDeviceEventInfoEXT-deviceEvent-parameter", VALIDATION_ERROR_05805801}, - {"VUID-VkDeviceEventInfoEXT-pNext-pNext", VALIDATION_ERROR_0581c40d}, - {"VUID-VkDeviceEventInfoEXT-sType-sType", VALIDATION_ERROR_0582b00b}, - {"VUID-VkDeviceGeneratedCommandsFeaturesNVX-pNext-pNext", VALIDATION_ERROR_05a1c40d}, - {"VUID-VkDeviceGeneratedCommandsFeaturesNVX-sType-sType", VALIDATION_ERROR_05a2b00b}, - {"VUID-VkDeviceGeneratedCommandsLimitsNVX-pNext-pNext", VALIDATION_ERROR_05c1c40d}, - {"VUID-VkDeviceGeneratedCommandsLimitsNVX-sType-sType", VALIDATION_ERROR_05c2b00b}, - {"VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118", VALIDATION_ERROR_05e008bc}, - {"VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119", VALIDATION_ERROR_05e008be}, - {"VUID-VkDeviceGroupBindSparseInfo-sType-sType", VALIDATION_ERROR_05e2b00b}, - {"VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106", VALIDATION_ERROR_060000d4}, - {"VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107", VALIDATION_ERROR_060000d6}, - {"VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType", VALIDATION_ERROR_0602b00b}, - {"VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375", VALIDATION_ERROR_062002ee}, - {"VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376", VALIDATION_ERROR_062002f0}, - {"VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377", VALIDATION_ERROR_062002f2}, - {"VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter", VALIDATION_ERROR_0621dc01}, - {"VUID-VkDeviceGroupDeviceCreateInfo-sType-sType", VALIDATION_ERROR_0622b00b}, - {"VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297", VALIDATION_ERROR_06400a22}, - {"VUID-VkDeviceGroupPresentInfoKHR-mode-01298", VALIDATION_ERROR_06400a24}, - {"VUID-VkDeviceGroupPresentInfoKHR-mode-01299", VALIDATION_ERROR_06400a26}, - {"VUID-VkDeviceGroupPresentInfoKHR-mode-01300", VALIDATION_ERROR_06400a28}, - {"VUID-VkDeviceGroupPresentInfoKHR-mode-01301", VALIDATION_ERROR_06400a2a}, - {"VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302", VALIDATION_ERROR_06400a2c}, - {"VUID-VkDeviceGroupPresentInfoKHR-mode-01303", VALIDATION_ERROR_06400a2e}, - {"VUID-VkDeviceGroupPresentInfoKHR-mode-parameter", VALIDATION_ERROR_0640ce01}, - {"VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter", VALIDATION_ERROR_06414001}, - {"VUID-VkDeviceGroupPresentInfoKHR-sType-sType", VALIDATION_ERROR_0642b00b}, - {"VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905", VALIDATION_ERROR_06600712}, - {"VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906", VALIDATION_ERROR_06600714}, - {"VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907", VALIDATION_ERROR_06600716}, - {"VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908", VALIDATION_ERROR_06600718}, - {"VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter", VALIDATION_ERROR_06614201}, - {"VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType", VALIDATION_ERROR_0662b00b}, - {"VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082", VALIDATION_ERROR_068000a4}, - {"VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083", VALIDATION_ERROR_068000a6}, - {"VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084", VALIDATION_ERROR_068000a8}, - {"VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085", VALIDATION_ERROR_068000aa}, - {"VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086", VALIDATION_ERROR_068000ac}, - {"VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter", VALIDATION_ERROR_06811201}, - {"VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter", VALIDATION_ERROR_06823001}, - {"VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter", VALIDATION_ERROR_06827201}, - {"VUID-VkDeviceGroupSubmitInfo-sType-sType", VALIDATION_ERROR_0682b00b}, - {"VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter", VALIDATION_ERROR_06a0d001}, - {"VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask", VALIDATION_ERROR_06a0d003}, - {"VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType", VALIDATION_ERROR_06a2b00b}, - {"VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381", VALIDATION_ERROR_06c002fa}, - {"VUID-VkDeviceQueueCreateInfo-queueCount-00382", VALIDATION_ERROR_06c002fc}, - {"VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383", VALIDATION_ERROR_06c002fe}, - {"VUID-VkDeviceQueueCreateInfo-flags-parameter", VALIDATION_ERROR_06c09001}, - {"VUID-VkDeviceQueueCreateInfo-pNext-pNext", VALIDATION_ERROR_06c1c40d}, - {"VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter", VALIDATION_ERROR_06c20401}, - {"VUID-VkDeviceQueueCreateInfo-queueCount-arraylength", VALIDATION_ERROR_06c29e1b}, - {"VUID-VkDeviceQueueCreateInfo-sType-sType", VALIDATION_ERROR_06c2b00b}, - {"VUID-VkDispatchIndirectCommand-x-00417", VALIDATION_ERROR_06e00342}, - {"VUID-VkDispatchIndirectCommand-y-00418", VALIDATION_ERROR_06e00344}, - {"VUID-VkDispatchIndirectCommand-z-00419", VALIDATION_ERROR_06e00346}, - {"VUID-VkDisplayEventInfoEXT-displayEvent-parameter", VALIDATION_ERROR_07006201}, - {"VUID-VkDisplayEventInfoEXT-pNext-pNext", VALIDATION_ERROR_0701c40d}, - {"VUID-VkDisplayEventInfoEXT-sType-sType", VALIDATION_ERROR_0702b00b}, - {"VUID-VkDisplayModeCreateInfoKHR-width-01250", VALIDATION_ERROR_072009c4}, - {"VUID-VkDisplayModeCreateInfoKHR-refreshRate-01251", VALIDATION_ERROR_072009c6}, - {"VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_07209005}, - {"VUID-VkDisplayModeCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_0721c40d}, - {"VUID-VkDisplayModeCreateInfoKHR-sType-sType", VALIDATION_ERROR_0722b00b}, - {"VUID-VkDisplayPowerInfoEXT-pNext-pNext", VALIDATION_ERROR_0741c40d}, - {"VUID-VkDisplayPowerInfoEXT-powerState-parameter", VALIDATION_ERROR_07428a01}, - {"VUID-VkDisplayPowerInfoEXT-sType-sType", VALIDATION_ERROR_0742b00b}, - {"VUID-VkDisplayPresentInfoKHR-srcRect-01257", VALIDATION_ERROR_076009d2}, - {"VUID-VkDisplayPresentInfoKHR-dstRect-01258", VALIDATION_ERROR_076009d4}, - {"VUID-VkDisplayPresentInfoKHR-persistentContent-01259", VALIDATION_ERROR_076009d6}, - {"VUID-VkDisplayPresentInfoKHR-sType-sType", VALIDATION_ERROR_0762b00b}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252", VALIDATION_ERROR_078009c8}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253", VALIDATION_ERROR_078009ca}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254", VALIDATION_ERROR_078009cc}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255", VALIDATION_ERROR_078009ce}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-width-01256", VALIDATION_ERROR_078009d0}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter", VALIDATION_ERROR_07800a01}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter", VALIDATION_ERROR_07806401}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_07809005}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_0781c40d}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType", VALIDATION_ERROR_0782b00b}, - {"VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter", VALIDATION_ERROR_07830201}, - {"VUID-VkDrawIndexedIndirectCommand-None-00552", VALIDATION_ERROR_07a00450}, - {"VUID-VkDrawIndexedIndirectCommand-indexSize-00553", VALIDATION_ERROR_07a00452}, - {"VUID-VkDrawIndexedIndirectCommand-firstInstance-00554", VALIDATION_ERROR_07a00454}, - {"VUID-VkDrawIndirectCommand-None-00500", VALIDATION_ERROR_07c003e8}, - {"VUID-VkDrawIndirectCommand-firstInstance-00501", VALIDATION_ERROR_07c003ea}, - {"VUID-VkEventCreateInfo-flags-zerobitmask", VALIDATION_ERROR_07e09005}, - {"VUID-VkEventCreateInfo-pNext-pNext", VALIDATION_ERROR_07e1c40d}, - {"VUID-VkEventCreateInfo-sType-sType", VALIDATION_ERROR_07e2b00b}, - {"VUID-VkExportMemoryAllocateInfo-handleTypes-00656", VALIDATION_ERROR_08000520}, - {"VUID-VkExportMemoryAllocateInfo-handleTypes-parameter", VALIDATION_ERROR_08009e01}, - {"VUID-VkExportMemoryAllocateInfo-sType-sType", VALIDATION_ERROR_0802b00b}, - {"VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter", VALIDATION_ERROR_08209e01}, - {"VUID-VkExportMemoryAllocateInfoNV-sType-sType", VALIDATION_ERROR_0822b00b}, - {"VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657", VALIDATION_ERROR_08400522}, - {"VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter", VALIDATION_ERROR_0840f401}, - {"VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_0842b00b}, - {"VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter", VALIDATION_ERROR_0860f401}, - {"VUID-VkExportMemoryWin32HandleInfoNV-sType-sType", VALIDATION_ERROR_0862b00b}, - {"VUID-VkExportSemaphoreCreateInfo-handleTypes-01124", VALIDATION_ERROR_088008c8}, - {"VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter", VALIDATION_ERROR_08809e01}, - {"VUID-VkExportSemaphoreCreateInfo-sType-sType", VALIDATION_ERROR_0882b00b}, - {"VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125", VALIDATION_ERROR_08a008ca}, - {"VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter", VALIDATION_ERROR_08a0f401}, - {"VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_08a2b00b}, - {"VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter", VALIDATION_ERROR_08c09e01}, - {"VUID-VkExternalMemoryBufferCreateInfo-sType-sType", VALIDATION_ERROR_08c2b00b}, - {"VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter", VALIDATION_ERROR_08e09e01}, - {"VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask", VALIDATION_ERROR_08e09e03}, - {"VUID-VkExternalMemoryImageCreateInfo-sType-sType", VALIDATION_ERROR_08e2b00b}, - {"VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter", VALIDATION_ERROR_09009e01}, - {"VUID-VkExternalMemoryImageCreateInfoNV-sType-sType", VALIDATION_ERROR_0902b00b}, - {"VUID-VkFenceCreateInfo-flags-parameter", VALIDATION_ERROR_09209001}, - {"VUID-VkFenceCreateInfo-pNext-pNext", VALIDATION_ERROR_0921c40d}, - {"VUID-VkFenceCreateInfo-sType-sType", VALIDATION_ERROR_0922b00b}, - {"VUID-VkFenceCreateInfo-sType-unique", VALIDATION_ERROR_0922b00f}, - {"VUID-VkFramebufferCreateInfo-commonparent", VALIDATION_ERROR_09400009}, - {"VUID-VkFramebufferCreateInfo-attachmentCount-00876", VALIDATION_ERROR_094006d8}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00877", VALIDATION_ERROR_094006da}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00878", VALIDATION_ERROR_094006dc}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00879", VALIDATION_ERROR_094006de}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00880", VALIDATION_ERROR_094006e0}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00881", VALIDATION_ERROR_094006e2}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00882", VALIDATION_ERROR_094006e4}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00883", VALIDATION_ERROR_094006e6}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00884", VALIDATION_ERROR_094006e8}, - {"VUID-VkFramebufferCreateInfo-width-00885", VALIDATION_ERROR_094006ea}, - {"VUID-VkFramebufferCreateInfo-width-00886", VALIDATION_ERROR_094006ec}, - {"VUID-VkFramebufferCreateInfo-height-00887", VALIDATION_ERROR_094006ee}, - {"VUID-VkFramebufferCreateInfo-height-00888", VALIDATION_ERROR_094006f0}, - {"VUID-VkFramebufferCreateInfo-layers-00889", VALIDATION_ERROR_094006f2}, - {"VUID-VkFramebufferCreateInfo-layers-00890", VALIDATION_ERROR_094006f4}, - {"VUID-VkFramebufferCreateInfo-pAttachments-00891", VALIDATION_ERROR_094006f6}, - {"VUID-VkFramebufferCreateInfo-flags-zerobitmask", VALIDATION_ERROR_09409005}, - {"VUID-VkFramebufferCreateInfo-pAttachments-parameter", VALIDATION_ERROR_0940f201}, - {"VUID-VkFramebufferCreateInfo-pNext-pNext", VALIDATION_ERROR_0941c40d}, - {"VUID-VkFramebufferCreateInfo-renderPass-parameter", VALIDATION_ERROR_0942ae01}, - {"VUID-VkFramebufferCreateInfo-sType-sType", VALIDATION_ERROR_0942b00b}, - {"VUID-VkGraphicsPipelineCreateInfo-commonparent", VALIDATION_ERROR_09600009}, - {"VUID-VkGraphicsPipelineCreateInfo-flags-00722", VALIDATION_ERROR_096005a4}, - {"VUID-VkGraphicsPipelineCreateInfo-flags-00723", VALIDATION_ERROR_096005a6}, - {"VUID-VkGraphicsPipelineCreateInfo-flags-00724", VALIDATION_ERROR_096005a8}, - {"VUID-VkGraphicsPipelineCreateInfo-flags-00725", VALIDATION_ERROR_096005aa}, - {"VUID-VkGraphicsPipelineCreateInfo-stage-00726", VALIDATION_ERROR_096005ac}, - {"VUID-VkGraphicsPipelineCreateInfo-stage-00727", VALIDATION_ERROR_096005ae}, - {"VUID-VkGraphicsPipelineCreateInfo-stage-00728", VALIDATION_ERROR_096005b0}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00729", VALIDATION_ERROR_096005b2}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00730", VALIDATION_ERROR_096005b4}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00731", VALIDATION_ERROR_096005b6}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00732", VALIDATION_ERROR_096005b8}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00733", VALIDATION_ERROR_096005ba}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00734", VALIDATION_ERROR_096005bc}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00735", VALIDATION_ERROR_096005be}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00736", VALIDATION_ERROR_096005c0}, - {"VUID-VkGraphicsPipelineCreateInfo-topology-00737", VALIDATION_ERROR_096005c2}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00738", VALIDATION_ERROR_096005c4}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00739", VALIDATION_ERROR_096005c6}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00740", VALIDATION_ERROR_096005c8}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00741", VALIDATION_ERROR_096005ca}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-00742", VALIDATION_ERROR_096005cc}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-00743", VALIDATION_ERROR_096005ce}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-00744", VALIDATION_ERROR_096005d0}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-00745", VALIDATION_ERROR_096005d2}, - {"VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746", VALIDATION_ERROR_096005d4}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747", VALIDATION_ERROR_096005d6}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748", VALIDATION_ERROR_096005d8}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749", VALIDATION_ERROR_096005da}, - {"VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750", VALIDATION_ERROR_096005dc}, - {"VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751", VALIDATION_ERROR_096005de}, - {"VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752", VALIDATION_ERROR_096005e0}, - {"VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753", VALIDATION_ERROR_096005e2}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754", VALIDATION_ERROR_096005e4}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755", VALIDATION_ERROR_096005e6}, - {"VUID-VkGraphicsPipelineCreateInfo-layout-00756", VALIDATION_ERROR_096005e8}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-00757", VALIDATION_ERROR_096005ea}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-00758", VALIDATION_ERROR_096005ec}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-00759", VALIDATION_ERROR_096005ee}, - {"VUID-VkGraphicsPipelineCreateInfo-renderPass-00760", VALIDATION_ERROR_096005f0}, - {"VUID-VkGraphicsPipelineCreateInfo-renderPass-00761", VALIDATION_ERROR_096005f2}, - {"VUID-VkGraphicsPipelineCreateInfo-renderPass-00762", VALIDATION_ERROR_096005f4}, - {"VUID-VkGraphicsPipelineCreateInfo-renderPass-00763", VALIDATION_ERROR_096005f6}, - {"VUID-VkGraphicsPipelineCreateInfo-flags-00764", VALIDATION_ERROR_096005f8}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-01411", VALIDATION_ERROR_09600b06}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-01412", VALIDATION_ERROR_09600b08}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-01505", VALIDATION_ERROR_09600bc2}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521", VALIDATION_ERROR_09600be2}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522", VALIDATION_ERROR_09600be4}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523", VALIDATION_ERROR_09600be6}, - {"VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524", VALIDATION_ERROR_09600be8}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-01565", VALIDATION_ERROR_09600c3a}, - {"VUID-VkGraphicsPipelineCreateInfo-layout-01688", VALIDATION_ERROR_09600d30}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715", VALIDATION_ERROR_09600d66}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-01756", VALIDATION_ERROR_09600db8}, - {"VUID-VkGraphicsPipelineCreateInfo-subpass-01757", VALIDATION_ERROR_09600dba}, - {"VUID-VkGraphicsPipelineCreateInfo-flags-parameter", VALIDATION_ERROR_09609001}, - {"VUID-VkGraphicsPipelineCreateInfo-layout-parameter", VALIDATION_ERROR_0960be01}, - {"VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter", VALIDATION_ERROR_09615601}, - {"VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter", VALIDATION_ERROR_09619801}, - {"VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", VALIDATION_ERROR_0961c40d}, - {"VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter", VALIDATION_ERROR_09620801}, - {"VUID-VkGraphicsPipelineCreateInfo-pStages-parameter", VALIDATION_ERROR_09623e01}, - {"VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter", VALIDATION_ERROR_09626801}, - {"VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter", VALIDATION_ERROR_0962ae01}, - {"VUID-VkGraphicsPipelineCreateInfo-sType-sType", VALIDATION_ERROR_0962b00b}, - {"VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength", VALIDATION_ERROR_0962da1b}, - {"VUID-VkIOSSurfaceCreateInfoMVK-pView-01316", VALIDATION_ERROR_09800a48}, - {"VUID-VkIOSSurfaceCreateInfoMVK-flags-zerobitmask", VALIDATION_ERROR_09809005}, - {"VUID-VkIOSSurfaceCreateInfoMVK-pNext-pNext", VALIDATION_ERROR_0981c40d}, - {"VUID-VkIOSSurfaceCreateInfoMVK-sType-sType", VALIDATION_ERROR_0982b00b}, - {"VUID-VkImageBlit-aspectMask-00238", VALIDATION_ERROR_09a001dc}, - {"VUID-VkImageBlit-layerCount-00239", VALIDATION_ERROR_09a001de}, - {"VUID-VkImageBlit-srcImage-00240", VALIDATION_ERROR_09a001e0}, - {"VUID-VkImageBlit-aspectMask-00241", VALIDATION_ERROR_09a001e2}, - {"VUID-VkImageBlit-aspectMask-00242", VALIDATION_ERROR_09a001e4}, - {"VUID-VkImageBlit-srcOffset-00243", VALIDATION_ERROR_09a001e6}, - {"VUID-VkImageBlit-srcOffset-00244", VALIDATION_ERROR_09a001e8}, - {"VUID-VkImageBlit-srcImage-00245", VALIDATION_ERROR_09a001ea}, - {"VUID-VkImageBlit-srcOffset-00246", VALIDATION_ERROR_09a001ec}, - {"VUID-VkImageBlit-srcImage-00247", VALIDATION_ERROR_09a001ee}, - {"VUID-VkImageBlit-dstOffset-00248", VALIDATION_ERROR_09a001f0}, - {"VUID-VkImageBlit-dstOffset-00249", VALIDATION_ERROR_09a001f2}, - {"VUID-VkImageBlit-dstImage-00250", VALIDATION_ERROR_09a001f4}, - {"VUID-VkImageBlit-dstOffset-00251", VALIDATION_ERROR_09a001f6}, - {"VUID-VkImageBlit-dstImage-00252", VALIDATION_ERROR_09a001f8}, - {"VUID-VkImageBlit-dstSubresource-parameter", VALIDATION_ERROR_09a07a01}, - {"VUID-VkImageBlit-srcSubresource-parameter", VALIDATION_ERROR_09a2d601}, - {"VUID-VkImageCopy-aspectMask-00137", VALIDATION_ERROR_09c00112}, - {"VUID-VkImageCopy-layerCount-00138", VALIDATION_ERROR_09c00114}, - {"VUID-VkImageCopy-srcImage-00139", VALIDATION_ERROR_09c00116}, - {"VUID-VkImageCopy-extent-00140", VALIDATION_ERROR_09c00118}, - {"VUID-VkImageCopy-srcImage-00141", VALIDATION_ERROR_09c0011a}, - {"VUID-VkImageCopy-aspectMask-00142", VALIDATION_ERROR_09c0011c}, - {"VUID-VkImageCopy-aspectMask-00143", VALIDATION_ERROR_09c0011e}, - {"VUID-VkImageCopy-srcOffset-00144", VALIDATION_ERROR_09c00120}, - {"VUID-VkImageCopy-srcOffset-00145", VALIDATION_ERROR_09c00122}, - {"VUID-VkImageCopy-srcImage-00146", VALIDATION_ERROR_09c00124}, - {"VUID-VkImageCopy-srcOffset-00147", VALIDATION_ERROR_09c00126}, - {"VUID-VkImageCopy-dstOffset-00150", VALIDATION_ERROR_09c0012c}, - {"VUID-VkImageCopy-dstOffset-00151", VALIDATION_ERROR_09c0012e}, - {"VUID-VkImageCopy-dstImage-00152", VALIDATION_ERROR_09c00130}, - {"VUID-VkImageCopy-dstOffset-00153", VALIDATION_ERROR_09c00132}, - {"VUID-VkImageCopy-srcOffset-00157", VALIDATION_ERROR_09c0013a}, - {"VUID-VkImageCopy-extent-00158", VALIDATION_ERROR_09c0013c}, - {"VUID-VkImageCopy-extent-00159", VALIDATION_ERROR_09c0013e}, - {"VUID-VkImageCopy-extent-00160", VALIDATION_ERROR_09c00140}, - {"VUID-VkImageCopy-dstOffset-00162", VALIDATION_ERROR_09c00144}, - {"VUID-VkImageCopy-extent-00163", VALIDATION_ERROR_09c00146}, - {"VUID-VkImageCopy-extent-00164", VALIDATION_ERROR_09c00148}, - {"VUID-VkImageCopy-extent-00165", VALIDATION_ERROR_09c0014a}, - {"VUID-VkImageCopy-srcImage-01551", VALIDATION_ERROR_09c00c1e}, - {"VUID-VkImageCopy-srcImage-01552", VALIDATION_ERROR_09c00c20}, - {"VUID-VkImageCopy-srcImage-01553", VALIDATION_ERROR_09c00c22}, - {"VUID-VkImageCopy-dstImage-01554", VALIDATION_ERROR_09c00c24}, - {"VUID-VkImageCopy-dstImage-01555", VALIDATION_ERROR_09c00c26}, - {"VUID-VkImageCopy-srcImage-01556", VALIDATION_ERROR_09c00c28}, - {"VUID-VkImageCopy-dstImage-01557", VALIDATION_ERROR_09c00c2a}, - {"VUID-VkImageCopy-srcImage-01727", VALIDATION_ERROR_09c00d7e}, - {"VUID-VkImageCopy-srcImage-01728", VALIDATION_ERROR_09c00d80}, - {"VUID-VkImageCopy-srcImage-01729", VALIDATION_ERROR_09c00d82}, - {"VUID-VkImageCopy-srcImage-01730", VALIDATION_ERROR_09c00d84}, - {"VUID-VkImageCopy-dstImage-01731", VALIDATION_ERROR_09c00d86}, - {"VUID-VkImageCopy-dstImage-01732", VALIDATION_ERROR_09c00d88}, - {"VUID-VkImageCopy-dstImage-01733", VALIDATION_ERROR_09c00d8a}, - {"VUID-VkImageCopy-dstImage-01734", VALIDATION_ERROR_09c00d8c}, - {"VUID-VkImageCopy-srcImage-01785", VALIDATION_ERROR_09c00df2}, - {"VUID-VkImageCopy-dstImage-01786", VALIDATION_ERROR_09c00df4}, - {"VUID-VkImageCopy-srcImage-01787", VALIDATION_ERROR_09c00df6}, - {"VUID-VkImageCopy-dstImage-01788", VALIDATION_ERROR_09c00df8}, - {"VUID-VkImageCopy-srcImage-01789", VALIDATION_ERROR_09c00dfa}, - {"VUID-VkImageCopy-srcImage-01790", VALIDATION_ERROR_09c00dfc}, - {"VUID-VkImageCopy-srcImage-01791", VALIDATION_ERROR_09c00dfe}, - {"VUID-VkImageCopy-dstImage-01792", VALIDATION_ERROR_09c00e00}, - {"VUID-VkImageCopy-dstSubresource-parameter", VALIDATION_ERROR_09c07a01}, - {"VUID-VkImageCopy-srcSubresource-parameter", VALIDATION_ERROR_09c2d601}, - {"VUID-VkImageCreateInfo-format-00940", VALIDATION_ERROR_09e00758}, - {"VUID-VkImageCreateInfo-sharingMode-00941", VALIDATION_ERROR_09e0075a}, - {"VUID-VkImageCreateInfo-sharingMode-00942", VALIDATION_ERROR_09e0075c}, - {"VUID-VkImageCreateInfo-format-00943", VALIDATION_ERROR_09e0075e}, - {"VUID-VkImageCreateInfo-extent-00944", VALIDATION_ERROR_09e00760}, - {"VUID-VkImageCreateInfo-extent-00945", VALIDATION_ERROR_09e00762}, - {"VUID-VkImageCreateInfo-extent-00946", VALIDATION_ERROR_09e00764}, - {"VUID-VkImageCreateInfo-mipLevels-00947", VALIDATION_ERROR_09e00766}, - {"VUID-VkImageCreateInfo-arrayLayers-00948", VALIDATION_ERROR_09e00768}, - {"VUID-VkImageCreateInfo-flags-00949", VALIDATION_ERROR_09e0076a}, - {"VUID-VkImageCreateInfo-flags-00950", VALIDATION_ERROR_09e0076c}, - {"VUID-VkImageCreateInfo-imageType-00951", VALIDATION_ERROR_09e0076e}, - {"VUID-VkImageCreateInfo-imageType-00952", VALIDATION_ERROR_09e00770}, - {"VUID-VkImageCreateInfo-imageType-00953", VALIDATION_ERROR_09e00772}, - {"VUID-VkImageCreateInfo-imageType-00954", VALIDATION_ERROR_09e00774}, - {"VUID-VkImageCreateInfo-imageType-00955", VALIDATION_ERROR_09e00776}, - {"VUID-VkImageCreateInfo-imageType-00956", VALIDATION_ERROR_09e00778}, - {"VUID-VkImageCreateInfo-imageType-00957", VALIDATION_ERROR_09e0077a}, - {"VUID-VkImageCreateInfo-mipLevels-00958", VALIDATION_ERROR_09e0077c}, - {"VUID-VkImageCreateInfo-extent-00959", VALIDATION_ERROR_09e0077e}, - {"VUID-VkImageCreateInfo-arrayLayers-00960", VALIDATION_ERROR_09e00780}, - {"VUID-VkImageCreateInfo-imageType-00961", VALIDATION_ERROR_09e00782}, - {"VUID-VkImageCreateInfo-samples-00962", VALIDATION_ERROR_09e00784}, - {"VUID-VkImageCreateInfo-usage-00963", VALIDATION_ERROR_09e00786}, - {"VUID-VkImageCreateInfo-usage-00964", VALIDATION_ERROR_09e00788}, - {"VUID-VkImageCreateInfo-usage-00965", VALIDATION_ERROR_09e0078a}, - {"VUID-VkImageCreateInfo-usage-00966", VALIDATION_ERROR_09e0078c}, - {"VUID-VkImageCreateInfo-samples-00967", VALIDATION_ERROR_09e0078e}, - {"VUID-VkImageCreateInfo-usage-00968", VALIDATION_ERROR_09e00790}, - {"VUID-VkImageCreateInfo-flags-00969", VALIDATION_ERROR_09e00792}, - {"VUID-VkImageCreateInfo-imageType-00970", VALIDATION_ERROR_09e00794}, - {"VUID-VkImageCreateInfo-imageType-00971", VALIDATION_ERROR_09e00796}, - {"VUID-VkImageCreateInfo-imageType-00972", VALIDATION_ERROR_09e00798}, - {"VUID-VkImageCreateInfo-imageType-00973", VALIDATION_ERROR_09e0079a}, - {"VUID-VkImageCreateInfo-imageType-00974", VALIDATION_ERROR_09e0079c}, - {"VUID-VkImageCreateInfo-imageType-00975", VALIDATION_ERROR_09e0079e}, - {"VUID-VkImageCreateInfo-imageType-00976", VALIDATION_ERROR_09e007a0}, - {"VUID-VkImageCreateInfo-flags-00987", VALIDATION_ERROR_09e007b6}, - {"VUID-VkImageCreateInfo-pNext-00988", VALIDATION_ERROR_09e007b8}, - {"VUID-VkImageCreateInfo-pNext-00990", VALIDATION_ERROR_09e007bc}, - {"VUID-VkImageCreateInfo-pNext-00991", VALIDATION_ERROR_09e007be}, - {"VUID-VkImageCreateInfo-flags-00992", VALIDATION_ERROR_09e007c0}, - {"VUID-VkImageCreateInfo-initialLayout-00993", VALIDATION_ERROR_09e007c2}, - {"VUID-VkImageCreateInfo-sharingMode-01392", VALIDATION_ERROR_09e00ae0}, - {"VUID-VkImageCreateInfo-sharingMode-01420", VALIDATION_ERROR_09e00b18}, - {"VUID-VkImageCreateInfo-physicalDeviceCount-01421", VALIDATION_ERROR_09e00b1a}, - {"VUID-VkImageCreateInfo-pNext-01443", VALIDATION_ERROR_09e00b46}, - {"VUID-VkImageCreateInfo-flags-01533", VALIDATION_ERROR_09e00bfa}, - {"VUID-VkImageCreateInfo-flags-01572", VALIDATION_ERROR_09e00c48}, - {"VUID-VkImageCreateInfo-flags-01573", VALIDATION_ERROR_09e00c4a}, - {"VUID-VkImageCreateInfo-format-01574", VALIDATION_ERROR_09e00c4c}, - {"VUID-VkImageCreateInfo-tiling-01575", VALIDATION_ERROR_09e00c4e}, - {"VUID-VkImageCreateInfo-tiling-01576", VALIDATION_ERROR_09e00c50}, - {"VUID-VkImageCreateInfo-format-01577", VALIDATION_ERROR_09e00c52}, - {"VUID-VkImageCreateInfo-pNext-01889", VALIDATION_ERROR_09e00ec2}, - {"VUID-VkImageCreateInfo-flags-01890", VALIDATION_ERROR_09e00ec4}, - {"VUID-VkImageCreateInfo-None-01891", VALIDATION_ERROR_09e00ec6}, - {"VUID-VkImageCreateInfo-pNext-01892", VALIDATION_ERROR_09e00ec8}, - {"VUID-VkImageCreateInfo-pNext-01893", VALIDATION_ERROR_09e00eca}, - {"VUID-VkImageCreateInfo-flags-01924", VALIDATION_ERROR_09e00f08}, - {"VUID-VkImageCreateInfo-None-01925", VALIDATION_ERROR_09e00f0a}, - {"VUID-VkImageCreateInfo-flags-parameter", VALIDATION_ERROR_09e09001}, - {"VUID-VkImageCreateInfo-format-parameter", VALIDATION_ERROR_09e09201}, - {"VUID-VkImageCreateInfo-imageType-parameter", VALIDATION_ERROR_09e0ac01}, - {"VUID-VkImageCreateInfo-initialLayout-parameter", VALIDATION_ERROR_09e0b801}, - {"VUID-VkImageCreateInfo-pNext-pNext", VALIDATION_ERROR_09e1c40d}, - {"VUID-VkImageCreateInfo-sType-sType", VALIDATION_ERROR_09e2b00b}, - {"VUID-VkImageCreateInfo-sType-unique", VALIDATION_ERROR_09e2b00f}, - {"VUID-VkImageCreateInfo-samples-parameter", VALIDATION_ERROR_09e2b401}, - {"VUID-VkImageCreateInfo-sharingMode-parameter", VALIDATION_ERROR_09e2c001}, - {"VUID-VkImageCreateInfo-tiling-parameter", VALIDATION_ERROR_09e2fa01}, - {"VUID-VkImageCreateInfo-usage-parameter", VALIDATION_ERROR_09e30601}, - {"VUID-VkImageCreateInfo-usage-requiredbitmask", VALIDATION_ERROR_09e30603}, - {"VUID-VkImageMemoryBarrier-oldLayout-01197", VALIDATION_ERROR_0a00095a}, - {"VUID-VkImageMemoryBarrier-newLayout-01198", VALIDATION_ERROR_0a00095c}, - {"VUID-VkImageMemoryBarrier-image-01199", VALIDATION_ERROR_0a00095e}, - {"VUID-VkImageMemoryBarrier-image-01200", VALIDATION_ERROR_0a000960}, - {"VUID-VkImageMemoryBarrier-image-01201", VALIDATION_ERROR_0a000962}, - {"VUID-VkImageMemoryBarrier-image-01205", VALIDATION_ERROR_0a00096a}, - {"VUID-VkImageMemoryBarrier-image-01207", VALIDATION_ERROR_0a00096e}, - {"VUID-VkImageMemoryBarrier-oldLayout-01208", VALIDATION_ERROR_0a000970}, - {"VUID-VkImageMemoryBarrier-oldLayout-01209", VALIDATION_ERROR_0a000972}, - {"VUID-VkImageMemoryBarrier-oldLayout-01210", VALIDATION_ERROR_0a000974}, - {"VUID-VkImageMemoryBarrier-oldLayout-01211", VALIDATION_ERROR_0a000976}, - {"VUID-VkImageMemoryBarrier-oldLayout-01212", VALIDATION_ERROR_0a000978}, - {"VUID-VkImageMemoryBarrier-oldLayout-01213", VALIDATION_ERROR_0a00097a}, - {"VUID-VkImageMemoryBarrier-image-01381", VALIDATION_ERROR_0a000aca}, - {"VUID-VkImageMemoryBarrier-subresourceRange-01486", VALIDATION_ERROR_0a000b9c}, - {"VUID-VkImageMemoryBarrier-subresourceRange-01488", VALIDATION_ERROR_0a000ba0}, - {"VUID-VkImageMemoryBarrier-oldLayout-01658", VALIDATION_ERROR_0a000cf4}, - {"VUID-VkImageMemoryBarrier-oldLayout-01659", VALIDATION_ERROR_0a000cf6}, - {"VUID-VkImageMemoryBarrier-image-01671", VALIDATION_ERROR_0a000d0e}, - {"VUID-VkImageMemoryBarrier-image-01672", VALIDATION_ERROR_0a000d10}, - {"VUID-VkImageMemoryBarrier-image-01673", VALIDATION_ERROR_0a000d12}, - {"VUID-VkImageMemoryBarrier-subresourceRange-01724", VALIDATION_ERROR_0a000d78}, - {"VUID-VkImageMemoryBarrier-subresourceRange-01725", VALIDATION_ERROR_0a000d7a}, - {"VUID-VkImageMemoryBarrier-image-01766", VALIDATION_ERROR_0a000dcc}, - {"VUID-VkImageMemoryBarrier-image-01767", VALIDATION_ERROR_0a000dce}, - {"VUID-VkImageMemoryBarrier-image-01768", VALIDATION_ERROR_0a000dd0}, - {"VUID-VkImageMemoryBarrier-image-01932", VALIDATION_ERROR_0a000f18}, - {"VUID-VkImageMemoryBarrier-dstAccessMask-parameter", VALIDATION_ERROR_0a006801}, - {"VUID-VkImageMemoryBarrier-image-parameter", VALIDATION_ERROR_0a00a001}, - {"VUID-VkImageMemoryBarrier-newLayout-parameter", VALIDATION_ERROR_0a00d401}, - {"VUID-VkImageMemoryBarrier-oldLayout-parameter", VALIDATION_ERROR_0a00dc01}, - {"VUID-VkImageMemoryBarrier-pNext-pNext", VALIDATION_ERROR_0a01c40d}, - {"VUID-VkImageMemoryBarrier-sType-sType", VALIDATION_ERROR_0a02b00b}, - {"VUID-VkImageMemoryBarrier-srcAccessMask-parameter", VALIDATION_ERROR_0a02c401}, - {"VUID-VkImageMemoryBarrier-subresourceRange-parameter", VALIDATION_ERROR_0a02ea01}, - {"VUID-VkImageResolve-aspectMask-00266", VALIDATION_ERROR_0a200214}, - {"VUID-VkImageResolve-layerCount-00267", VALIDATION_ERROR_0a200216}, - {"VUID-VkImageResolve-srcImage-00268", VALIDATION_ERROR_0a200218}, - {"VUID-VkImageResolve-srcOffset-00269", VALIDATION_ERROR_0a20021a}, - {"VUID-VkImageResolve-srcOffset-00270", VALIDATION_ERROR_0a20021c}, - {"VUID-VkImageResolve-srcImage-00271", VALIDATION_ERROR_0a20021e}, - {"VUID-VkImageResolve-srcOffset-00272", VALIDATION_ERROR_0a200220}, - {"VUID-VkImageResolve-srcImage-00273", VALIDATION_ERROR_0a200222}, - {"VUID-VkImageResolve-dstOffset-00274", VALIDATION_ERROR_0a200224}, - {"VUID-VkImageResolve-dstOffset-00275", VALIDATION_ERROR_0a200226}, - {"VUID-VkImageResolve-dstImage-00276", VALIDATION_ERROR_0a200228}, - {"VUID-VkImageResolve-dstOffset-00277", VALIDATION_ERROR_0a20022a}, - {"VUID-VkImageResolve-dstImage-00278", VALIDATION_ERROR_0a20022c}, - {"VUID-VkImageResolve-dstSubresource-parameter", VALIDATION_ERROR_0a207a01}, - {"VUID-VkImageResolve-srcSubresource-parameter", VALIDATION_ERROR_0a22d601}, - {"VUID-VkImageSubresource-aspectMask-parameter", VALIDATION_ERROR_0a400c01}, - {"VUID-VkImageSubresource-aspectMask-requiredbitmask", VALIDATION_ERROR_0a400c03}, - {"VUID-VkImageSubresourceLayers-aspectMask-00167", VALIDATION_ERROR_0a60014e}, - {"VUID-VkImageSubresourceLayers-aspectMask-00168", VALIDATION_ERROR_0a600150}, - {"VUID-VkImageSubresourceLayers-aspectMask-parameter", VALIDATION_ERROR_0a600c01}, - {"VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask", VALIDATION_ERROR_0a600c03}, - {"VUID-VkImageSubresourceLayers-layerCount-01700", VALIDATION_ERROR_0a600d48}, - {"VUID-VkImageSubresourceRange-aspectMask-parameter", VALIDATION_ERROR_0a800c01}, - {"VUID-VkImageSubresourceRange-aspectMask-requiredbitmask", VALIDATION_ERROR_0a800c03}, - {"VUID-VkImageSubresourceRange-aspectMask-01670", VALIDATION_ERROR_0a800d0c}, - {"VUID-VkImageSubresourceRange-levelCount-01720", VALIDATION_ERROR_0a800d70}, - {"VUID-VkImageSubresourceRange-layerCount-01721", VALIDATION_ERROR_0a800d72}, - {"VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995", VALIDATION_ERROR_0aa007c6}, - {"VUID-VkImageSwapchainCreateInfoKHR-sType-sType", VALIDATION_ERROR_0aa2b00b}, - {"VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter", VALIDATION_ERROR_0aa2f001}, - {"VUID-VkImageViewCreateInfo-image-01003", VALIDATION_ERROR_0ac007d6}, - {"VUID-VkImageViewCreateInfo-viewType-01004", VALIDATION_ERROR_0ac007d8}, - {"VUID-VkImageViewCreateInfo-image-01005", VALIDATION_ERROR_0ac007da}, - {"VUID-VkImageViewCreateInfo-image-01006", VALIDATION_ERROR_0ac007dc}, - {"VUID-VkImageViewCreateInfo-image-01007", VALIDATION_ERROR_0ac007de}, - {"VUID-VkImageViewCreateInfo-image-01008", VALIDATION_ERROR_0ac007e0}, - {"VUID-VkImageViewCreateInfo-image-01009", VALIDATION_ERROR_0ac007e2}, - {"VUID-VkImageViewCreateInfo-image-01010", VALIDATION_ERROR_0ac007e4}, - {"VUID-VkImageViewCreateInfo-image-01011", VALIDATION_ERROR_0ac007e6}, - {"VUID-VkImageViewCreateInfo-image-01012", VALIDATION_ERROR_0ac007e8}, - {"VUID-VkImageViewCreateInfo-image-01013", VALIDATION_ERROR_0ac007ea}, - {"VUID-VkImageViewCreateInfo-image-01014", VALIDATION_ERROR_0ac007ec}, - {"VUID-VkImageViewCreateInfo-image-01015", VALIDATION_ERROR_0ac007ee}, - {"VUID-VkImageViewCreateInfo-image-01016", VALIDATION_ERROR_0ac007f0}, - {"VUID-VkImageViewCreateInfo-image-01018", VALIDATION_ERROR_0ac007f4}, - {"VUID-VkImageViewCreateInfo-image-01019", VALIDATION_ERROR_0ac007f6}, - {"VUID-VkImageViewCreateInfo-image-01020", VALIDATION_ERROR_0ac007f8}, - {"VUID-VkImageViewCreateInfo-subResourceRange-01021", VALIDATION_ERROR_0ac007fa}, - {"VUID-VkImageViewCreateInfo-subresourceRange-01478", VALIDATION_ERROR_0ac00b8c}, - {"VUID-VkImageViewCreateInfo-subresourceRange-01480", VALIDATION_ERROR_0ac00b90}, - {"VUID-VkImageViewCreateInfo-image-01482", VALIDATION_ERROR_0ac00b94}, - {"VUID-VkImageViewCreateInfo-subresourceRange-01483", VALIDATION_ERROR_0ac00b96}, - {"VUID-VkImageViewCreateInfo-image-01484", VALIDATION_ERROR_0ac00b98}, - {"VUID-VkImageViewCreateInfo-subresourceRange-01485", VALIDATION_ERROR_0ac00b9a}, - {"VUID-VkImageViewCreateInfo-image-01583", VALIDATION_ERROR_0ac00c5e}, - {"VUID-VkImageViewCreateInfo-image-01584", VALIDATION_ERROR_0ac00c60}, - {"VUID-VkImageViewCreateInfo-pNext-01585", VALIDATION_ERROR_0ac00c62}, - {"VUID-VkImageViewCreateInfo-image-01586", VALIDATION_ERROR_0ac00c64}, - {"VUID-VkImageViewCreateInfo-subresourceRange-01718", VALIDATION_ERROR_0ac00d6c}, - {"VUID-VkImageViewCreateInfo-subresourceRange-01719", VALIDATION_ERROR_0ac00d6e}, - {"VUID-VkImageViewCreateInfo-image-01759", VALIDATION_ERROR_0ac00dbe}, - {"VUID-VkImageViewCreateInfo-image-01760", VALIDATION_ERROR_0ac00dc0}, - {"VUID-VkImageViewCreateInfo-image-01761", VALIDATION_ERROR_0ac00dc2}, - {"VUID-VkImageViewCreateInfo-image-01762", VALIDATION_ERROR_0ac00dc4}, - {"VUID-VkImageViewCreateInfo-image-01896", VALIDATION_ERROR_0ac00ed0}, - {"VUID-VkImageViewCreateInfo-components-parameter", VALIDATION_ERROR_0ac02c01}, - {"VUID-VkImageViewCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0ac09005}, - {"VUID-VkImageViewCreateInfo-format-parameter", VALIDATION_ERROR_0ac09201}, - {"VUID-VkImageViewCreateInfo-image-parameter", VALIDATION_ERROR_0ac0a001}, - {"VUID-VkImageViewCreateInfo-pNext-pNext", VALIDATION_ERROR_0ac1c40d}, - {"VUID-VkImageViewCreateInfo-sType-sType", VALIDATION_ERROR_0ac2b00b}, - {"VUID-VkImageViewCreateInfo-sType-unique", VALIDATION_ERROR_0ac2b00f}, - {"VUID-VkImageViewCreateInfo-subresourceRange-parameter", VALIDATION_ERROR_0ac2ea01}, - {"VUID-VkImageViewCreateInfo-viewType-parameter", VALIDATION_ERROR_0ac30801}, - {"VUID-VkImportMemoryFdInfoKHR-handleType-00667", VALIDATION_ERROR_0ae00536}, - {"VUID-VkImportMemoryFdInfoKHR-fd-00668", VALIDATION_ERROR_0ae00538}, - {"VUID-VkImportMemoryFdInfoKHR-handleType-00669", VALIDATION_ERROR_0ae0053a}, - {"VUID-VkImportMemoryFdInfoKHR-handleType-00670", VALIDATION_ERROR_0ae0053c}, - {"VUID-VkImportMemoryFdInfoKHR-fd-01520", VALIDATION_ERROR_0ae00be0}, - {"VUID-VkImportMemoryFdInfoKHR-fd-01746", VALIDATION_ERROR_0ae00da4}, - {"VUID-VkImportMemoryFdInfoKHR-handleType-parameter", VALIDATION_ERROR_0ae09c01}, - {"VUID-VkImportMemoryFdInfoKHR-sType-sType", VALIDATION_ERROR_0ae2b00b}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658", VALIDATION_ERROR_0b000524}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659", VALIDATION_ERROR_0b000526}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660", VALIDATION_ERROR_0b000528}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661", VALIDATION_ERROR_0b00052a}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439", VALIDATION_ERROR_0b000b3e}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440", VALIDATION_ERROR_0b000b40}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441", VALIDATION_ERROR_0b000b42}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518", VALIDATION_ERROR_0b000bdc}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-name-01519", VALIDATION_ERROR_0b000bde}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter", VALIDATION_ERROR_0b009c01}, - {"VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_0b02b00b}, - {"VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327", VALIDATION_ERROR_0b200a5e}, - {"VUID-VkImportMemoryWin32HandleInfoNV-handle-01328", VALIDATION_ERROR_0b200a60}, - {"VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter", VALIDATION_ERROR_0b209c01}, - {"VUID-VkImportMemoryWin32HandleInfoNV-sType-sType", VALIDATION_ERROR_0b22b00b}, - {"VUID-VkImportSemaphoreFdInfoKHR-handleType-01143", VALIDATION_ERROR_0b4008ee}, - {"VUID-VkImportSemaphoreFdInfoKHR-fd-01544", VALIDATION_ERROR_0b400c10}, - {"VUID-VkImportSemaphoreFdInfoKHR-flags-parameter", VALIDATION_ERROR_0b409001}, - {"VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter", VALIDATION_ERROR_0b409c01}, - {"VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext", VALIDATION_ERROR_0b41c40d}, - {"VUID-VkImportSemaphoreFdInfoKHR-sType-sType", VALIDATION_ERROR_0b42b00b}, - {"VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter", VALIDATION_ERROR_0b42b801}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140", VALIDATION_ERROR_0b6008e8}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466", VALIDATION_ERROR_0b600b74}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467", VALIDATION_ERROR_0b600b76}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468", VALIDATION_ERROR_0b600b78}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469", VALIDATION_ERROR_0b600b7a}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542", VALIDATION_ERROR_0b600c0c}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543", VALIDATION_ERROR_0b600c0e}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter", VALIDATION_ERROR_0b609001}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter", VALIDATION_ERROR_0b609c01}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext", VALIDATION_ERROR_0b61c40d}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_0b62b00b}, - {"VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter", VALIDATION_ERROR_0b62b801}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347", VALIDATION_ERROR_0b800a86}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348", VALIDATION_ERROR_0b800a88}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349", VALIDATION_ERROR_0b800a8a}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01350", VALIDATION_ERROR_0b800a8c}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01351", VALIDATION_ERROR_0b800a8e}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter", VALIDATION_ERROR_0b809001}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask", VALIDATION_ERROR_0b809003}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-pNext-pNext", VALIDATION_ERROR_0b81c40d}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter", VALIDATION_ERROR_0b826001}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter", VALIDATION_ERROR_0b827e01}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-sType-sType", VALIDATION_ERROR_0b82b00b}, - {"VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength", VALIDATION_ERROR_0b82fc1b}, - {"VUID-VkIndirectCommandsLayoutTokenNVX-bindingUnit-01342", VALIDATION_ERROR_0ba00a7c}, - {"VUID-VkIndirectCommandsLayoutTokenNVX-dynamicCount-01343", VALIDATION_ERROR_0ba00a7e}, - {"VUID-VkIndirectCommandsLayoutTokenNVX-divisor-01344", VALIDATION_ERROR_0ba00a80}, - {"VUID-VkIndirectCommandsLayoutTokenNVX-tokenType-parameter", VALIDATION_ERROR_0ba2fe01}, - {"VUID-VkIndirectCommandsTokenNVX-buffer-01345", VALIDATION_ERROR_0bc00a82}, - {"VUID-VkIndirectCommandsTokenNVX-offset-01346", VALIDATION_ERROR_0bc00a84}, - {"VUID-VkIndirectCommandsTokenNVX-buffer-parameter", VALIDATION_ERROR_0bc01a01}, - {"VUID-VkIndirectCommandsTokenNVX-tokenType-parameter", VALIDATION_ERROR_0bc2fe01}, - {"VUID-VkInstanceCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0be09005}, - {"VUID-VkInstanceCreateInfo-pApplicationInfo-parameter", VALIDATION_ERROR_0be0ee01}, - {"VUID-VkInstanceCreateInfo-pNext-pNext", VALIDATION_ERROR_0be1c40d}, - {"VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter", VALIDATION_ERROR_0be28e01}, - {"VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter", VALIDATION_ERROR_0be29001}, - {"VUID-VkInstanceCreateInfo-sType-sType", VALIDATION_ERROR_0be2b00b}, - {"VUID-VkInstanceCreateInfo-sType-unique", VALIDATION_ERROR_0be2b00f}, - {"VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317", VALIDATION_ERROR_0c000a4a}, - {"VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask", VALIDATION_ERROR_0c009005}, - {"VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext", VALIDATION_ERROR_0c01c40d}, - {"VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType", VALIDATION_ERROR_0c02b00b}, - {"VUID-VkMappedMemoryRange-memory-00684", VALIDATION_ERROR_0c200558}, - {"VUID-VkMappedMemoryRange-size-00685", VALIDATION_ERROR_0c20055a}, - {"VUID-VkMappedMemoryRange-size-00686", VALIDATION_ERROR_0c20055c}, - {"VUID-VkMappedMemoryRange-offset-00687", VALIDATION_ERROR_0c20055e}, - {"VUID-VkMappedMemoryRange-size-01389", VALIDATION_ERROR_0c200ada}, - {"VUID-VkMappedMemoryRange-size-01390", VALIDATION_ERROR_0c200adc}, - {"VUID-VkMappedMemoryRange-memory-parameter", VALIDATION_ERROR_0c20c601}, - {"VUID-VkMappedMemoryRange-pNext-pNext", VALIDATION_ERROR_0c21c40d}, - {"VUID-VkMappedMemoryRange-sType-sType", VALIDATION_ERROR_0c22b00b}, - {"VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675", VALIDATION_ERROR_0c400546}, - {"VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676", VALIDATION_ERROR_0c400548}, - {"VUID-VkMemoryAllocateFlagsInfo-flags-parameter", VALIDATION_ERROR_0c409001}, - {"VUID-VkMemoryAllocateFlagsInfo-sType-sType", VALIDATION_ERROR_0c42b00b}, - {"VUID-VkMemoryAllocateInfo-allocationSize-00638", VALIDATION_ERROR_0c6004fc}, - {"VUID-VkMemoryAllocateInfo-pNext-00639", VALIDATION_ERROR_0c6004fe}, - {"VUID-VkMemoryAllocateInfo-pNext-00640", VALIDATION_ERROR_0c600500}, - {"VUID-VkMemoryAllocateInfo-pNext-00641", VALIDATION_ERROR_0c600502}, - {"VUID-VkMemoryAllocateInfo-None-00643", VALIDATION_ERROR_0c600506}, - {"VUID-VkMemoryAllocateInfo-None-00644", VALIDATION_ERROR_0c600508}, - {"VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645", VALIDATION_ERROR_0c60050a}, - {"VUID-VkMemoryAllocateInfo-allocationSize-00646", VALIDATION_ERROR_0c60050c}, - {"VUID-VkMemoryAllocateInfo-allocationSize-00647", VALIDATION_ERROR_0c60050e}, - {"VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648", VALIDATION_ERROR_0c600510}, - {"VUID-VkMemoryAllocateInfo-allocationSize-01742", VALIDATION_ERROR_0c600d9c}, - {"VUID-VkMemoryAllocateInfo-allocationSize-01743", VALIDATION_ERROR_0c600d9e}, - {"VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744", VALIDATION_ERROR_0c600da0}, - {"VUID-VkMemoryAllocateInfo-allocationSize-01745", VALIDATION_ERROR_0c600da2}, - {"VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872", VALIDATION_ERROR_0c600ea0}, - {"VUID-VkMemoryAllocateInfo-None-01873", VALIDATION_ERROR_0c600ea2}, - {"VUID-VkMemoryAllocateInfo-pNext-01874", VALIDATION_ERROR_0c600ea4}, - {"VUID-VkMemoryAllocateInfo-pNext-01875", VALIDATION_ERROR_0c600ea6}, - {"VUID-VkMemoryAllocateInfo-pNext-pNext", VALIDATION_ERROR_0c61c40d}, - {"VUID-VkMemoryAllocateInfo-sType-sType", VALIDATION_ERROR_0c62b00b}, - {"VUID-VkMemoryAllocateInfo-sType-unique", VALIDATION_ERROR_0c62b00f}, - {"VUID-VkMemoryBarrier-dstAccessMask-parameter", VALIDATION_ERROR_0c806801}, - {"VUID-VkMemoryBarrier-pNext-pNext", VALIDATION_ERROR_0c81c40d}, - {"VUID-VkMemoryBarrier-sType-sType", VALIDATION_ERROR_0c82b00b}, - {"VUID-VkMemoryBarrier-srcAccessMask-parameter", VALIDATION_ERROR_0c82c401}, - {"VUID-VkMirSurfaceCreateInfoKHR-connection-01263", VALIDATION_ERROR_0ca009de}, - {"VUID-VkMirSurfaceCreateInfoKHR-surface-01264", VALIDATION_ERROR_0ca009e0}, - {"VUID-VkMirSurfaceCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_0ca09005}, - {"VUID-VkMirSurfaceCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_0ca1c40d}, - {"VUID-VkMirSurfaceCreateInfoKHR-sType-sType", VALIDATION_ERROR_0ca2b00b}, - {"VUID-VkObjectTableCreateInfoNVX-computeBindingPointSupport-01355", VALIDATION_ERROR_0cc00a96}, - {"VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-01356", VALIDATION_ERROR_0cc00a98}, - {"VUID-VkObjectTableCreateInfoNVX-maxUniformBuffersPerDescriptor-01357", VALIDATION_ERROR_0cc00a9a}, - {"VUID-VkObjectTableCreateInfoNVX-maxStorageBuffersPerDescriptor-01358", VALIDATION_ERROR_0cc00a9c}, - {"VUID-VkObjectTableCreateInfoNVX-maxStorageImagesPerDescriptor-01359", VALIDATION_ERROR_0cc00a9e}, - {"VUID-VkObjectTableCreateInfoNVX-maxSampledImagesPerDescriptor-01360", VALIDATION_ERROR_0cc00aa0}, - {"VUID-VkObjectTableCreateInfoNVX-objectCount-arraylength", VALIDATION_ERROR_0cc0d61b}, - {"VUID-VkObjectTableCreateInfoNVX-pNext-pNext", VALIDATION_ERROR_0cc1c40d}, - {"VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-parameter", VALIDATION_ERROR_0cc1c601}, - {"VUID-VkObjectTableCreateInfoNVX-pObjectEntryTypes-parameter", VALIDATION_ERROR_0cc1c801}, - {"VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-parameter", VALIDATION_ERROR_0cc1ca01}, - {"VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-requiredbitmask", VALIDATION_ERROR_0cc1ca03}, - {"VUID-VkObjectTableCreateInfoNVX-sType-sType", VALIDATION_ERROR_0cc2b00b}, - {"VUID-VkObjectTableDescriptorSetEntryNVX-commonparent", VALIDATION_ERROR_0ce00009}, - {"VUID-VkObjectTableDescriptorSetEntryNVX-type-01369", VALIDATION_ERROR_0ce00ab2}, - {"VUID-VkObjectTableDescriptorSetEntryNVX-descriptorSet-parameter", VALIDATION_ERROR_0ce04801}, - {"VUID-VkObjectTableDescriptorSetEntryNVX-flags-parameter", VALIDATION_ERROR_0ce09001}, - {"VUID-VkObjectTableDescriptorSetEntryNVX-flags-requiredbitmask", VALIDATION_ERROR_0ce09003}, - {"VUID-VkObjectTableDescriptorSetEntryNVX-pipelineLayout-parameter", VALIDATION_ERROR_0ce28201}, - {"VUID-VkObjectTableDescriptorSetEntryNVX-type-parameter", VALIDATION_ERROR_0ce30401}, - {"VUID-VkObjectTableEntryNVX-computeBindingPointSupport-01367", VALIDATION_ERROR_0d000aae}, - {"VUID-VkObjectTableEntryNVX-flags-parameter", VALIDATION_ERROR_0d009001}, - {"VUID-VkObjectTableEntryNVX-flags-requiredbitmask", VALIDATION_ERROR_0d009003}, - {"VUID-VkObjectTableEntryNVX-type-parameter", VALIDATION_ERROR_0d030401}, - {"VUID-VkObjectTableIndexBufferEntryNVX-type-01371", VALIDATION_ERROR_0d200ab6}, - {"VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter", VALIDATION_ERROR_0d201a01}, - {"VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter", VALIDATION_ERROR_0d209001}, - {"VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask", VALIDATION_ERROR_0d209003}, - {"VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter", VALIDATION_ERROR_0d20b201}, - {"VUID-VkObjectTableIndexBufferEntryNVX-type-parameter", VALIDATION_ERROR_0d230401}, - {"VUID-VkObjectTablePipelineEntryNVX-type-01368", VALIDATION_ERROR_0d400ab0}, - {"VUID-VkObjectTablePipelineEntryNVX-flags-parameter", VALIDATION_ERROR_0d409001}, - {"VUID-VkObjectTablePipelineEntryNVX-flags-requiredbitmask", VALIDATION_ERROR_0d409003}, - {"VUID-VkObjectTablePipelineEntryNVX-pipeline-parameter", VALIDATION_ERROR_0d427c01}, - {"VUID-VkObjectTablePipelineEntryNVX-type-parameter", VALIDATION_ERROR_0d430401}, - {"VUID-VkObjectTablePushConstantEntryNVX-type-01372", VALIDATION_ERROR_0d600ab8}, - {"VUID-VkObjectTablePushConstantEntryNVX-flags-parameter", VALIDATION_ERROR_0d609001}, - {"VUID-VkObjectTablePushConstantEntryNVX-flags-requiredbitmask", VALIDATION_ERROR_0d609003}, - {"VUID-VkObjectTablePushConstantEntryNVX-pipelineLayout-parameter", VALIDATION_ERROR_0d628201}, - {"VUID-VkObjectTablePushConstantEntryNVX-stageFlags-parameter", VALIDATION_ERROR_0d62dc01}, - {"VUID-VkObjectTablePushConstantEntryNVX-stageFlags-requiredbitmask", VALIDATION_ERROR_0d62dc03}, - {"VUID-VkObjectTablePushConstantEntryNVX-type-parameter", VALIDATION_ERROR_0d630401}, - {"VUID-VkObjectTableVertexBufferEntryNVX-type-01370", VALIDATION_ERROR_0d800ab4}, - {"VUID-VkObjectTableVertexBufferEntryNVX-buffer-parameter", VALIDATION_ERROR_0d801a01}, - {"VUID-VkObjectTableVertexBufferEntryNVX-flags-parameter", VALIDATION_ERROR_0d809001}, - {"VUID-VkObjectTableVertexBufferEntryNVX-flags-requiredbitmask", VALIDATION_ERROR_0d809003}, - {"VUID-VkObjectTableVertexBufferEntryNVX-type-parameter", VALIDATION_ERROR_0d830401}, - {"VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType", VALIDATION_ERROR_0da2b00b}, - {"VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter", VALIDATION_ERROR_0dc09001}, - {"VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter", VALIDATION_ERROR_0dc09c01}, - {"VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext", VALIDATION_ERROR_0dc1c40d}, - {"VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType", VALIDATION_ERROR_0dc2b00b}, - {"VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter", VALIDATION_ERROR_0dc30601}, - {"VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask", VALIDATION_ERROR_0dc30603}, - {"VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter", VALIDATION_ERROR_0de09c01}, - {"VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType", VALIDATION_ERROR_0de2b00b}, - {"VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter", VALIDATION_ERROR_0e009c01}, - {"VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext", VALIDATION_ERROR_0e01c40d}, - {"VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType", VALIDATION_ERROR_0e02b00b}, - {"VUID-VkPhysicalDeviceFeatures2-sType-sType", VALIDATION_ERROR_0e42b00b}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter", VALIDATION_ERROR_0e609001}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter", VALIDATION_ERROR_0e609201}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext", VALIDATION_ERROR_0e61c40d}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType", VALIDATION_ERROR_0e62b00b}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter", VALIDATION_ERROR_0e62fa01}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter", VALIDATION_ERROR_0e630401}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter", VALIDATION_ERROR_0e630601}, - {"VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask", VALIDATION_ERROR_0e630603}, - {"VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580", VALIDATION_ERROR_0e800488}, - {"VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581", VALIDATION_ERROR_0e80048a}, - {"VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType", VALIDATION_ERROR_0e82b00b}, - {"VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType", VALIDATION_ERROR_0ea2b00b}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095", VALIDATION_ERROR_0ec0088e}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter", VALIDATION_ERROR_0ec09201}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-pNext-pNext", VALIDATION_ERROR_0ec1c40d}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType", VALIDATION_ERROR_0ec2b00b}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter", VALIDATION_ERROR_0ec2b401}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter", VALIDATION_ERROR_0ec2fa01}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter", VALIDATION_ERROR_0ec30401}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter", VALIDATION_ERROR_0ec30601}, - {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask", VALIDATION_ERROR_0ec30603}, - {"VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext", VALIDATION_ERROR_0ee1c40d}, - {"VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType", VALIDATION_ERROR_0ee2b00b}, - {"VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", VALIDATION_ERROR_0ee2ec01}, - {"VUID-VkPipelineCacheCreateInfo-initialDataSize-00768", VALIDATION_ERROR_0f000600}, - {"VUID-VkPipelineCacheCreateInfo-initialDataSize-00769", VALIDATION_ERROR_0f000602}, - {"VUID-VkPipelineCacheCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0f009005}, - {"VUID-VkPipelineCacheCreateInfo-pInitialData-parameter", VALIDATION_ERROR_0f019601}, - {"VUID-VkPipelineCacheCreateInfo-pNext-pNext", VALIDATION_ERROR_0f01c40d}, - {"VUID-VkPipelineCacheCreateInfo-sType-sType", VALIDATION_ERROR_0f02b00b}, - {"VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608", VALIDATION_ERROR_0f2004c0}, - {"VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609", VALIDATION_ERROR_0f2004c2}, - {"VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610", VALIDATION_ERROR_0f2004c4}, - {"VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611", VALIDATION_ERROR_0f2004c6}, - {"VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter", VALIDATION_ERROR_0f200801}, - {"VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406", VALIDATION_ERROR_0f200afc}, - {"VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407", VALIDATION_ERROR_0f200afe}, - {"VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408", VALIDATION_ERROR_0f200b00}, - {"VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409", VALIDATION_ERROR_0f200b02}, - {"VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410", VALIDATION_ERROR_0f200b04}, - {"VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter", VALIDATION_ERROR_0f202001}, - {"VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter", VALIDATION_ERROR_0f202201}, - {"VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter", VALIDATION_ERROR_0f206a01}, - {"VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter", VALIDATION_ERROR_0f207001}, - {"VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter", VALIDATION_ERROR_0f22c601}, - {"VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter", VALIDATION_ERROR_0f22cc01}, - {"VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605", VALIDATION_ERROR_0f4004ba}, - {"VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606", VALIDATION_ERROR_0f4004bc}, - {"VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607", VALIDATION_ERROR_0f4004be}, - {"VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0f409005}, - {"VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter", VALIDATION_ERROR_0f40f201}, - {"VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext", VALIDATION_ERROR_0f41c40d}, - {"VUID-VkPipelineColorBlendStateCreateInfo-sType-sType", VALIDATION_ERROR_0f42b00b}, - {"VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598", VALIDATION_ERROR_0f6004ac}, - {"VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter", VALIDATION_ERROR_0f601201}, - {"VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter", VALIDATION_ERROR_0f604001}, - {"VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0f609005}, - {"VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter", VALIDATION_ERROR_0f609601}, - {"VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext", VALIDATION_ERROR_0f61c40d}, - {"VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType", VALIDATION_ERROR_0f62b00b}, - {"VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582", VALIDATION_ERROR_0f80048c}, - {"VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter", VALIDATION_ERROR_0f805e01}, - {"VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask", VALIDATION_ERROR_0f809005}, - {"VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType", VALIDATION_ERROR_0f82b00b}, - {"VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442", VALIDATION_ERROR_0fa00b44}, - {"VUID-VkPipelineDynamicStateCreateInfo-dynamicStateCount-arraylength", VALIDATION_ERROR_0fa07c1b}, - {"VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0fa09005}, - {"VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter", VALIDATION_ERROR_0fa15801}, - {"VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext", VALIDATION_ERROR_0fa1c40d}, - {"VUID-VkPipelineDynamicStateCreateInfo-sType-sType", VALIDATION_ERROR_0fa2b00b}, - {"VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428", VALIDATION_ERROR_0fc00358}, - {"VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429", VALIDATION_ERROR_0fc0035a}, - {"VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430", VALIDATION_ERROR_0fc0035c}, - {"VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0fc09005}, - {"VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext", VALIDATION_ERROR_0fc1c40d}, - {"VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType", VALIDATION_ERROR_0fc2b00b}, - {"VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter", VALIDATION_ERROR_0fc30001}, - {"VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286", VALIDATION_ERROR_0fe0023c}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00287", VALIDATION_ERROR_0fe0023e}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00288", VALIDATION_ERROR_0fe00240}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00289", VALIDATION_ERROR_0fe00242}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00290", VALIDATION_ERROR_0fe00244}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00291", VALIDATION_ERROR_0fe00246}, - {"VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292", VALIDATION_ERROR_0fe00248}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293", VALIDATION_ERROR_0fe0024a}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01676", VALIDATION_ERROR_0fe00d18}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01677", VALIDATION_ERROR_0fe00d1a}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01678", VALIDATION_ERROR_0fe00d1c}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01679", VALIDATION_ERROR_0fe00d1e}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01680", VALIDATION_ERROR_0fe00d20}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01681", VALIDATION_ERROR_0fe00d22}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01682", VALIDATION_ERROR_0fe00d24}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01683", VALIDATION_ERROR_0fe00d26}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01684", VALIDATION_ERROR_0fe00d28}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03016", VALIDATION_ERROR_0fe01790}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03017", VALIDATION_ERROR_0fe01792}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03018", VALIDATION_ERROR_0fe01794}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03019", VALIDATION_ERROR_0fe01796}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03020", VALIDATION_ERROR_0fe01798}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03021", VALIDATION_ERROR_0fe0179a}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03022", VALIDATION_ERROR_0fe0179c}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03023", VALIDATION_ERROR_0fe0179e}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03024", VALIDATION_ERROR_0fe017a0}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03025", VALIDATION_ERROR_0fe017a2}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03026", VALIDATION_ERROR_0fe017a4}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03027", VALIDATION_ERROR_0fe017a6}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03028", VALIDATION_ERROR_0fe017a8}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03029", VALIDATION_ERROR_0fe017aa}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03030", VALIDATION_ERROR_0fe017ac}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03031", VALIDATION_ERROR_0fe017ae}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03032", VALIDATION_ERROR_0fe017b0}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03033", VALIDATION_ERROR_0fe017b2}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03034", VALIDATION_ERROR_0fe017b4}, - {"VUID-VkPipelineLayoutCreateInfo-descriptorType-03035", VALIDATION_ERROR_0fe017b6}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036", VALIDATION_ERROR_0fe017b8}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037", VALIDATION_ERROR_0fe017ba}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038", VALIDATION_ERROR_0fe017bc}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039", VALIDATION_ERROR_0fe017be}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040", VALIDATION_ERROR_0fe017c0}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041", VALIDATION_ERROR_0fe017c2}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042", VALIDATION_ERROR_0fe017c4}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043", VALIDATION_ERROR_0fe017c6}, - {"VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask", VALIDATION_ERROR_0fe09005}, - {"VUID-VkPipelineLayoutCreateInfo-pNext-pNext", VALIDATION_ERROR_0fe1c40d}, - {"VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter", VALIDATION_ERROR_0fe1f801}, - {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", VALIDATION_ERROR_0fe22c01}, - {"VUID-VkPipelineLayoutCreateInfo-sType-sType", VALIDATION_ERROR_0fe2b00b}, - {"VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784", VALIDATION_ERROR_10000620}, - {"VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785", VALIDATION_ERROR_10000622}, - {"VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786", VALIDATION_ERROR_10000624}, - {"VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415", VALIDATION_ERROR_10000b0e}, - {"VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_10009005}, - {"VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext", VALIDATION_ERROR_1001c40d}, - {"VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter", VALIDATION_ERROR_10022201}, - {"VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter", VALIDATION_ERROR_1002a801}, - {"VUID-VkPipelineMultisampleStateCreateInfo-sType-sType", VALIDATION_ERROR_1002b00b}, - {"VUID-VkPipelineMultisampleStateCreateInfo-sType-unique", VALIDATION_ERROR_1002b00f}, - {"VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782", VALIDATION_ERROR_1020061c}, - {"VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413", VALIDATION_ERROR_10200b0a}, - {"VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414", VALIDATION_ERROR_10200b0c}, - {"VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", VALIDATION_ERROR_10200bc6}, - {"VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter", VALIDATION_ERROR_10203a01}, - {"VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_10209005}, - {"VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter", VALIDATION_ERROR_10209801}, - {"VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext", VALIDATION_ERROR_1021c40d}, - {"VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter", VALIDATION_ERROR_10228601}, - {"VUID-VkPipelineRasterizationStateCreateInfo-sType-sType", VALIDATION_ERROR_1022b00b}, - {"VUID-VkPipelineRasterizationStateCreateInfo-sType-unique", VALIDATION_ERROR_1022b00f}, - {"VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter", VALIDATION_ERROR_1042a601}, - {"VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType", VALIDATION_ERROR_1042b00b}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00704", VALIDATION_ERROR_10600580}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00705", VALIDATION_ERROR_10600582}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00706", VALIDATION_ERROR_10600584}, - {"VUID-VkPipelineShaderStageCreateInfo-pName-00707", VALIDATION_ERROR_10600586}, - {"VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708", VALIDATION_ERROR_10600588}, - {"VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709", VALIDATION_ERROR_1060058a}, - {"VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710", VALIDATION_ERROR_1060058c}, - {"VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711", VALIDATION_ERROR_1060058e}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00712", VALIDATION_ERROR_10600590}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00713", VALIDATION_ERROR_10600592}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00714", VALIDATION_ERROR_10600594}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00715", VALIDATION_ERROR_10600596}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00716", VALIDATION_ERROR_10600598}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00717", VALIDATION_ERROR_1060059a}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00718", VALIDATION_ERROR_1060059c}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-00719", VALIDATION_ERROR_1060059e}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-01511", VALIDATION_ERROR_10600bce}, - {"VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask", VALIDATION_ERROR_10609005}, - {"VUID-VkPipelineShaderStageCreateInfo-module-parameter", VALIDATION_ERROR_1060d201}, - {"VUID-VkPipelineShaderStageCreateInfo-pName-parameter", VALIDATION_ERROR_1061c001}, - {"VUID-VkPipelineShaderStageCreateInfo-pNext-pNext", VALIDATION_ERROR_1061c40d}, - {"VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter", VALIDATION_ERROR_10623a01}, - {"VUID-VkPipelineShaderStageCreateInfo-sType-sType", VALIDATION_ERROR_1062b00b}, - {"VUID-VkPipelineShaderStageCreateInfo-stage-parameter", VALIDATION_ERROR_1062d801}, - {"VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214", VALIDATION_ERROR_1080097c}, - {"VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_10809005}, - {"VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext", VALIDATION_ERROR_1081c40d}, - {"VUID-VkPipelineTessellationStateCreateInfo-sType-sType", VALIDATION_ERROR_1082b00b}, - {"VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613", VALIDATION_ERROR_10a004ca}, - {"VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614", VALIDATION_ERROR_10a004cc}, - {"VUID-VkPipelineVertexInputStateCreateInfo-binding-00615", VALIDATION_ERROR_10a004ce}, - {"VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616", VALIDATION_ERROR_10a004d0}, - {"VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617", VALIDATION_ERROR_10a004d2}, - {"VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_10a09005}, - {"VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext", VALIDATION_ERROR_10a1c40d}, - {"VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter", VALIDATION_ERROR_10a26401}, - {"VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter", VALIDATION_ERROR_10a26601}, - {"VUID-VkPipelineVertexInputStateCreateInfo-sType-sType", VALIDATION_ERROR_10a2b00b}, - {"VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216", VALIDATION_ERROR_10c00980}, - {"VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217", VALIDATION_ERROR_10c00982}, - {"VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218", VALIDATION_ERROR_10c00984}, - {"VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219", VALIDATION_ERROR_10c00986}, - {"VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220", VALIDATION_ERROR_10c00988}, - {"VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726", VALIDATION_ERROR_10c00d7c}, - {"VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask", VALIDATION_ERROR_10c09005}, - {"VUID-VkPipelineViewportStateCreateInfo-pNext-pNext", VALIDATION_ERROR_10c1c40d}, - {"VUID-VkPipelineViewportStateCreateInfo-sType-sType", VALIDATION_ERROR_10c2b00b}, - {"VUID-VkPipelineViewportStateCreateInfo-sType-unique", VALIDATION_ERROR_10c2b00f}, - {"VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength", VALIDATION_ERROR_10c2b61b}, - {"VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength", VALIDATION_ERROR_10c30a1b}, - {"VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215", VALIDATION_ERROR_10e0097e}, - {"VUID-VkPipelineViewportSwizzleStateCreateInfoNV-flags-zerobitmask", VALIDATION_ERROR_10e09005}, - {"VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType", VALIDATION_ERROR_10e2b00b}, - {"VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength", VALIDATION_ERROR_10e30a1b}, - {"VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType", VALIDATION_ERROR_1102b00b}, - {"VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength", VALIDATION_ERROR_11030a1b}, - {"VUID-VkPresentInfoKHR-commonparent", VALIDATION_ERROR_11200009}, - {"VUID-VkPresentInfoKHR-pImageIndices-01296", VALIDATION_ERROR_11200a20}, - {"VUID-VkPresentInfoKHR-pImageIndices-01430", VALIDATION_ERROR_11200b2c}, - {"VUID-VkPresentInfoKHR-pImageIndices-parameter", VALIDATION_ERROR_11218801}, - {"VUID-VkPresentInfoKHR-pNext-pNext", VALIDATION_ERROR_1121c40d}, - {"VUID-VkPresentInfoKHR-pResults-parameter", VALIDATION_ERROR_11221e01}, - {"VUID-VkPresentInfoKHR-pSwapchains-parameter", VALIDATION_ERROR_11225801}, - {"VUID-VkPresentInfoKHR-pWaitSemaphores-parameter", VALIDATION_ERROR_11227601}, - {"VUID-VkPresentInfoKHR-sType-sType", VALIDATION_ERROR_1122b00b}, - {"VUID-VkPresentInfoKHR-sType-unique", VALIDATION_ERROR_1122b00f}, - {"VUID-VkPresentInfoKHR-swapchainCount-arraylength", VALIDATION_ERROR_1122f21b}, - {"VUID-VkPresentRegionKHR-pRectangles-parameter", VALIDATION_ERROR_11420c01}, - {"VUID-VkPresentRegionsKHR-swapchainCount-01260", VALIDATION_ERROR_116009d8}, - {"VUID-VkPresentRegionsKHR-pRegions-parameter", VALIDATION_ERROR_11621001}, - {"VUID-VkPresentRegionsKHR-sType-sType", VALIDATION_ERROR_1162b00b}, - {"VUID-VkPresentRegionsKHR-swapchainCount-arraylength", VALIDATION_ERROR_1162f21b}, - {"VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247", VALIDATION_ERROR_118009be}, - {"VUID-VkPresentTimesInfoGOOGLE-pTimes-parameter", VALIDATION_ERROR_11825e01}, - {"VUID-VkPresentTimesInfoGOOGLE-sType-sType", VALIDATION_ERROR_1182b00b}, - {"VUID-VkPresentTimesInfoGOOGLE-swapchainCount-arraylength", VALIDATION_ERROR_1182f21b}, - {"VUID-VkPushConstantRange-offset-00294", VALIDATION_ERROR_11a0024c}, - {"VUID-VkPushConstantRange-offset-00295", VALIDATION_ERROR_11a0024e}, - {"VUID-VkPushConstantRange-size-00296", VALIDATION_ERROR_11a00250}, - {"VUID-VkPushConstantRange-size-00297", VALIDATION_ERROR_11a00252}, - {"VUID-VkPushConstantRange-size-00298", VALIDATION_ERROR_11a00254}, - {"VUID-VkPushConstantRange-stageFlags-parameter", VALIDATION_ERROR_11a2dc01}, - {"VUID-VkPushConstantRange-stageFlags-requiredbitmask", VALIDATION_ERROR_11a2dc03}, - {"VUID-VkQueryPoolCreateInfo-queryType-00791", VALIDATION_ERROR_11c0062e}, - {"VUID-VkQueryPoolCreateInfo-queryType-00792", VALIDATION_ERROR_11c00630}, - {"VUID-VkQueryPoolCreateInfo-flags-zerobitmask", VALIDATION_ERROR_11c09005}, - {"VUID-VkQueryPoolCreateInfo-pNext-pNext", VALIDATION_ERROR_11c1c40d}, - {"VUID-VkQueryPoolCreateInfo-queryType-parameter", VALIDATION_ERROR_11c29a01}, - {"VUID-VkQueryPoolCreateInfo-sType-sType", VALIDATION_ERROR_11c2b00b}, - {"VUID-VkRectLayerKHR-offset-01261", VALIDATION_ERROR_11e009da}, - {"VUID-VkRectLayerKHR-layer-01262", VALIDATION_ERROR_11e009dc}, - {"VUID-VkRenderPassBeginInfo-commonparent", VALIDATION_ERROR_12000009}, - {"VUID-VkRenderPassBeginInfo-clearValueCount-00902", VALIDATION_ERROR_1200070c}, - {"VUID-VkRenderPassBeginInfo-clearValueCount-00903", VALIDATION_ERROR_1200070e}, - {"VUID-VkRenderPassBeginInfo-renderPass-00904", VALIDATION_ERROR_12000710}, - {"VUID-VkRenderPassBeginInfo-framebuffer-parameter", VALIDATION_ERROR_12009401}, - {"VUID-VkRenderPassBeginInfo-pNext-pNext", VALIDATION_ERROR_1201c40d}, - {"VUID-VkRenderPassBeginInfo-renderPass-parameter", VALIDATION_ERROR_1202ae01}, - {"VUID-VkRenderPassBeginInfo-sType-sType", VALIDATION_ERROR_1202b00b}, - {"VUID-VkRenderPassBeginInfo-sType-unique", VALIDATION_ERROR_1202b00f}, - {"VUID-VkRenderPassCreateInfo-None-00832", VALIDATION_ERROR_12200680}, - {"VUID-VkRenderPassCreateInfo-attachment-00833", VALIDATION_ERROR_12200682}, - {"VUID-VkRenderPassCreateInfo-attachment-00834", VALIDATION_ERROR_12200684}, - {"VUID-VkRenderPassCreateInfo-pPreserveAttachments-00835", VALIDATION_ERROR_12200686}, - {"VUID-VkRenderPassCreateInfo-pAttachments-00836", VALIDATION_ERROR_12200688}, - {"VUID-VkRenderPassCreateInfo-pDependencies-00837", VALIDATION_ERROR_1220068a}, - {"VUID-VkRenderPassCreateInfo-pDependencies-00838", VALIDATION_ERROR_1220068c}, - {"VUID-VkRenderPassCreateInfo-pAttachments-01566", VALIDATION_ERROR_12200c3c}, - {"VUID-VkRenderPassCreateInfo-pAttachments-01567", VALIDATION_ERROR_12200c3e}, - {"VUID-VkRenderPassCreateInfo-pNext-01926", VALIDATION_ERROR_12200f0c}, - {"VUID-VkRenderPassCreateInfo-pNext-01927", VALIDATION_ERROR_12200f0e}, - {"VUID-VkRenderPassCreateInfo-pNext-01928", VALIDATION_ERROR_12200f10}, - {"VUID-VkRenderPassCreateInfo-pNext-01929", VALIDATION_ERROR_12200f12}, - {"VUID-VkRenderPassCreateInfo-pNext-01930", VALIDATION_ERROR_12200f14}, - {"VUID-VkRenderPassCreateInfo-flags-zerobitmask", VALIDATION_ERROR_12209005}, - {"VUID-VkRenderPassCreateInfo-pAttachments-parameter", VALIDATION_ERROR_1220f201}, - {"VUID-VkRenderPassCreateInfo-pDependencies-parameter", VALIDATION_ERROR_12212601}, - {"VUID-VkRenderPassCreateInfo-pNext-pNext", VALIDATION_ERROR_1221c40d}, - {"VUID-VkRenderPassCreateInfo-pSubpasses-parameter", VALIDATION_ERROR_12224201}, - {"VUID-VkRenderPassCreateInfo-sType-sType", VALIDATION_ERROR_1222b00b}, - {"VUID-VkRenderPassCreateInfo-sType-unique", VALIDATION_ERROR_1222b00f}, - {"VUID-VkRenderPassCreateInfo-subpassCount-arraylength", VALIDATION_ERROR_1222e61b}, - {"VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841", VALIDATION_ERROR_12400692}, - {"VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter", VALIDATION_ERROR_12411a01}, - {"VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter", VALIDATION_ERROR_12426c01}, - {"VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter", VALIDATION_ERROR_12426e01}, - {"VUID-VkRenderPassMultiviewCreateInfo-sType-sType", VALIDATION_ERROR_1242b00b}, - {"VUID-VkSamplerCreateInfo-addressModeU-parameter", VALIDATION_ERROR_12600201}, - {"VUID-VkSamplerCreateInfo-addressModeV-parameter", VALIDATION_ERROR_12600401}, - {"VUID-VkSamplerCreateInfo-addressModeW-parameter", VALIDATION_ERROR_12600601}, - {"VUID-VkSamplerCreateInfo-mipLodBias-01069", VALIDATION_ERROR_1260085a}, - {"VUID-VkSamplerCreateInfo-anisotropyEnable-01070", VALIDATION_ERROR_1260085c}, - {"VUID-VkSamplerCreateInfo-anisotropyEnable-01071", VALIDATION_ERROR_1260085e}, - {"VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072", VALIDATION_ERROR_12600860}, - {"VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073", VALIDATION_ERROR_12600862}, - {"VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074", VALIDATION_ERROR_12600864}, - {"VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075", VALIDATION_ERROR_12600866}, - {"VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076", VALIDATION_ERROR_12600868}, - {"VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077", VALIDATION_ERROR_1260086a}, - {"VUID-VkSamplerCreateInfo-addressModeU-01078", VALIDATION_ERROR_1260086c}, - {"VUID-VkSamplerCreateInfo-addressModeU-01079", VALIDATION_ERROR_1260086e}, - {"VUID-VkSamplerCreateInfo-compareEnable-01080", VALIDATION_ERROR_12600870}, - {"VUID-VkSamplerCreateInfo-magFilter-01081", VALIDATION_ERROR_12600872}, - {"VUID-VkSamplerCreateInfo-magFilter-01422", VALIDATION_ERROR_12600b1c}, - {"VUID-VkSamplerCreateInfo-compareEnable-01423", VALIDATION_ERROR_12600b1e}, - {"VUID-VkSamplerCreateInfo-minFilter-01645", VALIDATION_ERROR_12600cda}, - {"VUID-VkSamplerCreateInfo-addressModeU-01646", VALIDATION_ERROR_12600cdc}, - {"VUID-VkSamplerCreateInfo-None-01647", VALIDATION_ERROR_12600cde}, - {"VUID-VkSamplerCreateInfo-flags-zerobitmask", VALIDATION_ERROR_12609005}, - {"VUID-VkSamplerCreateInfo-magFilter-parameter", VALIDATION_ERROR_1260c401}, - {"VUID-VkSamplerCreateInfo-minFilter-parameter", VALIDATION_ERROR_1260ca01}, - {"VUID-VkSamplerCreateInfo-mipmapMode-parameter", VALIDATION_ERROR_1260cc01}, - {"VUID-VkSamplerCreateInfo-pNext-pNext", VALIDATION_ERROR_1261c40d}, - {"VUID-VkSamplerCreateInfo-sType-sType", VALIDATION_ERROR_1262b00b}, - {"VUID-VkSamplerCreateInfo-sType-unique", VALIDATION_ERROR_1262b00f}, - {"VUID-VkSemaphoreCreateInfo-flags-zerobitmask", VALIDATION_ERROR_12809005}, - {"VUID-VkSemaphoreCreateInfo-pNext-pNext", VALIDATION_ERROR_1281c40d}, - {"VUID-VkSemaphoreCreateInfo-sType-sType", VALIDATION_ERROR_1282b00b}, - {"VUID-VkSemaphoreCreateInfo-sType-unique", VALIDATION_ERROR_1282b00f}, - {"VUID-VkShaderModuleCreateInfo-codeSize-01085", VALIDATION_ERROR_12a0087a}, - {"VUID-VkShaderModuleCreateInfo-codeSize-01086", VALIDATION_ERROR_12a0087c}, - {"VUID-VkShaderModuleCreateInfo-pCode-01087", VALIDATION_ERROR_12a0087e}, - {"VUID-VkShaderModuleCreateInfo-pCode-01088", VALIDATION_ERROR_12a00880}, - {"VUID-VkShaderModuleCreateInfo-pCode-01089", VALIDATION_ERROR_12a00882}, - {"VUID-VkShaderModuleCreateInfo-pCode-01090", VALIDATION_ERROR_12a00884}, - {"VUID-VkShaderModuleCreateInfo-pCode-01091", VALIDATION_ERROR_12a00886}, - {"VUID-VkShaderModuleCreateInfo-pCode-01376", VALIDATION_ERROR_12a00ac0}, - {"VUID-VkShaderModuleCreateInfo-pCode-01377", VALIDATION_ERROR_12a00ac2}, - {"VUID-VkShaderModuleCreateInfo-pCode-01378", VALIDATION_ERROR_12a00ac4}, - {"VUID-VkShaderModuleCreateInfo-pCode-01379", VALIDATION_ERROR_12a00ac6}, - {"VUID-VkShaderModuleCreateInfo-flags-zerobitmask", VALIDATION_ERROR_12a09005}, - {"VUID-VkShaderModuleCreateInfo-pCode-parameter", VALIDATION_ERROR_12a10c01}, - {"VUID-VkShaderModuleCreateInfo-pNext-pNext", VALIDATION_ERROR_12a1c40d}, - {"VUID-VkShaderModuleCreateInfo-sType-sType", VALIDATION_ERROR_12a2b00b}, - {"VUID-VkSparseBufferMemoryBindInfo-bindCount-arraylength", VALIDATION_ERROR_12c0141b}, - {"VUID-VkSparseBufferMemoryBindInfo-buffer-parameter", VALIDATION_ERROR_12c01a01}, - {"VUID-VkSparseBufferMemoryBindInfo-pBinds-parameter", VALIDATION_ERROR_12c0fe01}, - {"VUID-VkSparseImageMemoryBind-memory-01104", VALIDATION_ERROR_12e008a0}, - {"VUID-VkSparseImageMemoryBind-memory-01105", VALIDATION_ERROR_12e008a2}, - {"VUID-VkSparseImageMemoryBind-subresource-01106", VALIDATION_ERROR_12e008a4}, - {"VUID-VkSparseImageMemoryBind-offset-01107", VALIDATION_ERROR_12e008a6}, - {"VUID-VkSparseImageMemoryBind-extent-01108", VALIDATION_ERROR_12e008a8}, - {"VUID-VkSparseImageMemoryBind-offset-01109", VALIDATION_ERROR_12e008aa}, - {"VUID-VkSparseImageMemoryBind-extent-01110", VALIDATION_ERROR_12e008ac}, - {"VUID-VkSparseImageMemoryBind-offset-01111", VALIDATION_ERROR_12e008ae}, - {"VUID-VkSparseImageMemoryBind-extent-01112", VALIDATION_ERROR_12e008b0}, - {"VUID-VkSparseImageMemoryBind-flags-parameter", VALIDATION_ERROR_12e09001}, - {"VUID-VkSparseImageMemoryBind-memory-parameter", VALIDATION_ERROR_12e0c601}, - {"VUID-VkSparseImageMemoryBind-subresource-parameter", VALIDATION_ERROR_12e2e801}, - {"VUID-VkSparseImageMemoryBindInfo-subresource-01722", VALIDATION_ERROR_13000d74}, - {"VUID-VkSparseImageMemoryBindInfo-subresource-01723", VALIDATION_ERROR_13000d76}, - {"VUID-VkSparseImageMemoryBindInfo-bindCount-arraylength", VALIDATION_ERROR_1300141b}, - {"VUID-VkSparseImageMemoryBindInfo-image-parameter", VALIDATION_ERROR_1300a001}, - {"VUID-VkSparseImageMemoryBindInfo-pBinds-parameter", VALIDATION_ERROR_1300fe01}, - {"VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103", VALIDATION_ERROR_1320089e}, - {"VUID-VkSparseImageOpaqueMemoryBindInfo-bindCount-arraylength", VALIDATION_ERROR_1320141b}, - {"VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter", VALIDATION_ERROR_1320a001}, - {"VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-parameter", VALIDATION_ERROR_1320fe01}, - {"VUID-VkSparseMemoryBind-memory-01096", VALIDATION_ERROR_13400890}, - {"VUID-VkSparseMemoryBind-memory-01097", VALIDATION_ERROR_13400892}, - {"VUID-VkSparseMemoryBind-size-01098", VALIDATION_ERROR_13400894}, - {"VUID-VkSparseMemoryBind-resourceOffset-01099", VALIDATION_ERROR_13400896}, - {"VUID-VkSparseMemoryBind-size-01100", VALIDATION_ERROR_13400898}, - {"VUID-VkSparseMemoryBind-memoryOffset-01101", VALIDATION_ERROR_1340089a}, - {"VUID-VkSparseMemoryBind-size-01102", VALIDATION_ERROR_1340089c}, - {"VUID-VkSparseMemoryBind-flags-parameter", VALIDATION_ERROR_13409001}, - {"VUID-VkSparseMemoryBind-memory-parameter", VALIDATION_ERROR_1340c601}, - {"VUID-VkSpecializationInfo-offset-00773", VALIDATION_ERROR_1360060a}, - {"VUID-VkSpecializationInfo-pMapEntries-00774", VALIDATION_ERROR_1360060c}, - {"VUID-VkSpecializationInfo-mapEntryCount-00775", VALIDATION_ERROR_1360060e}, - {"VUID-VkSpecializationInfo-pData-parameter", VALIDATION_ERROR_13612201}, - {"VUID-VkSpecializationMapEntry-constantID-00776", VALIDATION_ERROR_13800610}, - {"VUID-VkStencilOpState-compareOp-parameter", VALIDATION_ERROR_13a02a01}, - {"VUID-VkStencilOpState-depthFailOp-parameter", VALIDATION_ERROR_13a04201}, - {"VUID-VkStencilOpState-failOp-parameter", VALIDATION_ERROR_13a08601}, - {"VUID-VkStencilOpState-passOp-parameter", VALIDATION_ERROR_13a27801}, - {"VUID-VkSubmitInfo-commonparent", VALIDATION_ERROR_13c00009}, - {"VUID-VkSubmitInfo-pCommandBuffers-00075", VALIDATION_ERROR_13c00096}, - {"VUID-VkSubmitInfo-pWaitDstStageMask-00076", VALIDATION_ERROR_13c00098}, - {"VUID-VkSubmitInfo-pWaitDstStageMask-00077", VALIDATION_ERROR_13c0009a}, - {"VUID-VkSubmitInfo-pWaitDstStageMask-00078", VALIDATION_ERROR_13c0009c}, - {"VUID-VkSubmitInfo-pCommandBuffers-parameter", VALIDATION_ERROR_13c11401}, - {"VUID-VkSubmitInfo-pNext-pNext", VALIDATION_ERROR_13c1c40d}, - {"VUID-VkSubmitInfo-pSignalSemaphores-parameter", VALIDATION_ERROR_13c23401}, - {"VUID-VkSubmitInfo-pWaitDstStageMask-parameter", VALIDATION_ERROR_13c27001}, - {"VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask", VALIDATION_ERROR_13c27003}, - {"VUID-VkSubmitInfo-pWaitSemaphores-parameter", VALIDATION_ERROR_13c27601}, - {"VUID-VkSubmitInfo-sType-sType", VALIDATION_ERROR_13c2b00b}, - {"VUID-VkSubmitInfo-sType-unique", VALIDATION_ERROR_13c2b00f}, - {"VUID-VkSubpassDependency-srcSubpass-00858", VALIDATION_ERROR_13e006b4}, - {"VUID-VkSubpassDependency-dstSubpass-00859", VALIDATION_ERROR_13e006b6}, - {"VUID-VkSubpassDependency-srcStageMask-00860", VALIDATION_ERROR_13e006b8}, - {"VUID-VkSubpassDependency-dstStageMask-00861", VALIDATION_ERROR_13e006ba}, - {"VUID-VkSubpassDependency-srcStageMask-00862", VALIDATION_ERROR_13e006bc}, - {"VUID-VkSubpassDependency-dstStageMask-00863", VALIDATION_ERROR_13e006be}, - {"VUID-VkSubpassDependency-srcSubpass-00864", VALIDATION_ERROR_13e006c0}, - {"VUID-VkSubpassDependency-srcSubpass-00865", VALIDATION_ERROR_13e006c2}, - {"VUID-VkSubpassDependency-srcSubpass-00866", VALIDATION_ERROR_13e006c4}, - {"VUID-VkSubpassDependency-srcSubpass-00867", VALIDATION_ERROR_13e006c6}, - {"VUID-VkSubpassDependency-srcAccessMask-00868", VALIDATION_ERROR_13e006c8}, - {"VUID-VkSubpassDependency-dstAccessMask-00869", VALIDATION_ERROR_13e006ca}, - {"VUID-VkSubpassDependency-dependencyFlags-00870", VALIDATION_ERROR_13e006cc}, - {"VUID-VkSubpassDependency-dependencyFlags-00871", VALIDATION_ERROR_13e006ce}, - {"VUID-VkSubpassDependency-srcSubpass-00872", VALIDATION_ERROR_13e006d0}, - {"VUID-VkSubpassDependency-dependencyFlags-parameter", VALIDATION_ERROR_13e03e01}, - {"VUID-VkSubpassDependency-dstAccessMask-parameter", VALIDATION_ERROR_13e06801}, - {"VUID-VkSubpassDependency-dstStageMask-parameter", VALIDATION_ERROR_13e07801}, - {"VUID-VkSubpassDependency-dstStageMask-requiredbitmask", VALIDATION_ERROR_13e07803}, - {"VUID-VkSubpassDependency-srcAccessMask-parameter", VALIDATION_ERROR_13e2c401}, - {"VUID-VkSubpassDependency-srcStageMask-parameter", VALIDATION_ERROR_13e2d401}, - {"VUID-VkSubpassDependency-srcStageMask-requiredbitmask", VALIDATION_ERROR_13e2d403}, - {"VUID-VkSubpassDescription-pipelineBindPoint-00844", VALIDATION_ERROR_14000698}, - {"VUID-VkSubpassDescription-colorAttachmentCount-00845", VALIDATION_ERROR_1400069a}, - {"VUID-VkSubpassDescription-loadOp-00846", VALIDATION_ERROR_1400069c}, - {"VUID-VkSubpassDescription-pResolveAttachments-00847", VALIDATION_ERROR_1400069e}, - {"VUID-VkSubpassDescription-pResolveAttachments-00848", VALIDATION_ERROR_140006a0}, - {"VUID-VkSubpassDescription-pResolveAttachments-00849", VALIDATION_ERROR_140006a2}, - {"VUID-VkSubpassDescription-pResolveAttachments-00850", VALIDATION_ERROR_140006a4}, - {"VUID-VkSubpassDescription-None-00852", VALIDATION_ERROR_140006a8}, - {"VUID-VkSubpassDescription-attachment-00853", VALIDATION_ERROR_140006aa}, - {"VUID-VkSubpassDescription-pPreserveAttachments-00854", VALIDATION_ERROR_140006ac}, - {"VUID-VkSubpassDescription-layout-00855", VALIDATION_ERROR_140006ae}, - {"VUID-VkSubpassDescription-flags-00856", VALIDATION_ERROR_140006b0}, - {"VUID-VkSubpassDescription-pColorAttachments-01417", VALIDATION_ERROR_14000b12}, - {"VUID-VkSubpassDescription-pDepthStencilAttachment-01418", VALIDATION_ERROR_14000b14}, - {"VUID-VkSubpassDescription-pColorAttachments-01506", VALIDATION_ERROR_14000bc4}, - {"VUID-VkSubpassDescription-flags-parameter", VALIDATION_ERROR_14009001}, - {"VUID-VkSubpassDescription-pColorAttachments-parameter", VALIDATION_ERROR_14011001}, - {"VUID-VkSubpassDescription-pDepthStencilAttachment-parameter", VALIDATION_ERROR_14012a01}, - {"VUID-VkSubpassDescription-pInputAttachments-parameter", VALIDATION_ERROR_14019a01}, - {"VUID-VkSubpassDescription-pPreserveAttachments-parameter", VALIDATION_ERROR_1401f001}, - {"VUID-VkSubpassDescription-pResolveAttachments-parameter", VALIDATION_ERROR_14021c01}, - {"VUID-VkSubpassDescription-pipelineBindPoint-parameter", VALIDATION_ERROR_14027e01}, - {"VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246", VALIDATION_ERROR_142009bc}, - {"VUID-VkSurfaceCapabilities2EXT-pNext-pNext", VALIDATION_ERROR_1421c40d}, - {"VUID-VkSurfaceCapabilities2EXT-sType-sType", VALIDATION_ERROR_1422b00b}, - {"VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244", VALIDATION_ERROR_144009b8}, - {"VUID-VkSwapchainCounterCreateInfoEXT-sType-sType", VALIDATION_ERROR_1442b00b}, - {"VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter", VALIDATION_ERROR_1442ee01}, - {"VUID-VkSwapchainCreateInfoKHR-commonparent", VALIDATION_ERROR_14600009}, - {"VUID-VkSwapchainCreateInfoKHR-surface-01270", VALIDATION_ERROR_146009ec}, - {"VUID-VkSwapchainCreateInfoKHR-minImageCount-01271", VALIDATION_ERROR_146009ee}, - {"VUID-VkSwapchainCreateInfoKHR-minImageCount-01272", VALIDATION_ERROR_146009f0}, - {"VUID-VkSwapchainCreateInfoKHR-imageFormat-01273", VALIDATION_ERROR_146009f2}, - {"VUID-VkSwapchainCreateInfoKHR-imageExtent-01274", VALIDATION_ERROR_146009f4}, - {"VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275", VALIDATION_ERROR_146009f6}, - {"VUID-VkSwapchainCreateInfoKHR-imageUsage-01276", VALIDATION_ERROR_146009f8}, - {"VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277", VALIDATION_ERROR_146009fa}, - {"VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278", VALIDATION_ERROR_146009fc}, - {"VUID-VkSwapchainCreateInfoKHR-preTransform-01279", VALIDATION_ERROR_146009fe}, - {"VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280", VALIDATION_ERROR_14600a00}, - {"VUID-VkSwapchainCreateInfoKHR-presentMode-01281", VALIDATION_ERROR_14600a02}, - {"VUID-VkSwapchainCreateInfoKHR-minImageCount-01383", VALIDATION_ERROR_14600ace}, - {"VUID-VkSwapchainCreateInfoKHR-imageUsage-01384", VALIDATION_ERROR_14600ad0}, - {"VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01393", VALIDATION_ERROR_14600ae2}, - {"VUID-VkSwapchainCreateInfoKHR-presentMode-01427", VALIDATION_ERROR_14600b26}, - {"VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428", VALIDATION_ERROR_14600b28}, - {"VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429", VALIDATION_ERROR_14600b2a}, - {"VUID-VkSwapchainCreateInfoKHR-imageExtent-01689", VALIDATION_ERROR_14600d32}, - {"VUID-VkSwapchainCreateInfoKHR-imageFormat-01778", VALIDATION_ERROR_14600de4}, - {"VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933", VALIDATION_ERROR_14600f1a}, - {"VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter", VALIDATION_ERROR_14602e01}, - {"VUID-VkSwapchainCreateInfoKHR-flags-parameter", VALIDATION_ERROR_14609001}, - {"VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter", VALIDATION_ERROR_1460a201}, - {"VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter", VALIDATION_ERROR_1460a401}, - {"VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter", VALIDATION_ERROR_1460a801}, - {"VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter", VALIDATION_ERROR_1460ae01}, - {"VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask", VALIDATION_ERROR_1460ae03}, - {"VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter", VALIDATION_ERROR_1460de01}, - {"VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent", VALIDATION_ERROR_1460de07}, - {"VUID-VkSwapchainCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_1461c40d}, - {"VUID-VkSwapchainCreateInfoKHR-preTransform-parameter", VALIDATION_ERROR_14629401}, - {"VUID-VkSwapchainCreateInfoKHR-presentMode-parameter", VALIDATION_ERROR_14629601}, - {"VUID-VkSwapchainCreateInfoKHR-sType-sType", VALIDATION_ERROR_1462b00b}, - {"VUID-VkSwapchainCreateInfoKHR-sType-unique", VALIDATION_ERROR_1462b00f}, - {"VUID-VkSwapchainCreateInfoKHR-surface-parameter", VALIDATION_ERROR_1462ec01}, - {"VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength", VALIDATION_ERROR_14805a1b}, - {"VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter", VALIDATION_ERROR_14814401}, - {"VUID-VkValidationFlagsEXT-sType-sType", VALIDATION_ERROR_1482b00b}, - {"VUID-VkVertexInputAttributeDescription-location-00620", VALIDATION_ERROR_14a004d8}, - {"VUID-VkVertexInputAttributeDescription-binding-00621", VALIDATION_ERROR_14a004da}, - {"VUID-VkVertexInputAttributeDescription-offset-00622", VALIDATION_ERROR_14a004dc}, - {"VUID-VkVertexInputAttributeDescription-format-00623", VALIDATION_ERROR_14a004de}, - {"VUID-VkVertexInputAttributeDescription-format-parameter", VALIDATION_ERROR_14a09201}, - {"VUID-VkVertexInputBindingDescription-binding-00618", VALIDATION_ERROR_14c004d4}, - {"VUID-VkVertexInputBindingDescription-stride-00619", VALIDATION_ERROR_14c004d6}, - {"VUID-VkVertexInputBindingDescription-inputRate-parameter", VALIDATION_ERROR_14c0ba01}, - {"VUID-VkViSurfaceCreateInfoNN-window-01318", VALIDATION_ERROR_14e00a4c}, - {"VUID-VkViSurfaceCreateInfoNN-flags-zerobitmask", VALIDATION_ERROR_14e09005}, - {"VUID-VkViSurfaceCreateInfoNN-pNext-pNext", VALIDATION_ERROR_14e1c40d}, - {"VUID-VkViSurfaceCreateInfoNN-sType-sType", VALIDATION_ERROR_14e2b00b}, - {"VUID-VkViewport-x-01232", VALIDATION_ERROR_150009a0}, - {"VUID-VkViewport-y-01233", VALIDATION_ERROR_150009a2}, - {"VUID-VkViewport-minDepth-01234", VALIDATION_ERROR_150009a4}, - {"VUID-VkViewport-maxDepth-01235", VALIDATION_ERROR_150009a6}, - {"VUID-VkViewport-width-01770", VALIDATION_ERROR_15000dd4}, - {"VUID-VkViewport-width-01771", VALIDATION_ERROR_15000dd6}, - {"VUID-VkViewport-height-01772", VALIDATION_ERROR_15000dd8}, - {"VUID-VkViewport-height-01773", VALIDATION_ERROR_15000dda}, - {"VUID-VkViewport-x-01774", VALIDATION_ERROR_15000ddc}, - {"VUID-VkViewport-y-01775", VALIDATION_ERROR_15000dde}, - {"VUID-VkViewport-y-01776", VALIDATION_ERROR_15000de0}, - {"VUID-VkViewport-y-01777", VALIDATION_ERROR_15000de2}, - {"VUID-VkViewportSwizzleNV-w-parameter", VALIDATION_ERROR_15230c01}, - {"VUID-VkViewportSwizzleNV-x-parameter", VALIDATION_ERROR_15231001}, - {"VUID-VkViewportSwizzleNV-y-parameter", VALIDATION_ERROR_15231201}, - {"VUID-VkViewportSwizzleNV-z-parameter", VALIDATION_ERROR_15231401}, - {"VUID-VkWaylandSurfaceCreateInfoKHR-display-01304", VALIDATION_ERROR_15400a30}, - {"VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305", VALIDATION_ERROR_15400a32}, - {"VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_15409005}, - {"VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_1541c40d}, - {"VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType", VALIDATION_ERROR_1542b00b}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent", VALIDATION_ERROR_15600009}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081", VALIDATION_ERROR_156000a2}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter", VALIDATION_ERROR_1560e201}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter", VALIDATION_ERROR_1560e401}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter", VALIDATION_ERROR_1560e801}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter", VALIDATION_ERROR_15621201}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter", VALIDATION_ERROR_15621401}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType", VALIDATION_ERROR_1562b00b}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent", VALIDATION_ERROR_15800009}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter", VALIDATION_ERROR_1580e201}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter", VALIDATION_ERROR_1580e401}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireTimeoutMilliseconds-parameter", VALIDATION_ERROR_1580e601}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseKeys-parameter", VALIDATION_ERROR_15821201}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseSyncs-parameter", VALIDATION_ERROR_15821401}, - {"VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-sType-sType", VALIDATION_ERROR_1582b00b}, - {"VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307", VALIDATION_ERROR_15a00a36}, - {"VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308", VALIDATION_ERROR_15a00a38}, - {"VUID-VkWin32SurfaceCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_15a09005}, - {"VUID-VkWin32SurfaceCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_15a1c40d}, - {"VUID-VkWin32SurfaceCreateInfoKHR-sType-sType", VALIDATION_ERROR_15a2b00b}, - {"VUID-VkWriteDescriptorSet-commonparent", VALIDATION_ERROR_15c00009}, - {"VUID-VkWriteDescriptorSet-dstBinding-00315", VALIDATION_ERROR_15c00276}, - {"VUID-VkWriteDescriptorSet-dstBinding-00316", VALIDATION_ERROR_15c00278}, - {"VUID-VkWriteDescriptorSet-descriptorCount-00317", VALIDATION_ERROR_15c0027a}, - {"VUID-VkWriteDescriptorSet-descriptorCount-00318", VALIDATION_ERROR_15c0027c}, - {"VUID-VkWriteDescriptorSet-descriptorType-00319", VALIDATION_ERROR_15c0027e}, - {"VUID-VkWriteDescriptorSet-dstSet-00320", VALIDATION_ERROR_15c00280}, - {"VUID-VkWriteDescriptorSet-dstArrayElement-00321", VALIDATION_ERROR_15c00282}, - {"VUID-VkWriteDescriptorSet-descriptorType-00322", VALIDATION_ERROR_15c00284}, - {"VUID-VkWriteDescriptorSet-descriptorType-00323", VALIDATION_ERROR_15c00286}, - {"VUID-VkWriteDescriptorSet-descriptorType-00324", VALIDATION_ERROR_15c00288}, - {"VUID-VkWriteDescriptorSet-descriptorType-00325", VALIDATION_ERROR_15c0028a}, - {"VUID-VkWriteDescriptorSet-descriptorType-00326", VALIDATION_ERROR_15c0028c}, - {"VUID-VkWriteDescriptorSet-descriptorType-00327", VALIDATION_ERROR_15c0028e}, - {"VUID-VkWriteDescriptorSet-descriptorType-00328", VALIDATION_ERROR_15c00290}, - {"VUID-VkWriteDescriptorSet-descriptorType-00329", VALIDATION_ERROR_15c00292}, - {"VUID-VkWriteDescriptorSet-descriptorType-00330", VALIDATION_ERROR_15c00294}, - {"VUID-VkWriteDescriptorSet-descriptorType-00331", VALIDATION_ERROR_15c00296}, - {"VUID-VkWriteDescriptorSet-descriptorType-00332", VALIDATION_ERROR_15c00298}, - {"VUID-VkWriteDescriptorSet-descriptorType-00333", VALIDATION_ERROR_15c0029a}, - {"VUID-VkWriteDescriptorSet-descriptorType-00334", VALIDATION_ERROR_15c0029c}, - {"VUID-VkWriteDescriptorSet-descriptorType-00335", VALIDATION_ERROR_15c0029e}, - {"VUID-VkWriteDescriptorSet-descriptorType-00336", VALIDATION_ERROR_15c002a0}, - {"VUID-VkWriteDescriptorSet-descriptorType-00337", VALIDATION_ERROR_15c002a2}, - {"VUID-VkWriteDescriptorSet-descriptorType-00338", VALIDATION_ERROR_15c002a4}, - {"VUID-VkWriteDescriptorSet-descriptorType-00339", VALIDATION_ERROR_15c002a6}, - {"VUID-VkWriteDescriptorSet-descriptorType-01402", VALIDATION_ERROR_15c00af4}, - {"VUID-VkWriteDescriptorSet-descriptorType-01403", VALIDATION_ERROR_15c00af6}, - {"VUID-VkWriteDescriptorSet-descriptorCount-03048", VALIDATION_ERROR_15c017d0}, - {"VUID-VkWriteDescriptorSet-descriptorCount-arraylength", VALIDATION_ERROR_15c0441b}, - {"VUID-VkWriteDescriptorSet-descriptorType-parameter", VALIDATION_ERROR_15c04e01}, - {"VUID-VkWriteDescriptorSet-pNext-pNext", VALIDATION_ERROR_15c1c40d}, - {"VUID-VkWriteDescriptorSet-sType-sType", VALIDATION_ERROR_15c2b00b}, - {"VUID-VkXcbSurfaceCreateInfoKHR-connection-01310", VALIDATION_ERROR_15e00a3c}, - {"VUID-VkXcbSurfaceCreateInfoKHR-window-01311", VALIDATION_ERROR_15e00a3e}, - {"VUID-VkXcbSurfaceCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_15e09005}, - {"VUID-VkXcbSurfaceCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_15e1c40d}, - {"VUID-VkXcbSurfaceCreateInfoKHR-sType-sType", VALIDATION_ERROR_15e2b00b}, - {"VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313", VALIDATION_ERROR_16000a42}, - {"VUID-VkXlibSurfaceCreateInfoKHR-window-01314", VALIDATION_ERROR_16000a44}, - {"VUID-VkXlibSurfaceCreateInfoKHR-flags-zerobitmask", VALIDATION_ERROR_16009005}, - {"VUID-VkXlibSurfaceCreateInfoKHR-pNext-pNext", VALIDATION_ERROR_1601c40d}, - {"VUID-VkXlibSurfaceCreateInfoKHR-sType-sType", VALIDATION_ERROR_1602b00b}, - {"VUID-vkAcquireNextImage2KHR-swapchain-01803", VALIDATION_ERROR_16200e16}, - {"VUID-vkAcquireNextImage2KHR-device-parameter", VALIDATION_ERROR_16205601}, - {"VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter", VALIDATION_ERROR_1620e001}, - {"VUID-vkAcquireNextImage2KHR-pImageIndex-parameter", VALIDATION_ERROR_16218601}, - {"VUID-vkAcquireNextImageKHR-commonparent", VALIDATION_ERROR_16400009}, - {"VUID-vkAcquireNextImageKHR-swapchain-01285", VALIDATION_ERROR_16400a0a}, - {"VUID-vkAcquireNextImageKHR-semaphore-01286", VALIDATION_ERROR_16400a0c}, - {"VUID-vkAcquireNextImageKHR-fence-01287", VALIDATION_ERROR_16400a0e}, - {"VUID-vkAcquireNextImageKHR-semaphore-01779", VALIDATION_ERROR_16400de6}, - {"VUID-vkAcquireNextImageKHR-semaphore-01780", VALIDATION_ERROR_16400de8}, - {"VUID-vkAcquireNextImageKHR-swapchain-01802", VALIDATION_ERROR_16400e14}, - {"VUID-vkAcquireNextImageKHR-device-parameter", VALIDATION_ERROR_16405601}, - {"VUID-vkAcquireNextImageKHR-fence-parameter", VALIDATION_ERROR_16408801}, - {"VUID-vkAcquireNextImageKHR-fence-parent", VALIDATION_ERROR_16408807}, - {"VUID-vkAcquireNextImageKHR-pImageIndex-parameter", VALIDATION_ERROR_16418601}, - {"VUID-vkAcquireNextImageKHR-semaphore-parameter", VALIDATION_ERROR_1642b801}, - {"VUID-vkAcquireNextImageKHR-semaphore-parent", VALIDATION_ERROR_1642b807}, - {"VUID-vkAcquireNextImageKHR-swapchain-parameter", VALIDATION_ERROR_1642f001}, - {"VUID-vkAcquireXlibDisplayEXT-display-parameter", VALIDATION_ERROR_16606001}, - {"VUID-vkAcquireXlibDisplayEXT-dpy-parameter", VALIDATION_ERROR_16606601}, - {"VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter", VALIDATION_ERROR_16627a01}, - {"VUID-vkAllocateCommandBuffers-device-parameter", VALIDATION_ERROR_16805601}, - {"VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter", VALIDATION_ERROR_1680ea01}, - {"VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter", VALIDATION_ERROR_16811401}, - {"VUID-vkAllocateDescriptorSets-device-parameter", VALIDATION_ERROR_16a05601}, - {"VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter", VALIDATION_ERROR_16a0ea01}, - {"VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter", VALIDATION_ERROR_16a13001}, - {"VUID-vkAllocateMemory-pAllocateInfo-01713", VALIDATION_ERROR_16c00d62}, - {"VUID-vkAllocateMemory-pAllocateInfo-01714", VALIDATION_ERROR_16c00d64}, - {"VUID-vkAllocateMemory-device-parameter", VALIDATION_ERROR_16c05601}, - {"VUID-vkAllocateMemory-pAllocateInfo-parameter", VALIDATION_ERROR_16c0ea01}, - {"VUID-vkAllocateMemory-pAllocator-parameter", VALIDATION_ERROR_16c0ec01}, - {"VUID-vkAllocateMemory-pMemory-parameter", VALIDATION_ERROR_16c1aa01}, - {"VUID-vkBeginCommandBuffer-commandBuffer-00049", VALIDATION_ERROR_16e00062}, - {"VUID-vkBeginCommandBuffer-commandBuffer-00050", VALIDATION_ERROR_16e00064}, - {"VUID-vkBeginCommandBuffer-commandBuffer-00051", VALIDATION_ERROR_16e00066}, - {"VUID-vkBeginCommandBuffer-commandBuffer-00052", VALIDATION_ERROR_16e00068}, - {"VUID-vkBeginCommandBuffer-commandBuffer-parameter", VALIDATION_ERROR_16e02401}, - {"VUID-vkBeginCommandBuffer-pBeginInfo-parameter", VALIDATION_ERROR_16e0f601}, - {"VUID-vkBindBufferMemory-buffer-01029", VALIDATION_ERROR_1700080a}, - {"VUID-vkBindBufferMemory-buffer-01030", VALIDATION_ERROR_1700080c}, - {"VUID-vkBindBufferMemory-memoryOffset-01031", VALIDATION_ERROR_1700080e}, - {"VUID-vkBindBufferMemory-buffer-01032", VALIDATION_ERROR_17000810}, - {"VUID-vkBindBufferMemory-buffer-01033", VALIDATION_ERROR_17000812}, - {"VUID-vkBindBufferMemory-buffer-01034", VALIDATION_ERROR_17000814}, - {"VUID-vkBindBufferMemory-memory-01035", VALIDATION_ERROR_17000816}, - {"VUID-vkBindBufferMemory-memoryOffset-01036", VALIDATION_ERROR_17000818}, - {"VUID-vkBindBufferMemory-size-01037", VALIDATION_ERROR_1700081a}, - {"VUID-vkBindBufferMemory-buffer-01038", VALIDATION_ERROR_1700081c}, - {"VUID-vkBindBufferMemory-buffer-01039", VALIDATION_ERROR_1700081e}, - {"VUID-vkBindBufferMemory-buffer-01444", VALIDATION_ERROR_17000b48}, - {"VUID-vkBindBufferMemory-memory-01508", VALIDATION_ERROR_17000bc8}, - {"VUID-vkBindBufferMemory-None-01898", VALIDATION_ERROR_17000ed4}, - {"VUID-vkBindBufferMemory-None-01899", VALIDATION_ERROR_17000ed6}, - {"VUID-vkBindBufferMemory-buffer-parameter", VALIDATION_ERROR_17001a01}, - {"VUID-vkBindBufferMemory-buffer-parent", VALIDATION_ERROR_17001a07}, - {"VUID-vkBindBufferMemory-device-parameter", VALIDATION_ERROR_17005601}, - {"VUID-vkBindBufferMemory-memory-parameter", VALIDATION_ERROR_1700c601}, - {"VUID-vkBindBufferMemory-memory-parent", VALIDATION_ERROR_1700c607}, - {"VUID-vkBindBufferMemory2-bindInfoCount-arraylength", VALIDATION_ERROR_1720161b}, - {"VUID-vkBindBufferMemory2-device-parameter", VALIDATION_ERROR_17205601}, - {"VUID-vkBindBufferMemory2-pBindInfos-parameter", VALIDATION_ERROR_1720fa01}, - {"VUID-vkBindImageMemory-image-01044", VALIDATION_ERROR_17400828}, - {"VUID-vkBindImageMemory-image-01045", VALIDATION_ERROR_1740082a}, - {"VUID-vkBindImageMemory-memoryOffset-01046", VALIDATION_ERROR_1740082c}, - {"VUID-vkBindImageMemory-memory-01047", VALIDATION_ERROR_1740082e}, - {"VUID-vkBindImageMemory-memoryOffset-01048", VALIDATION_ERROR_17400830}, - {"VUID-vkBindImageMemory-size-01049", VALIDATION_ERROR_17400832}, - {"VUID-vkBindImageMemory-image-01050", VALIDATION_ERROR_17400834}, - {"VUID-vkBindImageMemory-image-01051", VALIDATION_ERROR_17400836}, - {"VUID-vkBindImageMemory-image-01445", VALIDATION_ERROR_17400b4a}, - {"VUID-vkBindImageMemory-memory-01509", VALIDATION_ERROR_17400bca}, - {"VUID-vkBindImageMemory-image-01608", VALIDATION_ERROR_17400c90}, - {"VUID-vkBindImageMemory-None-01901", VALIDATION_ERROR_17400eda}, - {"VUID-vkBindImageMemory-None-01902", VALIDATION_ERROR_17400edc}, - {"VUID-vkBindImageMemory-device-parameter", VALIDATION_ERROR_17405601}, - {"VUID-vkBindImageMemory-image-parameter", VALIDATION_ERROR_1740a001}, - {"VUID-vkBindImageMemory-image-parent", VALIDATION_ERROR_1740a007}, - {"VUID-vkBindImageMemory-memory-parameter", VALIDATION_ERROR_1740c601}, - {"VUID-vkBindImageMemory-memory-parent", VALIDATION_ERROR_1740c607}, - {"VUID-vkBindImageMemory2-bindInfoCount-arraylength", VALIDATION_ERROR_1760161b}, - {"VUID-vkBindImageMemory2-device-parameter", VALIDATION_ERROR_17605601}, - {"VUID-vkBindImageMemory2-pBindInfos-parameter", VALIDATION_ERROR_1760fa01}, - {"VUID-vkCmdBeginQuery-commonparent", VALIDATION_ERROR_17800009}, - {"VUID-vkCmdBeginQuery-queryType-00800", VALIDATION_ERROR_17800640}, - {"VUID-vkCmdBeginQuery-query-00802", VALIDATION_ERROR_17800644}, - {"VUID-vkCmdBeginQuery-queryType-00803", VALIDATION_ERROR_17800646}, - {"VUID-vkCmdBeginQuery-queryType-00804", VALIDATION_ERROR_17800648}, - {"VUID-vkCmdBeginQuery-queryType-00805", VALIDATION_ERROR_1780064a}, - {"VUID-vkCmdBeginQuery-None-00807", VALIDATION_ERROR_1780064e}, - {"VUID-vkCmdBeginQuery-query-00808", VALIDATION_ERROR_17800650}, - {"VUID-vkCmdBeginQuery-commandBuffer-01885", VALIDATION_ERROR_17800eba}, - {"VUID-vkCmdBeginQuery-queryPool-01922", VALIDATION_ERROR_17800f04}, - {"VUID-vkCmdBeginQuery-commandBuffer-parameter", VALIDATION_ERROR_17802401}, - {"VUID-vkCmdBeginQuery-commandBuffer-recording", VALIDATION_ERROR_17802413}, - {"VUID-vkCmdBeginQuery-commandBuffer-cmdpool", VALIDATION_ERROR_17802415}, - {"VUID-vkCmdBeginQuery-flags-parameter", VALIDATION_ERROR_17809001}, - {"VUID-vkCmdBeginQuery-queryPool-parameter", VALIDATION_ERROR_17829801}, - {"VUID-vkCmdBeginRenderPass-renderpass", VALIDATION_ERROR_17a00017}, - {"VUID-vkCmdBeginRenderPass-bufferlevel", VALIDATION_ERROR_17a00019}, - {"VUID-vkCmdBeginRenderPass-initialLayout-00895", VALIDATION_ERROR_17a006fe}, - {"VUID-vkCmdBeginRenderPass-initialLayout-00896", VALIDATION_ERROR_17a00700}, - {"VUID-vkCmdBeginRenderPass-initialLayout-00897", VALIDATION_ERROR_17a00702}, - {"VUID-vkCmdBeginRenderPass-initialLayout-00898", VALIDATION_ERROR_17a00704}, - {"VUID-vkCmdBeginRenderPass-initialLayout-00899", VALIDATION_ERROR_17a00706}, - {"VUID-vkCmdBeginRenderPass-initialLayout-00900", VALIDATION_ERROR_17a00708}, - {"VUID-vkCmdBeginRenderPass-srcStageMask-00901", VALIDATION_ERROR_17a0070a}, - {"VUID-vkCmdBeginRenderPass-initialLayout-01758", VALIDATION_ERROR_17a00dbc}, - {"VUID-vkCmdBeginRenderPass-commandBuffer-parameter", VALIDATION_ERROR_17a02401}, - {"VUID-vkCmdBeginRenderPass-commandBuffer-recording", VALIDATION_ERROR_17a02413}, - {"VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool", VALIDATION_ERROR_17a02415}, - {"VUID-vkCmdBeginRenderPass-contents-parameter", VALIDATION_ERROR_17a03201}, - {"VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter", VALIDATION_ERROR_17a21801}, - {"VUID-vkCmdBindDescriptorSets-commonparent", VALIDATION_ERROR_17c00009}, - {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358", VALIDATION_ERROR_17c002cc}, - {"VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359", VALIDATION_ERROR_17c002ce}, - {"VUID-vkCmdBindDescriptorSets-firstSet-00360", VALIDATION_ERROR_17c002d0}, - {"VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361", VALIDATION_ERROR_17c002d2}, - {"VUID-vkCmdBindDescriptorSets-pDynamicOffsets-00362", VALIDATION_ERROR_17c002d4}, - {"VUID-vkCmdBindDescriptorSets-commandBuffer-parameter", VALIDATION_ERROR_17c02401}, - {"VUID-vkCmdBindDescriptorSets-commandBuffer-recording", VALIDATION_ERROR_17c02413}, - {"VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool", VALIDATION_ERROR_17c02415}, - {"VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength", VALIDATION_ERROR_17c04a1b}, - {"VUID-vkCmdBindDescriptorSets-layout-parameter", VALIDATION_ERROR_17c0be01}, - {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter", VALIDATION_ERROR_17c13001}, - {"VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter", VALIDATION_ERROR_17c15401}, - {"VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter", VALIDATION_ERROR_17c27e01}, - {"VUID-vkCmdBindIndexBuffer-commonparent", VALIDATION_ERROR_17e00009}, - {"VUID-vkCmdBindIndexBuffer-offset-00431", VALIDATION_ERROR_17e0035e}, - {"VUID-vkCmdBindIndexBuffer-offset-00432", VALIDATION_ERROR_17e00360}, - {"VUID-vkCmdBindIndexBuffer-buffer-00433", VALIDATION_ERROR_17e00362}, - {"VUID-vkCmdBindIndexBuffer-buffer-00434", VALIDATION_ERROR_17e00364}, - {"VUID-vkCmdBindIndexBuffer-buffer-parameter", VALIDATION_ERROR_17e01a01}, - {"VUID-vkCmdBindIndexBuffer-commandBuffer-parameter", VALIDATION_ERROR_17e02401}, - {"VUID-vkCmdBindIndexBuffer-commandBuffer-recording", VALIDATION_ERROR_17e02413}, - {"VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool", VALIDATION_ERROR_17e02415}, - {"VUID-vkCmdBindIndexBuffer-indexType-parameter", VALIDATION_ERROR_17e0b201}, - {"VUID-vkCmdBindPipeline-commonparent", VALIDATION_ERROR_18000009}, - {"VUID-vkCmdBindPipeline-pipelineBindPoint-00777", VALIDATION_ERROR_18000612}, - {"VUID-vkCmdBindPipeline-pipelineBindPoint-00778", VALIDATION_ERROR_18000614}, - {"VUID-vkCmdBindPipeline-pipelineBindPoint-00779", VALIDATION_ERROR_18000616}, - {"VUID-vkCmdBindPipeline-pipelineBindPoint-00780", VALIDATION_ERROR_18000618}, - {"VUID-vkCmdBindPipeline-pipeline-00781", VALIDATION_ERROR_1800061a}, - {"VUID-vkCmdBindPipeline-variableSampleLocations-01525", VALIDATION_ERROR_18000bea}, - {"VUID-vkCmdBindPipeline-commandBuffer-parameter", VALIDATION_ERROR_18002401}, - {"VUID-vkCmdBindPipeline-commandBuffer-recording", VALIDATION_ERROR_18002413}, - {"VUID-vkCmdBindPipeline-commandBuffer-cmdpool", VALIDATION_ERROR_18002415}, - {"VUID-vkCmdBindPipeline-pipeline-parameter", VALIDATION_ERROR_18027c01}, - {"VUID-vkCmdBindPipeline-pipelineBindPoint-parameter", VALIDATION_ERROR_18027e01}, - {"VUID-vkCmdBindVertexBuffers-commonparent", VALIDATION_ERROR_18200009}, - {"VUID-vkCmdBindVertexBuffers-firstBinding-00624", VALIDATION_ERROR_182004e0}, - {"VUID-vkCmdBindVertexBuffers-firstBinding-00625", VALIDATION_ERROR_182004e2}, - {"VUID-vkCmdBindVertexBuffers-pOffsets-00626", VALIDATION_ERROR_182004e4}, - {"VUID-vkCmdBindVertexBuffers-pBuffers-00627", VALIDATION_ERROR_182004e6}, - {"VUID-vkCmdBindVertexBuffers-pBuffers-00628", VALIDATION_ERROR_182004e8}, - {"VUID-vkCmdBindVertexBuffers-bindingCount-arraylength", VALIDATION_ERROR_1820181b}, - {"VUID-vkCmdBindVertexBuffers-commandBuffer-parameter", VALIDATION_ERROR_18202401}, - {"VUID-vkCmdBindVertexBuffers-commandBuffer-recording", VALIDATION_ERROR_18202413}, - {"VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool", VALIDATION_ERROR_18202415}, - {"VUID-vkCmdBindVertexBuffers-pBuffers-parameter", VALIDATION_ERROR_18210601}, - {"VUID-vkCmdBindVertexBuffers-pOffsets-parameter", VALIDATION_ERROR_1821d201}, - {"VUID-vkCmdBlitImage-commonparent", VALIDATION_ERROR_18400009}, - {"VUID-vkCmdBlitImage-renderpass", VALIDATION_ERROR_18400017}, - {"VUID-vkCmdBlitImage-pRegions-00215", VALIDATION_ERROR_184001ae}, - {"VUID-vkCmdBlitImage-pRegions-00216", VALIDATION_ERROR_184001b0}, - {"VUID-vkCmdBlitImage-pRegions-00217", VALIDATION_ERROR_184001b2}, - {"VUID-vkCmdBlitImage-srcImage-00218", VALIDATION_ERROR_184001b4}, - {"VUID-vkCmdBlitImage-srcImage-00219", VALIDATION_ERROR_184001b6}, - {"VUID-vkCmdBlitImage-srcImage-00220", VALIDATION_ERROR_184001b8}, - {"VUID-vkCmdBlitImage-srcImageLayout-00221", VALIDATION_ERROR_184001ba}, - {"VUID-vkCmdBlitImage-srcImageLayout-00222", VALIDATION_ERROR_184001bc}, - {"VUID-vkCmdBlitImage-dstImage-00223", VALIDATION_ERROR_184001be}, - {"VUID-vkCmdBlitImage-dstImage-00224", VALIDATION_ERROR_184001c0}, - {"VUID-vkCmdBlitImage-dstImage-00225", VALIDATION_ERROR_184001c2}, - {"VUID-vkCmdBlitImage-dstImageLayout-00226", VALIDATION_ERROR_184001c4}, - {"VUID-vkCmdBlitImage-dstImageLayout-00227", VALIDATION_ERROR_184001c6}, - {"VUID-vkCmdBlitImage-srcImage-00228", VALIDATION_ERROR_184001c8}, - {"VUID-vkCmdBlitImage-srcImage-00229", VALIDATION_ERROR_184001ca}, - {"VUID-vkCmdBlitImage-srcImage-00230", VALIDATION_ERROR_184001cc}, - {"VUID-vkCmdBlitImage-srcImage-00231", VALIDATION_ERROR_184001ce}, - {"VUID-vkCmdBlitImage-srcImage-00232", VALIDATION_ERROR_184001d0}, - {"VUID-vkCmdBlitImage-srcImage-00233", VALIDATION_ERROR_184001d2}, - {"VUID-vkCmdBlitImage-dstImage-00234", VALIDATION_ERROR_184001d4}, - {"VUID-vkCmdBlitImage-filter-00235", VALIDATION_ERROR_184001d6}, - {"VUID-vkCmdBlitImage-filter-00236", VALIDATION_ERROR_184001d8}, - {"VUID-vkCmdBlitImage-filter-00237", VALIDATION_ERROR_184001da}, - {"VUID-vkCmdBlitImage-srcImageLayout-01398", VALIDATION_ERROR_18400aec}, - {"VUID-vkCmdBlitImage-dstImageLayout-01399", VALIDATION_ERROR_18400aee}, - {"VUID-vkCmdBlitImage-srcImage-01561", VALIDATION_ERROR_18400c32}, - {"VUID-vkCmdBlitImage-dstImage-01562", VALIDATION_ERROR_18400c34}, - {"VUID-vkCmdBlitImage-srcSubresource-01705", VALIDATION_ERROR_18400d52}, - {"VUID-vkCmdBlitImage-dstSubresource-01706", VALIDATION_ERROR_18400d54}, - {"VUID-vkCmdBlitImage-srcSubresource-01707", VALIDATION_ERROR_18400d56}, - {"VUID-vkCmdBlitImage-dstSubresource-01708", VALIDATION_ERROR_18400d58}, - {"VUID-vkCmdBlitImage-commandBuffer-01834", VALIDATION_ERROR_18400e54}, - {"VUID-vkCmdBlitImage-commandBuffer-01835", VALIDATION_ERROR_18400e56}, - {"VUID-vkCmdBlitImage-commandBuffer-01836", VALIDATION_ERROR_18400e58}, - {"VUID-vkCmdBlitImage-commandBuffer-parameter", VALIDATION_ERROR_18402401}, - {"VUID-vkCmdBlitImage-commandBuffer-recording", VALIDATION_ERROR_18402413}, - {"VUID-vkCmdBlitImage-commandBuffer-cmdpool", VALIDATION_ERROR_18402415}, - {"VUID-vkCmdBlitImage-dstImage-parameter", VALIDATION_ERROR_18407201}, - {"VUID-vkCmdBlitImage-dstImageLayout-parameter", VALIDATION_ERROR_18407401}, - {"VUID-vkCmdBlitImage-filter-parameter", VALIDATION_ERROR_18408c01}, - {"VUID-vkCmdBlitImage-pRegions-parameter", VALIDATION_ERROR_18421001}, - {"VUID-vkCmdBlitImage-regionCount-arraylength", VALIDATION_ERROR_1842ac1b}, - {"VUID-vkCmdBlitImage-srcImage-parameter", VALIDATION_ERROR_1842ce01}, - {"VUID-vkCmdBlitImage-srcImageLayout-parameter", VALIDATION_ERROR_1842d001}, - {"VUID-vkCmdClearAttachments-renderpass", VALIDATION_ERROR_18600017}, - {"VUID-vkCmdClearAttachments-aspectMask-00015", VALIDATION_ERROR_1860001e}, - {"VUID-vkCmdClearAttachments-pRects-00016", VALIDATION_ERROR_18600020}, - {"VUID-vkCmdClearAttachments-pRects-00017", VALIDATION_ERROR_18600022}, - {"VUID-vkCmdClearAttachments-baseArrayLayer-00018", VALIDATION_ERROR_18600024}, - {"VUID-vkCmdClearAttachments-attachmentCount-arraylength", VALIDATION_ERROR_18600e1b}, - {"VUID-vkCmdClearAttachments-layerCount-01934", VALIDATION_ERROR_18600f1c}, - {"VUID-vkCmdClearAttachments-commandBuffer-parameter", VALIDATION_ERROR_18602401}, - {"VUID-vkCmdClearAttachments-commandBuffer-recording", VALIDATION_ERROR_18602413}, - {"VUID-vkCmdClearAttachments-commandBuffer-cmdpool", VALIDATION_ERROR_18602415}, - {"VUID-vkCmdClearAttachments-pAttachments-parameter", VALIDATION_ERROR_1860f201}, - {"VUID-vkCmdClearAttachments-pRects-parameter", VALIDATION_ERROR_18620e01}, - {"VUID-vkCmdClearAttachments-rectCount-arraylength", VALIDATION_ERROR_1862aa1b}, - {"VUID-vkCmdClearColorImage-image-00001", VALIDATION_ERROR_18800002}, - {"VUID-vkCmdClearColorImage-image-00002", VALIDATION_ERROR_18800004}, - {"VUID-vkCmdClearColorImage-image-00003", VALIDATION_ERROR_18800006}, - {"VUID-vkCmdClearColorImage-imageLayout-00004", VALIDATION_ERROR_18800008}, - {"VUID-vkCmdClearColorImage-commonparent", VALIDATION_ERROR_18800009}, - {"VUID-vkCmdClearColorImage-imageLayout-00005", VALIDATION_ERROR_1880000a}, - {"VUID-vkCmdClearColorImage-image-00007", VALIDATION_ERROR_1880000e}, - {"VUID-vkCmdClearColorImage-renderpass", VALIDATION_ERROR_18800017}, - {"VUID-vkCmdClearColorImage-imageLayout-01394", VALIDATION_ERROR_18800ae4}, - {"VUID-vkCmdClearColorImage-baseMipLevel-01470", VALIDATION_ERROR_18800b7c}, - {"VUID-vkCmdClearColorImage-baseArrayLayer-01472", VALIDATION_ERROR_18800b80}, - {"VUID-vkCmdClearColorImage-image-01545", VALIDATION_ERROR_18800c12}, - {"VUID-vkCmdClearColorImage-pRanges-01692", VALIDATION_ERROR_18800d38}, - {"VUID-vkCmdClearColorImage-pRanges-01693", VALIDATION_ERROR_18800d3a}, - {"VUID-vkCmdClearColorImage-commandBuffer-01805", VALIDATION_ERROR_18800e1a}, - {"VUID-vkCmdClearColorImage-commandBuffer-01806", VALIDATION_ERROR_18800e1c}, - {"VUID-vkCmdClearColorImage-commandBuffer-parameter", VALIDATION_ERROR_18802401}, - {"VUID-vkCmdClearColorImage-commandBuffer-recording", VALIDATION_ERROR_18802413}, - {"VUID-vkCmdClearColorImage-commandBuffer-cmdpool", VALIDATION_ERROR_18802415}, - {"VUID-vkCmdClearColorImage-image-parameter", VALIDATION_ERROR_1880a001}, - {"VUID-vkCmdClearColorImage-imageLayout-parameter", VALIDATION_ERROR_1880a601}, - {"VUID-vkCmdClearColorImage-pColor-parameter", VALIDATION_ERROR_18810e01}, - {"VUID-vkCmdClearColorImage-pRanges-parameter", VALIDATION_ERROR_18820601}, - {"VUID-vkCmdClearColorImage-rangeCount-arraylength", VALIDATION_ERROR_1882a41b}, - {"VUID-vkCmdClearDepthStencilImage-commonparent", VALIDATION_ERROR_18a00009}, - {"VUID-vkCmdClearDepthStencilImage-image-00008", VALIDATION_ERROR_18a00010}, - {"VUID-vkCmdClearDepthStencilImage-image-00009", VALIDATION_ERROR_18a00012}, - {"VUID-vkCmdClearDepthStencilImage-image-00010", VALIDATION_ERROR_18a00014}, - {"VUID-vkCmdClearDepthStencilImage-imageLayout-00011", VALIDATION_ERROR_18a00016}, - {"VUID-vkCmdClearDepthStencilImage-renderpass", VALIDATION_ERROR_18a00017}, - {"VUID-vkCmdClearDepthStencilImage-imageLayout-00012", VALIDATION_ERROR_18a00018}, - {"VUID-vkCmdClearDepthStencilImage-image-00014", VALIDATION_ERROR_18a0001c}, - {"VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474", VALIDATION_ERROR_18a00b84}, - {"VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476", VALIDATION_ERROR_18a00b88}, - {"VUID-vkCmdClearDepthStencilImage-pRanges-01694", VALIDATION_ERROR_18a00d3c}, - {"VUID-vkCmdClearDepthStencilImage-pRanges-01695", VALIDATION_ERROR_18a00d3e}, - {"VUID-vkCmdClearDepthStencilImage-commandBuffer-01807", VALIDATION_ERROR_18a00e1e}, - {"VUID-vkCmdClearDepthStencilImage-commandBuffer-01808", VALIDATION_ERROR_18a00e20}, - {"VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter", VALIDATION_ERROR_18a02401}, - {"VUID-vkCmdClearDepthStencilImage-commandBuffer-recording", VALIDATION_ERROR_18a02413}, - {"VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool", VALIDATION_ERROR_18a02415}, - {"VUID-vkCmdClearDepthStencilImage-image-parameter", VALIDATION_ERROR_18a0a001}, - {"VUID-vkCmdClearDepthStencilImage-imageLayout-parameter", VALIDATION_ERROR_18a0a601}, - {"VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter", VALIDATION_ERROR_18a12801}, - {"VUID-vkCmdClearDepthStencilImage-pRanges-parameter", VALIDATION_ERROR_18a20601}, - {"VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength", VALIDATION_ERROR_18a2a41b}, - {"VUID-vkCmdCopyBuffer-commonparent", VALIDATION_ERROR_18c00009}, - {"VUID-vkCmdCopyBuffer-renderpass", VALIDATION_ERROR_18c00017}, - {"VUID-vkCmdCopyBuffer-size-00112", VALIDATION_ERROR_18c000e0}, - {"VUID-vkCmdCopyBuffer-srcOffset-00113", VALIDATION_ERROR_18c000e2}, - {"VUID-vkCmdCopyBuffer-dstOffset-00114", VALIDATION_ERROR_18c000e4}, - {"VUID-vkCmdCopyBuffer-size-00115", VALIDATION_ERROR_18c000e6}, - {"VUID-vkCmdCopyBuffer-size-00116", VALIDATION_ERROR_18c000e8}, - {"VUID-vkCmdCopyBuffer-pRegions-00117", VALIDATION_ERROR_18c000ea}, - {"VUID-vkCmdCopyBuffer-srcBuffer-00118", VALIDATION_ERROR_18c000ec}, - {"VUID-vkCmdCopyBuffer-srcBuffer-00119", VALIDATION_ERROR_18c000ee}, - {"VUID-vkCmdCopyBuffer-dstBuffer-00120", VALIDATION_ERROR_18c000f0}, - {"VUID-vkCmdCopyBuffer-dstBuffer-00121", VALIDATION_ERROR_18c000f2}, - {"VUID-vkCmdCopyBuffer-commandBuffer-01822", VALIDATION_ERROR_18c00e3c}, - {"VUID-vkCmdCopyBuffer-commandBuffer-01823", VALIDATION_ERROR_18c00e3e}, - {"VUID-vkCmdCopyBuffer-commandBuffer-01824", VALIDATION_ERROR_18c00e40}, - {"VUID-vkCmdCopyBuffer-commandBuffer-parameter", VALIDATION_ERROR_18c02401}, - {"VUID-vkCmdCopyBuffer-commandBuffer-recording", VALIDATION_ERROR_18c02413}, - {"VUID-vkCmdCopyBuffer-commandBuffer-cmdpool", VALIDATION_ERROR_18c02415}, - {"VUID-vkCmdCopyBuffer-dstBuffer-parameter", VALIDATION_ERROR_18c06c01}, - {"VUID-vkCmdCopyBuffer-pRegions-parameter", VALIDATION_ERROR_18c21001}, - {"VUID-vkCmdCopyBuffer-regionCount-arraylength", VALIDATION_ERROR_18c2ac1b}, - {"VUID-vkCmdCopyBuffer-srcBuffer-parameter", VALIDATION_ERROR_18c2c801}, - {"VUID-vkCmdCopyBufferToImage-commonparent", VALIDATION_ERROR_18e00009}, - {"VUID-vkCmdCopyBufferToImage-renderpass", VALIDATION_ERROR_18e00017}, - {"VUID-vkCmdCopyBufferToImage-pRegions-00171", VALIDATION_ERROR_18e00156}, - {"VUID-vkCmdCopyBufferToImage-pRegions-00172", VALIDATION_ERROR_18e00158}, - {"VUID-vkCmdCopyBufferToImage-pRegions-00173", VALIDATION_ERROR_18e0015a}, - {"VUID-vkCmdCopyBufferToImage-srcBuffer-00174", VALIDATION_ERROR_18e0015c}, - {"VUID-vkCmdCopyBufferToImage-dstImage-00175", VALIDATION_ERROR_18e0015e}, - {"VUID-vkCmdCopyBufferToImage-srcBuffer-00176", VALIDATION_ERROR_18e00160}, - {"VUID-vkCmdCopyBufferToImage-dstImage-00177", VALIDATION_ERROR_18e00162}, - {"VUID-vkCmdCopyBufferToImage-dstImage-00178", VALIDATION_ERROR_18e00164}, - {"VUID-vkCmdCopyBufferToImage-dstImage-00179", VALIDATION_ERROR_18e00166}, - {"VUID-vkCmdCopyBufferToImage-dstImageLayout-00180", VALIDATION_ERROR_18e00168}, - {"VUID-vkCmdCopyBufferToImage-dstImageLayout-00181", VALIDATION_ERROR_18e0016a}, - {"VUID-vkCmdCopyBufferToImage-dstImageLayout-01396", VALIDATION_ERROR_18e00ae8}, - {"VUID-vkCmdCopyBufferToImage-imageSubresource-01701", VALIDATION_ERROR_18e00d4a}, - {"VUID-vkCmdCopyBufferToImage-imageSubresource-01702", VALIDATION_ERROR_18e00d4c}, - {"VUID-vkCmdCopyBufferToImage-imageOffset-01793", VALIDATION_ERROR_18e00e02}, - {"VUID-vkCmdCopyBufferToImage-commandBuffer-01828", VALIDATION_ERROR_18e00e48}, - {"VUID-vkCmdCopyBufferToImage-commandBuffer-01829", VALIDATION_ERROR_18e00e4a}, - {"VUID-vkCmdCopyBufferToImage-commandBuffer-01830", VALIDATION_ERROR_18e00e4c}, - {"VUID-vkCmdCopyBufferToImage-commandBuffer-parameter", VALIDATION_ERROR_18e02401}, - {"VUID-vkCmdCopyBufferToImage-commandBuffer-recording", VALIDATION_ERROR_18e02413}, - {"VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool", VALIDATION_ERROR_18e02415}, - {"VUID-vkCmdCopyBufferToImage-dstImage-parameter", VALIDATION_ERROR_18e07201}, - {"VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter", VALIDATION_ERROR_18e07401}, - {"VUID-vkCmdCopyBufferToImage-pRegions-parameter", VALIDATION_ERROR_18e21001}, - {"VUID-vkCmdCopyBufferToImage-regionCount-arraylength", VALIDATION_ERROR_18e2ac1b}, - {"VUID-vkCmdCopyBufferToImage-srcBuffer-parameter", VALIDATION_ERROR_18e2c801}, - {"VUID-vkCmdCopyImage-commonparent", VALIDATION_ERROR_19000009}, - {"VUID-vkCmdCopyImage-renderpass", VALIDATION_ERROR_19000017}, - {"VUID-vkCmdCopyImage-pRegions-00122", VALIDATION_ERROR_190000f4}, - {"VUID-vkCmdCopyImage-pRegions-00123", VALIDATION_ERROR_190000f6}, - {"VUID-vkCmdCopyImage-pRegions-00124", VALIDATION_ERROR_190000f8}, - {"VUID-vkCmdCopyImage-srcImage-00125", VALIDATION_ERROR_190000fa}, - {"VUID-vkCmdCopyImage-srcImage-00126", VALIDATION_ERROR_190000fc}, - {"VUID-vkCmdCopyImage-srcImage-00127", VALIDATION_ERROR_190000fe}, - {"VUID-vkCmdCopyImage-srcImageLayout-00128", VALIDATION_ERROR_19000100}, - {"VUID-vkCmdCopyImage-srcImageLayout-00129", VALIDATION_ERROR_19000102}, - {"VUID-vkCmdCopyImage-dstImage-00130", VALIDATION_ERROR_19000104}, - {"VUID-vkCmdCopyImage-dstImage-00131", VALIDATION_ERROR_19000106}, - {"VUID-vkCmdCopyImage-dstImage-00132", VALIDATION_ERROR_19000108}, - {"VUID-vkCmdCopyImage-dstImageLayout-00133", VALIDATION_ERROR_1900010a}, - {"VUID-vkCmdCopyImage-dstImageLayout-00134", VALIDATION_ERROR_1900010c}, - {"VUID-vkCmdCopyImage-srcImage-00135", VALIDATION_ERROR_1900010e}, - {"VUID-vkCmdCopyImage-srcImage-00136", VALIDATION_ERROR_19000110}, - {"VUID-vkCmdCopyImage-dstImageLayout-01395", VALIDATION_ERROR_19000ae6}, - {"VUID-vkCmdCopyImage-srcImage-01546", VALIDATION_ERROR_19000c14}, - {"VUID-vkCmdCopyImage-dstImage-01547", VALIDATION_ERROR_19000c16}, - {"VUID-vkCmdCopyImage-srcImage-01548", VALIDATION_ERROR_19000c18}, - {"VUID-vkCmdCopyImage-None-01549", VALIDATION_ERROR_19000c1a}, - {"VUID-vkCmdCopyImage-aspectMask-01550", VALIDATION_ERROR_19000c1c}, - {"VUID-vkCmdCopyImage-srcSubresource-01696", VALIDATION_ERROR_19000d40}, - {"VUID-vkCmdCopyImage-dstSubresource-01697", VALIDATION_ERROR_19000d42}, - {"VUID-vkCmdCopyImage-srcSubresource-01698", VALIDATION_ERROR_19000d44}, - {"VUID-vkCmdCopyImage-dstSubresource-01699", VALIDATION_ERROR_19000d46}, - {"VUID-vkCmdCopyImage-srcOffset-01783", VALIDATION_ERROR_19000dee}, - {"VUID-vkCmdCopyImage-dstOffset-01784", VALIDATION_ERROR_19000df0}, - {"VUID-vkCmdCopyImage-commandBuffer-01825", VALIDATION_ERROR_19000e42}, - {"VUID-vkCmdCopyImage-commandBuffer-01826", VALIDATION_ERROR_19000e44}, - {"VUID-vkCmdCopyImage-commandBuffer-01827", VALIDATION_ERROR_19000e46}, - {"VUID-vkCmdCopyImage-srcImageLayout-01917", VALIDATION_ERROR_19000efa}, - {"VUID-vkCmdCopyImage-commandBuffer-parameter", VALIDATION_ERROR_19002401}, - {"VUID-vkCmdCopyImage-commandBuffer-recording", VALIDATION_ERROR_19002413}, - {"VUID-vkCmdCopyImage-commandBuffer-cmdpool", VALIDATION_ERROR_19002415}, - {"VUID-vkCmdCopyImage-dstImage-parameter", VALIDATION_ERROR_19007201}, - {"VUID-vkCmdCopyImage-dstImageLayout-parameter", VALIDATION_ERROR_19007401}, - {"VUID-vkCmdCopyImage-pRegions-parameter", VALIDATION_ERROR_19021001}, - {"VUID-vkCmdCopyImage-regionCount-arraylength", VALIDATION_ERROR_1902ac1b}, - {"VUID-vkCmdCopyImage-srcImage-parameter", VALIDATION_ERROR_1902ce01}, - {"VUID-vkCmdCopyImage-srcImageLayout-parameter", VALIDATION_ERROR_1902d001}, - {"VUID-vkCmdCopyImageToBuffer-commonparent", VALIDATION_ERROR_19200009}, - {"VUID-vkCmdCopyImageToBuffer-renderpass", VALIDATION_ERROR_19200017}, - {"VUID-vkCmdCopyImageToBuffer-pRegions-00182", VALIDATION_ERROR_1920016c}, - {"VUID-vkCmdCopyImageToBuffer-pRegions-00183", VALIDATION_ERROR_1920016e}, - {"VUID-vkCmdCopyImageToBuffer-pRegions-00184", VALIDATION_ERROR_19200170}, - {"VUID-vkCmdCopyImageToBuffer-srcImage-00185", VALIDATION_ERROR_19200172}, - {"VUID-vkCmdCopyImageToBuffer-srcImage-00186", VALIDATION_ERROR_19200174}, - {"VUID-vkCmdCopyImageToBuffer-srcImage-00187", VALIDATION_ERROR_19200176}, - {"VUID-vkCmdCopyImageToBuffer-srcImage-00188", VALIDATION_ERROR_19200178}, - {"VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189", VALIDATION_ERROR_1920017a}, - {"VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190", VALIDATION_ERROR_1920017c}, - {"VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", VALIDATION_ERROR_1920017e}, - {"VUID-vkCmdCopyImageToBuffer-dstBuffer-00192", VALIDATION_ERROR_19200180}, - {"VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397", VALIDATION_ERROR_19200aea}, - {"VUID-vkCmdCopyImageToBuffer-imageSubresource-01703", VALIDATION_ERROR_19200d4e}, - {"VUID-vkCmdCopyImageToBuffer-imageSubresource-01704", VALIDATION_ERROR_19200d50}, - {"VUID-vkCmdCopyImageToBuffer-imageOffset-01794", VALIDATION_ERROR_19200e04}, - {"VUID-vkCmdCopyImageToBuffer-commandBuffer-01831", VALIDATION_ERROR_19200e4e}, - {"VUID-vkCmdCopyImageToBuffer-commandBuffer-01832", VALIDATION_ERROR_19200e50}, - {"VUID-vkCmdCopyImageToBuffer-commandBuffer-01833", VALIDATION_ERROR_19200e52}, - {"VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter", VALIDATION_ERROR_19202401}, - {"VUID-vkCmdCopyImageToBuffer-commandBuffer-recording", VALIDATION_ERROR_19202413}, - {"VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool", VALIDATION_ERROR_19202415}, - {"VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter", VALIDATION_ERROR_19206c01}, - {"VUID-vkCmdCopyImageToBuffer-pRegions-parameter", VALIDATION_ERROR_19221001}, - {"VUID-vkCmdCopyImageToBuffer-regionCount-arraylength", VALIDATION_ERROR_1922ac1b}, - {"VUID-vkCmdCopyImageToBuffer-srcImage-parameter", VALIDATION_ERROR_1922ce01}, - {"VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter", VALIDATION_ERROR_1922d001}, - {"VUID-vkCmdCopyQueryPoolResults-commonparent", VALIDATION_ERROR_19400009}, - {"VUID-vkCmdCopyQueryPoolResults-renderpass", VALIDATION_ERROR_19400017}, - {"VUID-vkCmdCopyQueryPoolResults-dstOffset-00819", VALIDATION_ERROR_19400666}, - {"VUID-vkCmdCopyQueryPoolResults-firstQuery-00820", VALIDATION_ERROR_19400668}, - {"VUID-vkCmdCopyQueryPoolResults-firstQuery-00821", VALIDATION_ERROR_1940066a}, - {"VUID-vkCmdCopyQueryPoolResults-flags-00822", VALIDATION_ERROR_1940066c}, - {"VUID-vkCmdCopyQueryPoolResults-flags-00823", VALIDATION_ERROR_1940066e}, - {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824", VALIDATION_ERROR_19400670}, - {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825", VALIDATION_ERROR_19400672}, - {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826", VALIDATION_ERROR_19400674}, - {"VUID-vkCmdCopyQueryPoolResults-queryType-00827", VALIDATION_ERROR_19400676}, - {"VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter", VALIDATION_ERROR_19402401}, - {"VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording", VALIDATION_ERROR_19402413}, - {"VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool", VALIDATION_ERROR_19402415}, - {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter", VALIDATION_ERROR_19406c01}, - {"VUID-vkCmdCopyQueryPoolResults-flags-parameter", VALIDATION_ERROR_19409001}, - {"VUID-vkCmdCopyQueryPoolResults-queryPool-parameter", VALIDATION_ERROR_19429801}, - {"VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter", VALIDATION_ERROR_19602401}, - {"VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording", VALIDATION_ERROR_19602413}, - {"VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-cmdpool", VALIDATION_ERROR_19602415}, - {"VUID-vkCmdDebugMarkerBeginEXT-pMarkerInfo-parameter", VALIDATION_ERROR_1961a601}, - {"VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239", VALIDATION_ERROR_198009ae}, - {"VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240", VALIDATION_ERROR_198009b0}, - {"VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter", VALIDATION_ERROR_19802401}, - {"VUID-vkCmdDebugMarkerEndEXT-commandBuffer-recording", VALIDATION_ERROR_19802413}, - {"VUID-vkCmdDebugMarkerEndEXT-commandBuffer-cmdpool", VALIDATION_ERROR_19802415}, - {"VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter", VALIDATION_ERROR_19a02401}, - {"VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-recording", VALIDATION_ERROR_19a02413}, - {"VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-cmdpool", VALIDATION_ERROR_19a02415}, - {"VUID-vkCmdDebugMarkerInsertEXT-pMarkerInfo-parameter", VALIDATION_ERROR_19a1a601}, - {"VUID-vkCmdDispatch-renderpass", VALIDATION_ERROR_19c00017}, - {"VUID-vkCmdDispatch-groupCountX-00386", VALIDATION_ERROR_19c00304}, - {"VUID-vkCmdDispatch-groupCountY-00387", VALIDATION_ERROR_19c00306}, - {"VUID-vkCmdDispatch-groupCountZ-00388", VALIDATION_ERROR_19c00308}, - {"VUID-vkCmdDispatch-None-00389", VALIDATION_ERROR_19c0030a}, - {"VUID-vkCmdDispatch-None-00390", VALIDATION_ERROR_19c0030c}, - {"VUID-vkCmdDispatch-None-00391", VALIDATION_ERROR_19c0030e}, - {"VUID-vkCmdDispatch-None-00392", VALIDATION_ERROR_19c00310}, - {"VUID-vkCmdDispatch-None-00393", VALIDATION_ERROR_19c00312}, - {"VUID-vkCmdDispatch-None-00394", VALIDATION_ERROR_19c00314}, - {"VUID-vkCmdDispatch-None-00395", VALIDATION_ERROR_19c00316}, - {"VUID-vkCmdDispatch-None-00396", VALIDATION_ERROR_19c00318}, - {"VUID-vkCmdDispatch-None-00397", VALIDATION_ERROR_19c0031a}, - {"VUID-vkCmdDispatch-linearTilingFeatures-00398", VALIDATION_ERROR_19c0031c}, - {"VUID-vkCmdDispatch-linearTilingFeatures-00399", VALIDATION_ERROR_19c0031e}, - {"VUID-vkCmdDispatch-None-00400", VALIDATION_ERROR_19c00320}, - {"VUID-vkCmdDispatch-commandBuffer-01844", VALIDATION_ERROR_19c00e68}, - {"VUID-vkCmdDispatch-commandBuffer-01845", VALIDATION_ERROR_19c00e6a}, - {"VUID-vkCmdDispatch-commandBuffer-01846", VALIDATION_ERROR_19c00e6c}, - {"VUID-vkCmdDispatch-commandBuffer-parameter", VALIDATION_ERROR_19c02401}, - {"VUID-vkCmdDispatch-commandBuffer-recording", VALIDATION_ERROR_19c02413}, - {"VUID-vkCmdDispatch-commandBuffer-cmdpool", VALIDATION_ERROR_19c02415}, - {"VUID-vkCmdDispatchBase-renderpass", VALIDATION_ERROR_19e00017}, - {"VUID-vkCmdDispatchBase-None-00420", VALIDATION_ERROR_19e00348}, - {"VUID-vkCmdDispatchBase-baseGroupX-00421", VALIDATION_ERROR_19e0034a}, - {"VUID-vkCmdDispatchBase-baseGroupX-00422", VALIDATION_ERROR_19e0034c}, - {"VUID-vkCmdDispatchBase-baseGroupZ-00423", VALIDATION_ERROR_19e0034e}, - {"VUID-vkCmdDispatchBase-groupCountX-00424", VALIDATION_ERROR_19e00350}, - {"VUID-vkCmdDispatchBase-groupCountY-00425", VALIDATION_ERROR_19e00352}, - {"VUID-vkCmdDispatchBase-groupCountZ-00426", VALIDATION_ERROR_19e00354}, - {"VUID-vkCmdDispatchBase-baseGroupX-00427", VALIDATION_ERROR_19e00356}, - {"VUID-vkCmdDispatchBase-commandBuffer-parameter", VALIDATION_ERROR_19e02401}, - {"VUID-vkCmdDispatchBase-commandBuffer-recording", VALIDATION_ERROR_19e02413}, - {"VUID-vkCmdDispatchBase-commandBuffer-cmdpool", VALIDATION_ERROR_19e02415}, - {"VUID-vkCmdDispatchIndirect-commonparent", VALIDATION_ERROR_1a000009}, - {"VUID-vkCmdDispatchIndirect-renderpass", VALIDATION_ERROR_1a000017}, - {"VUID-vkCmdDispatchIndirect-buffer-00401", VALIDATION_ERROR_1a000322}, - {"VUID-vkCmdDispatchIndirect-None-00402", VALIDATION_ERROR_1a000324}, - {"VUID-vkCmdDispatchIndirect-None-00403", VALIDATION_ERROR_1a000326}, - {"VUID-vkCmdDispatchIndirect-None-00404", VALIDATION_ERROR_1a000328}, - {"VUID-vkCmdDispatchIndirect-buffer-00405", VALIDATION_ERROR_1a00032a}, - {"VUID-vkCmdDispatchIndirect-offset-00406", VALIDATION_ERROR_1a00032c}, - {"VUID-vkCmdDispatchIndirect-offset-00407", VALIDATION_ERROR_1a00032e}, - {"VUID-vkCmdDispatchIndirect-None-00408", VALIDATION_ERROR_1a000330}, - {"VUID-vkCmdDispatchIndirect-None-00409", VALIDATION_ERROR_1a000332}, - {"VUID-vkCmdDispatchIndirect-None-00410", VALIDATION_ERROR_1a000334}, - {"VUID-vkCmdDispatchIndirect-None-00411", VALIDATION_ERROR_1a000336}, - {"VUID-vkCmdDispatchIndirect-None-00412", VALIDATION_ERROR_1a000338}, - {"VUID-vkCmdDispatchIndirect-None-00413", VALIDATION_ERROR_1a00033a}, - {"VUID-vkCmdDispatchIndirect-linearTilingFeatures-00414", VALIDATION_ERROR_1a00033c}, - {"VUID-vkCmdDispatchIndirect-linearTilingFeatures-00415", VALIDATION_ERROR_1a00033e}, - {"VUID-vkCmdDispatchIndirect-None-00416", VALIDATION_ERROR_1a000340}, - {"VUID-vkCmdDispatchIndirect-commandBuffer-01847", VALIDATION_ERROR_1a000e6e}, - {"VUID-vkCmdDispatchIndirect-commandBuffer-01848", VALIDATION_ERROR_1a000e70}, - {"VUID-vkCmdDispatchIndirect-commandBuffer-01849", VALIDATION_ERROR_1a000e72}, - {"VUID-vkCmdDispatchIndirect-buffer-parameter", VALIDATION_ERROR_1a001a01}, - {"VUID-vkCmdDispatchIndirect-commandBuffer-parameter", VALIDATION_ERROR_1a002401}, - {"VUID-vkCmdDispatchIndirect-commandBuffer-recording", VALIDATION_ERROR_1a002413}, - {"VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool", VALIDATION_ERROR_1a002415}, - {"VUID-vkCmdDraw-renderpass", VALIDATION_ERROR_1a200017}, - {"VUID-vkCmdDraw-renderPass-00435", VALIDATION_ERROR_1a200366}, - {"VUID-vkCmdDraw-subpass-00436", VALIDATION_ERROR_1a200368}, - {"VUID-vkCmdDraw-None-00437", VALIDATION_ERROR_1a20036a}, - {"VUID-vkCmdDraw-None-00438", VALIDATION_ERROR_1a20036c}, - {"VUID-vkCmdDraw-None-00439", VALIDATION_ERROR_1a20036e}, - {"VUID-vkCmdDraw-None-00440", VALIDATION_ERROR_1a200370}, - {"VUID-vkCmdDraw-None-00441", VALIDATION_ERROR_1a200372}, - {"VUID-vkCmdDraw-None-00442", VALIDATION_ERROR_1a200374}, - {"VUID-vkCmdDraw-None-00443", VALIDATION_ERROR_1a200376}, - {"VUID-vkCmdDraw-None-00444", VALIDATION_ERROR_1a200378}, - {"VUID-vkCmdDraw-None-00445", VALIDATION_ERROR_1a20037a}, - {"VUID-vkCmdDraw-None-00446", VALIDATION_ERROR_1a20037c}, - {"VUID-vkCmdDraw-None-00447", VALIDATION_ERROR_1a20037e}, - {"VUID-vkCmdDraw-None-00448", VALIDATION_ERROR_1a200380}, - {"VUID-vkCmdDraw-None-00449", VALIDATION_ERROR_1a200382}, - {"VUID-vkCmdDraw-linearTilingFeatures-00450", VALIDATION_ERROR_1a200384}, - {"VUID-vkCmdDraw-linearTilingFeatures-00451", VALIDATION_ERROR_1a200386}, - {"VUID-vkCmdDraw-None-00452", VALIDATION_ERROR_1a200388}, - {"VUID-vkCmdDraw-maxMultiviewInstanceIndex-00453", VALIDATION_ERROR_1a20038a}, - {"VUID-vkCmdDraw-None-01499", VALIDATION_ERROR_1a200bb6}, - {"VUID-vkCmdDraw-sampleLocationsEnable-01512", VALIDATION_ERROR_1a200bd0}, - {"VUID-vkCmdDraw-commandBuffer-01850", VALIDATION_ERROR_1a200e74}, - {"VUID-vkCmdDraw-commandBuffer-01851", VALIDATION_ERROR_1a200e76}, - {"VUID-vkCmdDraw-commandBuffer-01852", VALIDATION_ERROR_1a200e78}, - {"VUID-vkCmdDraw-commandBuffer-parameter", VALIDATION_ERROR_1a202401}, - {"VUID-vkCmdDraw-commandBuffer-recording", VALIDATION_ERROR_1a202413}, - {"VUID-vkCmdDraw-commandBuffer-cmdpool", VALIDATION_ERROR_1a202415}, - {"VUID-vkCmdDrawIndexed-renderpass", VALIDATION_ERROR_1a400017}, - {"VUID-vkCmdDrawIndexed-renderPass-00454", VALIDATION_ERROR_1a40038c}, - {"VUID-vkCmdDrawIndexed-subpass-00455", VALIDATION_ERROR_1a40038e}, - {"VUID-vkCmdDrawIndexed-None-00456", VALIDATION_ERROR_1a400390}, - {"VUID-vkCmdDrawIndexed-None-00457", VALIDATION_ERROR_1a400392}, - {"VUID-vkCmdDrawIndexed-None-00458", VALIDATION_ERROR_1a400394}, - {"VUID-vkCmdDrawIndexed-None-00459", VALIDATION_ERROR_1a400396}, - {"VUID-vkCmdDrawIndexed-None-00460", VALIDATION_ERROR_1a400398}, - {"VUID-vkCmdDrawIndexed-None-00461", VALIDATION_ERROR_1a40039a}, - {"VUID-vkCmdDrawIndexed-None-00462", VALIDATION_ERROR_1a40039c}, - {"VUID-vkCmdDrawIndexed-indexSize-00463", VALIDATION_ERROR_1a40039e}, - {"VUID-vkCmdDrawIndexed-None-00464", VALIDATION_ERROR_1a4003a0}, - {"VUID-vkCmdDrawIndexed-None-00465", VALIDATION_ERROR_1a4003a2}, - {"VUID-vkCmdDrawIndexed-None-00466", VALIDATION_ERROR_1a4003a4}, - {"VUID-vkCmdDrawIndexed-None-00467", VALIDATION_ERROR_1a4003a6}, - {"VUID-vkCmdDrawIndexed-None-00468", VALIDATION_ERROR_1a4003a8}, - {"VUID-vkCmdDrawIndexed-None-00469", VALIDATION_ERROR_1a4003aa}, - {"VUID-vkCmdDrawIndexed-linearTilingFeatures-00470", VALIDATION_ERROR_1a4003ac}, - {"VUID-vkCmdDrawIndexed-linearTilingFeatures-00471", VALIDATION_ERROR_1a4003ae}, - {"VUID-vkCmdDrawIndexed-None-00472", VALIDATION_ERROR_1a4003b0}, - {"VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-00473", VALIDATION_ERROR_1a4003b2}, - {"VUID-vkCmdDrawIndexed-None-01500", VALIDATION_ERROR_1a400bb8}, - {"VUID-vkCmdDrawIndexed-sampleLocationsEnable-01513", VALIDATION_ERROR_1a400bd2}, - {"VUID-vkCmdDrawIndexed-commandBuffer-01853", VALIDATION_ERROR_1a400e7a}, - {"VUID-vkCmdDrawIndexed-commandBuffer-01854", VALIDATION_ERROR_1a400e7c}, - {"VUID-vkCmdDrawIndexed-commandBuffer-01855", VALIDATION_ERROR_1a400e7e}, - {"VUID-vkCmdDrawIndexed-commandBuffer-parameter", VALIDATION_ERROR_1a402401}, - {"VUID-vkCmdDrawIndexed-commandBuffer-recording", VALIDATION_ERROR_1a402413}, - {"VUID-vkCmdDrawIndexed-commandBuffer-cmdpool", VALIDATION_ERROR_1a402415}, - {"VUID-vkCmdDrawIndexedIndirect-commonparent", VALIDATION_ERROR_1a600009}, - {"VUID-vkCmdDrawIndexedIndirect-renderpass", VALIDATION_ERROR_1a600017}, - {"VUID-vkCmdDrawIndexedIndirect-buffer-00526", VALIDATION_ERROR_1a60041c}, - {"VUID-vkCmdDrawIndexedIndirect-offset-00527", VALIDATION_ERROR_1a60041e}, - {"VUID-vkCmdDrawIndexedIndirect-drawCount-00528", VALIDATION_ERROR_1a600420}, - {"VUID-vkCmdDrawIndexedIndirect-drawCount-00529", VALIDATION_ERROR_1a600422}, - {"VUID-vkCmdDrawIndexedIndirect-firstInstance-00530", VALIDATION_ERROR_1a600424}, - {"VUID-vkCmdDrawIndexedIndirect-renderPass-00531", VALIDATION_ERROR_1a600426}, - {"VUID-vkCmdDrawIndexedIndirect-subpass-00532", VALIDATION_ERROR_1a600428}, - {"VUID-vkCmdDrawIndexedIndirect-None-00533", VALIDATION_ERROR_1a60042a}, - {"VUID-vkCmdDrawIndexedIndirect-None-00534", VALIDATION_ERROR_1a60042c}, - {"VUID-vkCmdDrawIndexedIndirect-None-00535", VALIDATION_ERROR_1a60042e}, - {"VUID-vkCmdDrawIndexedIndirect-None-00536", VALIDATION_ERROR_1a600430}, - {"VUID-vkCmdDrawIndexedIndirect-None-00537", VALIDATION_ERROR_1a600432}, - {"VUID-vkCmdDrawIndexedIndirect-None-00538", VALIDATION_ERROR_1a600434}, - {"VUID-vkCmdDrawIndexedIndirect-drawCount-00539", VALIDATION_ERROR_1a600436}, - {"VUID-vkCmdDrawIndexedIndirect-drawCount-00540", VALIDATION_ERROR_1a600438}, - {"VUID-vkCmdDrawIndexedIndirect-drawCount-00541", VALIDATION_ERROR_1a60043a}, - {"VUID-vkCmdDrawIndexedIndirect-None-00542", VALIDATION_ERROR_1a60043c}, - {"VUID-vkCmdDrawIndexedIndirect-None-00543", VALIDATION_ERROR_1a60043e}, - {"VUID-vkCmdDrawIndexedIndirect-None-00544", VALIDATION_ERROR_1a600440}, - {"VUID-vkCmdDrawIndexedIndirect-None-00545", VALIDATION_ERROR_1a600442}, - {"VUID-vkCmdDrawIndexedIndirect-None-00546", VALIDATION_ERROR_1a600444}, - {"VUID-vkCmdDrawIndexedIndirect-None-00547", VALIDATION_ERROR_1a600446}, - {"VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00548", VALIDATION_ERROR_1a600448}, - {"VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00549", VALIDATION_ERROR_1a60044a}, - {"VUID-vkCmdDrawIndexedIndirect-None-00550", VALIDATION_ERROR_1a60044c}, - {"VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-00551", VALIDATION_ERROR_1a60044e}, - {"VUID-vkCmdDrawIndexedIndirect-None-01503", VALIDATION_ERROR_1a600bbe}, - {"VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-01516", VALIDATION_ERROR_1a600bd8}, - {"VUID-vkCmdDrawIndexedIndirect-buffer-01665", VALIDATION_ERROR_1a600d02}, - {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-01862", VALIDATION_ERROR_1a600e8c}, - {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-01863", VALIDATION_ERROR_1a600e8e}, - {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-01864", VALIDATION_ERROR_1a600e90}, - {"VUID-vkCmdDrawIndexedIndirect-buffer-parameter", VALIDATION_ERROR_1a601a01}, - {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter", VALIDATION_ERROR_1a602401}, - {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording", VALIDATION_ERROR_1a602413}, - {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool", VALIDATION_ERROR_1a602415}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-commonparent", VALIDATION_ERROR_1a800009}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-renderpass", VALIDATION_ERROR_1a800017}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-offset-00555", VALIDATION_ERROR_1a800456}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-countBufferOffset-00556", VALIDATION_ERROR_1a800458}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-stride-00557", VALIDATION_ERROR_1a80045a}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-maxDrawCount-00558", VALIDATION_ERROR_1a80045c}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-firstInstance-00559", VALIDATION_ERROR_1a80045e}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-renderPass-00560", VALIDATION_ERROR_1a800460}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-subpass-00561", VALIDATION_ERROR_1a800462}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00562", VALIDATION_ERROR_1a800464}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00563", VALIDATION_ERROR_1a800466}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00564", VALIDATION_ERROR_1a800468}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00565", VALIDATION_ERROR_1a80046a}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00566", VALIDATION_ERROR_1a80046c}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00567", VALIDATION_ERROR_1a80046e}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00568", VALIDATION_ERROR_1a800470}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00569", VALIDATION_ERROR_1a800472}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-drawCount-00570", VALIDATION_ERROR_1a800474}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00571", VALIDATION_ERROR_1a800476}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00572", VALIDATION_ERROR_1a800478}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00573", VALIDATION_ERROR_1a80047a}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00574", VALIDATION_ERROR_1a80047c}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00575", VALIDATION_ERROR_1a80047e}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-00576", VALIDATION_ERROR_1a800480}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-linearTilingFeatures-00577", VALIDATION_ERROR_1a800482}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-maxMultiviewInstanceIndex-00578", VALIDATION_ERROR_1a800484}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-None-01504", VALIDATION_ERROR_1a800bc0}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-sampleLocationsEnable-01517", VALIDATION_ERROR_1a800bda}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01666", VALIDATION_ERROR_1a800d04}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01667", VALIDATION_ERROR_1a800d06}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01668", VALIDATION_ERROR_1a800d08}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01669", VALIDATION_ERROR_1a800d0a}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01865", VALIDATION_ERROR_1a800e92}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01866", VALIDATION_ERROR_1a800e94}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01867", VALIDATION_ERROR_1a800e96}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-parameter", VALIDATION_ERROR_1a801a01}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-parameter", VALIDATION_ERROR_1a802401}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-recording", VALIDATION_ERROR_1a802413}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-cmdpool", VALIDATION_ERROR_1a802415}, - {"VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-parameter", VALIDATION_ERROR_1a803401}, - {"VUID-vkCmdDrawIndirect-commonparent", VALIDATION_ERROR_1aa00009}, - {"VUID-vkCmdDrawIndirect-renderpass", VALIDATION_ERROR_1aa00017}, - {"VUID-vkCmdDrawIndirect-buffer-00474", VALIDATION_ERROR_1aa003b4}, - {"VUID-vkCmdDrawIndirect-offset-00475", VALIDATION_ERROR_1aa003b6}, - {"VUID-vkCmdDrawIndirect-drawCount-00476", VALIDATION_ERROR_1aa003b8}, - {"VUID-vkCmdDrawIndirect-drawCount-00477", VALIDATION_ERROR_1aa003ba}, - {"VUID-vkCmdDrawIndirect-firstInstance-00478", VALIDATION_ERROR_1aa003bc}, - {"VUID-vkCmdDrawIndirect-renderPass-00479", VALIDATION_ERROR_1aa003be}, - {"VUID-vkCmdDrawIndirect-subpass-00480", VALIDATION_ERROR_1aa003c0}, - {"VUID-vkCmdDrawIndirect-None-00481", VALIDATION_ERROR_1aa003c2}, - {"VUID-vkCmdDrawIndirect-None-00482", VALIDATION_ERROR_1aa003c4}, - {"VUID-vkCmdDrawIndirect-None-00483", VALIDATION_ERROR_1aa003c6}, - {"VUID-vkCmdDrawIndirect-None-00484", VALIDATION_ERROR_1aa003c8}, - {"VUID-vkCmdDrawIndirect-None-00485", VALIDATION_ERROR_1aa003ca}, - {"VUID-vkCmdDrawIndirect-None-00486", VALIDATION_ERROR_1aa003cc}, - {"VUID-vkCmdDrawIndirect-drawCount-00487", VALIDATION_ERROR_1aa003ce}, - {"VUID-vkCmdDrawIndirect-drawCount-00488", VALIDATION_ERROR_1aa003d0}, - {"VUID-vkCmdDrawIndirect-drawCount-00489", VALIDATION_ERROR_1aa003d2}, - {"VUID-vkCmdDrawIndirect-None-00490", VALIDATION_ERROR_1aa003d4}, - {"VUID-vkCmdDrawIndirect-None-00491", VALIDATION_ERROR_1aa003d6}, - {"VUID-vkCmdDrawIndirect-None-00492", VALIDATION_ERROR_1aa003d8}, - {"VUID-vkCmdDrawIndirect-None-00493", VALIDATION_ERROR_1aa003da}, - {"VUID-vkCmdDrawIndirect-None-00494", VALIDATION_ERROR_1aa003dc}, - {"VUID-vkCmdDrawIndirect-None-00495", VALIDATION_ERROR_1aa003de}, - {"VUID-vkCmdDrawIndirect-linearTilingFeatures-00496", VALIDATION_ERROR_1aa003e0}, - {"VUID-vkCmdDrawIndirect-linearTilingFeatures-00497", VALIDATION_ERROR_1aa003e2}, - {"VUID-vkCmdDrawIndirect-None-00498", VALIDATION_ERROR_1aa003e4}, - {"VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-00499", VALIDATION_ERROR_1aa003e6}, - {"VUID-vkCmdDrawIndirect-None-01501", VALIDATION_ERROR_1aa00bba}, - {"VUID-vkCmdDrawIndirect-sampleLocationsEnable-01514", VALIDATION_ERROR_1aa00bd4}, - {"VUID-vkCmdDrawIndirect-buffer-01660", VALIDATION_ERROR_1aa00cf8}, - {"VUID-vkCmdDrawIndirect-commandBuffer-01856", VALIDATION_ERROR_1aa00e80}, - {"VUID-vkCmdDrawIndirect-commandBuffer-01857", VALIDATION_ERROR_1aa00e82}, - {"VUID-vkCmdDrawIndirect-commandBuffer-01858", VALIDATION_ERROR_1aa00e84}, - {"VUID-vkCmdDrawIndirect-buffer-parameter", VALIDATION_ERROR_1aa01a01}, - {"VUID-vkCmdDrawIndirect-commandBuffer-parameter", VALIDATION_ERROR_1aa02401}, - {"VUID-vkCmdDrawIndirect-commandBuffer-recording", VALIDATION_ERROR_1aa02413}, - {"VUID-vkCmdDrawIndirect-commandBuffer-cmdpool", VALIDATION_ERROR_1aa02415}, - {"VUID-vkCmdDrawIndirectCountAMD-commonparent", VALIDATION_ERROR_1ac00009}, - {"VUID-vkCmdDrawIndirectCountAMD-renderpass", VALIDATION_ERROR_1ac00017}, - {"VUID-vkCmdDrawIndirectCountAMD-offset-00502", VALIDATION_ERROR_1ac003ec}, - {"VUID-vkCmdDrawIndirectCountAMD-countBufferOffset-00503", VALIDATION_ERROR_1ac003ee}, - {"VUID-vkCmdDrawIndirectCountAMD-stride-00504", VALIDATION_ERROR_1ac003f0}, - {"VUID-vkCmdDrawIndirectCountAMD-maxDrawCount-00505", VALIDATION_ERROR_1ac003f2}, - {"VUID-vkCmdDrawIndirectCountAMD-firstInstance-00506", VALIDATION_ERROR_1ac003f4}, - {"VUID-vkCmdDrawIndirectCountAMD-renderPass-00507", VALIDATION_ERROR_1ac003f6}, - {"VUID-vkCmdDrawIndirectCountAMD-subpass-00508", VALIDATION_ERROR_1ac003f8}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00509", VALIDATION_ERROR_1ac003fa}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00510", VALIDATION_ERROR_1ac003fc}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00511", VALIDATION_ERROR_1ac003fe}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00512", VALIDATION_ERROR_1ac00400}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00513", VALIDATION_ERROR_1ac00402}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00514", VALIDATION_ERROR_1ac00404}, - {"VUID-vkCmdDrawIndirectCountAMD-countBuffer-00515", VALIDATION_ERROR_1ac00406}, - {"VUID-vkCmdDrawIndirectCountAMD-countBuffer-00516", VALIDATION_ERROR_1ac00408}, - {"VUID-vkCmdDrawIndirectCountAMD-countBuffer-00517", VALIDATION_ERROR_1ac0040a}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00518", VALIDATION_ERROR_1ac0040c}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00519", VALIDATION_ERROR_1ac0040e}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00520", VALIDATION_ERROR_1ac00410}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00521", VALIDATION_ERROR_1ac00412}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00522", VALIDATION_ERROR_1ac00414}, - {"VUID-vkCmdDrawIndirectCountAMD-None-00523", VALIDATION_ERROR_1ac00416}, - {"VUID-vkCmdDrawIndirectCountAMD-linearTilingFeatures-00524", VALIDATION_ERROR_1ac00418}, - {"VUID-vkCmdDrawIndirectCountAMD-maxMultiviewInstanceIndex-00525", VALIDATION_ERROR_1ac0041a}, - {"VUID-vkCmdDrawIndirectCountAMD-None-01502", VALIDATION_ERROR_1ac00bbc}, - {"VUID-vkCmdDrawIndirectCountAMD-sampleLocationsEnable-01515", VALIDATION_ERROR_1ac00bd6}, - {"VUID-vkCmdDrawIndirectCountAMD-buffer-01661", VALIDATION_ERROR_1ac00cfa}, - {"VUID-vkCmdDrawIndirectCountAMD-buffer-01662", VALIDATION_ERROR_1ac00cfc}, - {"VUID-vkCmdDrawIndirectCountAMD-countBuffer-01663", VALIDATION_ERROR_1ac00cfe}, - {"VUID-vkCmdDrawIndirectCountAMD-countBuffer-01664", VALIDATION_ERROR_1ac00d00}, - {"VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01859", VALIDATION_ERROR_1ac00e86}, - {"VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01860", VALIDATION_ERROR_1ac00e88}, - {"VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01861", VALIDATION_ERROR_1ac00e8a}, - {"VUID-vkCmdDrawIndirectCountAMD-buffer-parameter", VALIDATION_ERROR_1ac01a01}, - {"VUID-vkCmdDrawIndirectCountAMD-commandBuffer-parameter", VALIDATION_ERROR_1ac02401}, - {"VUID-vkCmdDrawIndirectCountAMD-commandBuffer-recording", VALIDATION_ERROR_1ac02413}, - {"VUID-vkCmdDrawIndirectCountAMD-commandBuffer-cmdpool", VALIDATION_ERROR_1ac02415}, - {"VUID-vkCmdDrawIndirectCountAMD-countBuffer-parameter", VALIDATION_ERROR_1ac03401}, - {"VUID-vkCmdEndQuery-commonparent", VALIDATION_ERROR_1ae00009}, - {"VUID-vkCmdEndQuery-query-00810", VALIDATION_ERROR_1ae00654}, - {"VUID-vkCmdEndQuery-query-00812", VALIDATION_ERROR_1ae00658}, - {"VUID-vkCmdEndQuery-commandBuffer-01886", VALIDATION_ERROR_1ae00ebc}, - {"VUID-vkCmdEndQuery-None-01923", VALIDATION_ERROR_1ae00f06}, - {"VUID-vkCmdEndQuery-commandBuffer-parameter", VALIDATION_ERROR_1ae02401}, - {"VUID-vkCmdEndQuery-commandBuffer-recording", VALIDATION_ERROR_1ae02413}, - {"VUID-vkCmdEndQuery-commandBuffer-cmdpool", VALIDATION_ERROR_1ae02415}, - {"VUID-vkCmdEndQuery-queryPool-parameter", VALIDATION_ERROR_1ae29801}, - {"VUID-vkCmdEndRenderPass-renderpass", VALIDATION_ERROR_1b000017}, - {"VUID-vkCmdEndRenderPass-bufferlevel", VALIDATION_ERROR_1b000019}, - {"VUID-vkCmdEndRenderPass-None-00910", VALIDATION_ERROR_1b00071c}, - {"VUID-vkCmdEndRenderPass-commandBuffer-parameter", VALIDATION_ERROR_1b002401}, - {"VUID-vkCmdEndRenderPass-commandBuffer-recording", VALIDATION_ERROR_1b002413}, - {"VUID-vkCmdEndRenderPass-commandBuffer-cmdpool", VALIDATION_ERROR_1b002415}, - {"VUID-vkCmdExecuteCommands-commonparent", VALIDATION_ERROR_1b200009}, - {"VUID-vkCmdExecuteCommands-bufferlevel", VALIDATION_ERROR_1b200019}, - {"VUID-vkCmdExecuteCommands-commandBuffer-00087", VALIDATION_ERROR_1b2000ae}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00088", VALIDATION_ERROR_1b2000b0}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00089", VALIDATION_ERROR_1b2000b2}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00090", VALIDATION_ERROR_1b2000b4}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00091", VALIDATION_ERROR_1b2000b6}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00092", VALIDATION_ERROR_1b2000b8}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00093", VALIDATION_ERROR_1b2000ba}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00094", VALIDATION_ERROR_1b2000bc}, - {"VUID-vkCmdExecuteCommands-contents-00095", VALIDATION_ERROR_1b2000be}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00096", VALIDATION_ERROR_1b2000c0}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00097", VALIDATION_ERROR_1b2000c2}, - {"VUID-vkCmdExecuteCommands-pInheritanceInfo-00098", VALIDATION_ERROR_1b2000c4}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00099", VALIDATION_ERROR_1b2000c6}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00100", VALIDATION_ERROR_1b2000c8}, - {"VUID-vkCmdExecuteCommands-commandBuffer-00101", VALIDATION_ERROR_1b2000ca}, - {"VUID-vkCmdExecuteCommands-commandBuffer-00102", VALIDATION_ERROR_1b2000cc}, - {"VUID-vkCmdExecuteCommands-commandBuffer-00103", VALIDATION_ERROR_1b2000ce}, - {"VUID-vkCmdExecuteCommands-commandBuffer-00104", VALIDATION_ERROR_1b2000d0}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-00105", VALIDATION_ERROR_1b2000d2}, - {"VUID-vkCmdExecuteCommands-commandBuffer-01820", VALIDATION_ERROR_1b200e38}, - {"VUID-vkCmdExecuteCommands-commandBuffer-01821", VALIDATION_ERROR_1b200e3a}, - {"VUID-vkCmdExecuteCommands-commandBuffer-parameter", VALIDATION_ERROR_1b202401}, - {"VUID-vkCmdExecuteCommands-commandBuffer-recording", VALIDATION_ERROR_1b202413}, - {"VUID-vkCmdExecuteCommands-commandBuffer-cmdpool", VALIDATION_ERROR_1b202415}, - {"VUID-vkCmdExecuteCommands-commandBufferCount-arraylength", VALIDATION_ERROR_1b20261b}, - {"VUID-vkCmdExecuteCommands-pCommandBuffers-parameter", VALIDATION_ERROR_1b211401}, - {"VUID-vkCmdFillBuffer-commonparent", VALIDATION_ERROR_1b400009}, - {"VUID-vkCmdFillBuffer-renderpass", VALIDATION_ERROR_1b400017}, - {"VUID-vkCmdFillBuffer-dstOffset-00024", VALIDATION_ERROR_1b400030}, - {"VUID-vkCmdFillBuffer-dstOffset-00025", VALIDATION_ERROR_1b400032}, - {"VUID-vkCmdFillBuffer-size-00026", VALIDATION_ERROR_1b400034}, - {"VUID-vkCmdFillBuffer-size-00027", VALIDATION_ERROR_1b400036}, - {"VUID-vkCmdFillBuffer-size-00028", VALIDATION_ERROR_1b400038}, - {"VUID-vkCmdFillBuffer-dstBuffer-00029", VALIDATION_ERROR_1b40003a}, - {"VUID-vkCmdFillBuffer-commandBuffer-00030", VALIDATION_ERROR_1b40003c}, - {"VUID-vkCmdFillBuffer-dstBuffer-00031", VALIDATION_ERROR_1b40003e}, - {"VUID-vkCmdFillBuffer-commandBuffer-01811", VALIDATION_ERROR_1b400e26}, - {"VUID-vkCmdFillBuffer-commandBuffer-01812", VALIDATION_ERROR_1b400e28}, - {"VUID-vkCmdFillBuffer-commandBuffer-parameter", VALIDATION_ERROR_1b402401}, - {"VUID-vkCmdFillBuffer-commandBuffer-recording", VALIDATION_ERROR_1b402413}, - {"VUID-vkCmdFillBuffer-commandBuffer-cmdpool", VALIDATION_ERROR_1b402415}, - {"VUID-vkCmdFillBuffer-dstBuffer-parameter", VALIDATION_ERROR_1b406c01}, - {"VUID-vkCmdNextSubpass-renderpass", VALIDATION_ERROR_1b600017}, - {"VUID-vkCmdNextSubpass-bufferlevel", VALIDATION_ERROR_1b600019}, - {"VUID-vkCmdNextSubpass-None-00909", VALIDATION_ERROR_1b60071a}, - {"VUID-vkCmdNextSubpass-commandBuffer-parameter", VALIDATION_ERROR_1b602401}, - {"VUID-vkCmdNextSubpass-commandBuffer-recording", VALIDATION_ERROR_1b602413}, - {"VUID-vkCmdNextSubpass-commandBuffer-cmdpool", VALIDATION_ERROR_1b602415}, - {"VUID-vkCmdNextSubpass-contents-parameter", VALIDATION_ERROR_1b603201}, - {"VUID-vkCmdPipelineBarrier-srcStageMask-01168", VALIDATION_ERROR_1b800920}, - {"VUID-vkCmdPipelineBarrier-dstStageMask-01169", VALIDATION_ERROR_1b800922}, - {"VUID-vkCmdPipelineBarrier-srcStageMask-01170", VALIDATION_ERROR_1b800924}, - {"VUID-vkCmdPipelineBarrier-dstStageMask-01171", VALIDATION_ERROR_1b800926}, - {"VUID-vkCmdPipelineBarrier-pDependencies-01172", VALIDATION_ERROR_1b800928}, - {"VUID-vkCmdPipelineBarrier-srcStageMask-01173", VALIDATION_ERROR_1b80092a}, - {"VUID-vkCmdPipelineBarrier-dstStageMask-01174", VALIDATION_ERROR_1b80092c}, - {"VUID-vkCmdPipelineBarrier-srcAccessMask-01175", VALIDATION_ERROR_1b80092e}, - {"VUID-vkCmdPipelineBarrier-dstAccessMask-01176", VALIDATION_ERROR_1b800930}, - {"VUID-vkCmdPipelineBarrier-dependencyFlags-01177", VALIDATION_ERROR_1b800932}, - {"VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178", VALIDATION_ERROR_1b800934}, - {"VUID-vkCmdPipelineBarrier-image-01179", VALIDATION_ERROR_1b800936}, - {"VUID-vkCmdPipelineBarrier-oldLayout-01180", VALIDATION_ERROR_1b800938}, - {"VUID-vkCmdPipelineBarrier-oldLayout-01181", VALIDATION_ERROR_1b80093a}, - {"VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182", VALIDATION_ERROR_1b80093c}, - {"VUID-vkCmdPipelineBarrier-srcStageMask-01183", VALIDATION_ERROR_1b80093e}, - {"VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184", VALIDATION_ERROR_1b800940}, - {"VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185", VALIDATION_ERROR_1b800942}, - {"VUID-vkCmdPipelineBarrier-dependencyFlags-01186", VALIDATION_ERROR_1b800944}, - {"VUID-vkCmdPipelineBarrier-commandBuffer-parameter", VALIDATION_ERROR_1b802401}, - {"VUID-vkCmdPipelineBarrier-commandBuffer-recording", VALIDATION_ERROR_1b802413}, - {"VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool", VALIDATION_ERROR_1b802415}, - {"VUID-vkCmdPipelineBarrier-dependencyFlags-parameter", VALIDATION_ERROR_1b803e01}, - {"VUID-vkCmdPipelineBarrier-dstStageMask-parameter", VALIDATION_ERROR_1b807801}, - {"VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask", VALIDATION_ERROR_1b807803}, - {"VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter", VALIDATION_ERROR_1b810401}, - {"VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter", VALIDATION_ERROR_1b818a01}, - {"VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter", VALIDATION_ERROR_1b81ac01}, - {"VUID-vkCmdPipelineBarrier-srcStageMask-parameter", VALIDATION_ERROR_1b82d401}, - {"VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask", VALIDATION_ERROR_1b82d403}, - {"VUID-vkCmdProcessCommandsNVX-renderpass", VALIDATION_ERROR_1ba00017}, - {"VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter", VALIDATION_ERROR_1ba02401}, - {"VUID-vkCmdProcessCommandsNVX-commandBuffer-recording", VALIDATION_ERROR_1ba02413}, - {"VUID-vkCmdProcessCommandsNVX-commandBuffer-cmdpool", VALIDATION_ERROR_1ba02415}, - {"VUID-vkCmdProcessCommandsNVX-pProcessCommandsInfo-parameter", VALIDATION_ERROR_1ba1f201}, - {"VUID-vkCmdPushConstants-commonparent", VALIDATION_ERROR_1bc00009}, - {"VUID-vkCmdPushConstants-offset-00368", VALIDATION_ERROR_1bc002e0}, - {"VUID-vkCmdPushConstants-size-00369", VALIDATION_ERROR_1bc002e2}, - {"VUID-vkCmdPushConstants-offset-00370", VALIDATION_ERROR_1bc002e4}, - {"VUID-vkCmdPushConstants-size-00371", VALIDATION_ERROR_1bc002e6}, - {"VUID-vkCmdPushConstants-offset-01795", VALIDATION_ERROR_1bc00e06}, - {"VUID-vkCmdPushConstants-offset-01796", VALIDATION_ERROR_1bc00e08}, - {"VUID-vkCmdPushConstants-commandBuffer-parameter", VALIDATION_ERROR_1bc02401}, - {"VUID-vkCmdPushConstants-commandBuffer-recording", VALIDATION_ERROR_1bc02413}, - {"VUID-vkCmdPushConstants-commandBuffer-cmdpool", VALIDATION_ERROR_1bc02415}, - {"VUID-vkCmdPushConstants-layout-parameter", VALIDATION_ERROR_1bc0be01}, - {"VUID-vkCmdPushConstants-pValues-parameter", VALIDATION_ERROR_1bc26201}, - {"VUID-vkCmdPushConstants-size-arraylength", VALIDATION_ERROR_1bc2c21b}, - {"VUID-vkCmdPushConstants-stageFlags-parameter", VALIDATION_ERROR_1bc2dc01}, - {"VUID-vkCmdPushConstants-stageFlags-requiredbitmask", VALIDATION_ERROR_1bc2dc03}, - {"VUID-vkCmdPushDescriptorSetKHR-commonparent", VALIDATION_ERROR_1be00009}, - {"VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363", VALIDATION_ERROR_1be002d6}, - {"VUID-vkCmdPushDescriptorSetKHR-set-00364", VALIDATION_ERROR_1be002d8}, - {"VUID-vkCmdPushDescriptorSetKHR-set-00365", VALIDATION_ERROR_1be002da}, - {"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter", VALIDATION_ERROR_1be02401}, - {"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording", VALIDATION_ERROR_1be02413}, - {"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool", VALIDATION_ERROR_1be02415}, - {"VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength", VALIDATION_ERROR_1be0541b}, - {"VUID-vkCmdPushDescriptorSetKHR-layout-parameter", VALIDATION_ERROR_1be0be01}, - {"VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter", VALIDATION_ERROR_1be13601}, - {"VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter", VALIDATION_ERROR_1be27e01}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent", VALIDATION_ERROR_1c000009}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366", VALIDATION_ERROR_1c0002dc}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686", VALIDATION_ERROR_1c000d2c}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter", VALIDATION_ERROR_1c002401}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-recording", VALIDATION_ERROR_1c002413}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool", VALIDATION_ERROR_1c002415}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter", VALIDATION_ERROR_1c005201}, - {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter", VALIDATION_ERROR_1c00be01}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-renderpass", VALIDATION_ERROR_1c200017}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-bufferlevel", VALIDATION_ERROR_1c200019}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01329", VALIDATION_ERROR_1c200a62}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01330", VALIDATION_ERROR_1c200a64}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter", VALIDATION_ERROR_1c202401}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-recording", VALIDATION_ERROR_1c202413}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-cmdpool", VALIDATION_ERROR_1c202415}, - {"VUID-vkCmdReserveSpaceForCommandsNVX-pReserveSpaceInfo-parameter", VALIDATION_ERROR_1c221a01}, - {"VUID-vkCmdResetEvent-commonparent", VALIDATION_ERROR_1c400009}, - {"VUID-vkCmdResetEvent-renderpass", VALIDATION_ERROR_1c400017}, - {"VUID-vkCmdResetEvent-stageMask-01153", VALIDATION_ERROR_1c400902}, - {"VUID-vkCmdResetEvent-stageMask-01154", VALIDATION_ERROR_1c400904}, - {"VUID-vkCmdResetEvent-stageMask-01155", VALIDATION_ERROR_1c400906}, - {"VUID-vkCmdResetEvent-event-01156", VALIDATION_ERROR_1c400908}, - {"VUID-vkCmdResetEvent-commandBuffer-01157", VALIDATION_ERROR_1c40090a}, - {"VUID-vkCmdResetEvent-commandBuffer-parameter", VALIDATION_ERROR_1c402401}, - {"VUID-vkCmdResetEvent-commandBuffer-recording", VALIDATION_ERROR_1c402413}, - {"VUID-vkCmdResetEvent-commandBuffer-cmdpool", VALIDATION_ERROR_1c402415}, - {"VUID-vkCmdResetEvent-event-parameter", VALIDATION_ERROR_1c407e01}, - {"VUID-vkCmdResetEvent-stageMask-parameter", VALIDATION_ERROR_1c42de01}, - {"VUID-vkCmdResetEvent-stageMask-requiredbitmask", VALIDATION_ERROR_1c42de03}, - {"VUID-vkCmdResetQueryPool-commonparent", VALIDATION_ERROR_1c600009}, - {"VUID-vkCmdResetQueryPool-renderpass", VALIDATION_ERROR_1c600017}, - {"VUID-vkCmdResetQueryPool-firstQuery-00796", VALIDATION_ERROR_1c600638}, - {"VUID-vkCmdResetQueryPool-firstQuery-00797", VALIDATION_ERROR_1c60063a}, - {"VUID-vkCmdResetQueryPool-commandBuffer-parameter", VALIDATION_ERROR_1c602401}, - {"VUID-vkCmdResetQueryPool-commandBuffer-recording", VALIDATION_ERROR_1c602413}, - {"VUID-vkCmdResetQueryPool-commandBuffer-cmdpool", VALIDATION_ERROR_1c602415}, - {"VUID-vkCmdResetQueryPool-queryPool-parameter", VALIDATION_ERROR_1c629801}, - {"VUID-vkCmdResolveImage-commonparent", VALIDATION_ERROR_1c800009}, - {"VUID-vkCmdResolveImage-renderpass", VALIDATION_ERROR_1c800017}, - {"VUID-vkCmdResolveImage-pRegions-00253", VALIDATION_ERROR_1c8001fa}, - {"VUID-vkCmdResolveImage-pRegions-00254", VALIDATION_ERROR_1c8001fc}, - {"VUID-vkCmdResolveImage-pRegions-00255", VALIDATION_ERROR_1c8001fe}, - {"VUID-vkCmdResolveImage-srcImage-00256", VALIDATION_ERROR_1c800200}, - {"VUID-vkCmdResolveImage-srcImage-00257", VALIDATION_ERROR_1c800202}, - {"VUID-vkCmdResolveImage-dstImage-00258", VALIDATION_ERROR_1c800204}, - {"VUID-vkCmdResolveImage-dstImage-00259", VALIDATION_ERROR_1c800206}, - {"VUID-vkCmdResolveImage-srcImageLayout-00260", VALIDATION_ERROR_1c800208}, - {"VUID-vkCmdResolveImage-srcImageLayout-00261", VALIDATION_ERROR_1c80020a}, - {"VUID-vkCmdResolveImage-dstImageLayout-00262", VALIDATION_ERROR_1c80020c}, - {"VUID-vkCmdResolveImage-dstImageLayout-00263", VALIDATION_ERROR_1c80020e}, - {"VUID-vkCmdResolveImage-dstImage-00264", VALIDATION_ERROR_1c800210}, - {"VUID-vkCmdResolveImage-dstImage-00265", VALIDATION_ERROR_1c800212}, - {"VUID-vkCmdResolveImage-srcImage-01386", VALIDATION_ERROR_1c800ad4}, - {"VUID-vkCmdResolveImage-srcImageLayout-01400", VALIDATION_ERROR_1c800af0}, - {"VUID-vkCmdResolveImage-dstImageLayout-01401", VALIDATION_ERROR_1c800af2}, - {"VUID-vkCmdResolveImage-srcSubresource-01709", VALIDATION_ERROR_1c800d5a}, - {"VUID-vkCmdResolveImage-dstSubresource-01710", VALIDATION_ERROR_1c800d5c}, - {"VUID-vkCmdResolveImage-srcSubresource-01711", VALIDATION_ERROR_1c800d5e}, - {"VUID-vkCmdResolveImage-dstSubresource-01712", VALIDATION_ERROR_1c800d60}, - {"VUID-vkCmdResolveImage-commandBuffer-01837", VALIDATION_ERROR_1c800e5a}, - {"VUID-vkCmdResolveImage-commandBuffer-01838", VALIDATION_ERROR_1c800e5c}, - {"VUID-vkCmdResolveImage-commandBuffer-01839", VALIDATION_ERROR_1c800e5e}, - {"VUID-vkCmdResolveImage-commandBuffer-parameter", VALIDATION_ERROR_1c802401}, - {"VUID-vkCmdResolveImage-commandBuffer-recording", VALIDATION_ERROR_1c802413}, - {"VUID-vkCmdResolveImage-commandBuffer-cmdpool", VALIDATION_ERROR_1c802415}, - {"VUID-vkCmdResolveImage-dstImage-parameter", VALIDATION_ERROR_1c807201}, - {"VUID-vkCmdResolveImage-dstImageLayout-parameter", VALIDATION_ERROR_1c807401}, - {"VUID-vkCmdResolveImage-pRegions-parameter", VALIDATION_ERROR_1c821001}, - {"VUID-vkCmdResolveImage-regionCount-arraylength", VALIDATION_ERROR_1c82ac1b}, - {"VUID-vkCmdResolveImage-srcImage-parameter", VALIDATION_ERROR_1c82ce01}, - {"VUID-vkCmdResolveImage-srcImageLayout-parameter", VALIDATION_ERROR_1c82d001}, - {"VUID-vkCmdSetBlendConstants-None-00612", VALIDATION_ERROR_1ca004c8}, - {"VUID-vkCmdSetBlendConstants-commandBuffer-parameter", VALIDATION_ERROR_1ca02401}, - {"VUID-vkCmdSetBlendConstants-commandBuffer-recording", VALIDATION_ERROR_1ca02413}, - {"VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool", VALIDATION_ERROR_1ca02415}, - {"VUID-vkCmdSetDepthBias-None-00789", VALIDATION_ERROR_1cc0062a}, - {"VUID-vkCmdSetDepthBias-depthBiasClamp-00790", VALIDATION_ERROR_1cc0062c}, - {"VUID-vkCmdSetDepthBias-commandBuffer-parameter", VALIDATION_ERROR_1cc02401}, - {"VUID-vkCmdSetDepthBias-commandBuffer-recording", VALIDATION_ERROR_1cc02413}, - {"VUID-vkCmdSetDepthBias-commandBuffer-cmdpool", VALIDATION_ERROR_1cc02415}, - {"VUID-vkCmdSetDepthBounds-None-00599", VALIDATION_ERROR_1ce004ae}, - {"VUID-vkCmdSetDepthBounds-minDepthBounds-00600", VALIDATION_ERROR_1ce004b0}, - {"VUID-vkCmdSetDepthBounds-maxDepthBounds-00601", VALIDATION_ERROR_1ce004b2}, - {"VUID-vkCmdSetDepthBounds-commandBuffer-parameter", VALIDATION_ERROR_1ce02401}, - {"VUID-vkCmdSetDepthBounds-commandBuffer-recording", VALIDATION_ERROR_1ce02413}, - {"VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool", VALIDATION_ERROR_1ce02415}, - {"VUID-vkCmdSetDeviceMask-deviceMask-00108", VALIDATION_ERROR_1d0000d8}, - {"VUID-vkCmdSetDeviceMask-deviceMask-00109", VALIDATION_ERROR_1d0000da}, - {"VUID-vkCmdSetDeviceMask-deviceMask-00110", VALIDATION_ERROR_1d0000dc}, - {"VUID-vkCmdSetDeviceMask-deviceMask-00111", VALIDATION_ERROR_1d0000de}, - {"VUID-vkCmdSetDeviceMask-commandBuffer-parameter", VALIDATION_ERROR_1d002401}, - {"VUID-vkCmdSetDeviceMask-commandBuffer-recording", VALIDATION_ERROR_1d002413}, - {"VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool", VALIDATION_ERROR_1d002415}, - {"VUID-vkCmdSetDiscardRectangleEXT-None-00583", VALIDATION_ERROR_1d20048e}, - {"VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585", VALIDATION_ERROR_1d200492}, - {"VUID-vkCmdSetDiscardRectangleEXT-x-00587", VALIDATION_ERROR_1d200496}, - {"VUID-vkCmdSetDiscardRectangleEXT-offset-00588", VALIDATION_ERROR_1d200498}, - {"VUID-vkCmdSetDiscardRectangleEXT-offset-00589", VALIDATION_ERROR_1d20049a}, - {"VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter", VALIDATION_ERROR_1d202401}, - {"VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording", VALIDATION_ERROR_1d202413}, - {"VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool", VALIDATION_ERROR_1d202415}, - {"VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength", VALIDATION_ERROR_1d205c1b}, - {"VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter", VALIDATION_ERROR_1d214601}, - {"VUID-vkCmdSetEvent-commonparent", VALIDATION_ERROR_1d400009}, - {"VUID-vkCmdSetEvent-renderpass", VALIDATION_ERROR_1d400017}, - {"VUID-vkCmdSetEvent-stageMask-01149", VALIDATION_ERROR_1d4008fa}, - {"VUID-vkCmdSetEvent-stageMask-01150", VALIDATION_ERROR_1d4008fc}, - {"VUID-vkCmdSetEvent-stageMask-01151", VALIDATION_ERROR_1d4008fe}, - {"VUID-vkCmdSetEvent-commandBuffer-01152", VALIDATION_ERROR_1d400900}, - {"VUID-vkCmdSetEvent-commandBuffer-parameter", VALIDATION_ERROR_1d402401}, - {"VUID-vkCmdSetEvent-commandBuffer-recording", VALIDATION_ERROR_1d402413}, - {"VUID-vkCmdSetEvent-commandBuffer-cmdpool", VALIDATION_ERROR_1d402415}, - {"VUID-vkCmdSetEvent-event-parameter", VALIDATION_ERROR_1d407e01}, - {"VUID-vkCmdSetEvent-stageMask-parameter", VALIDATION_ERROR_1d42de01}, - {"VUID-vkCmdSetEvent-stageMask-requiredbitmask", VALIDATION_ERROR_1d42de03}, - {"VUID-vkCmdSetLineWidth-None-00787", VALIDATION_ERROR_1d600626}, - {"VUID-vkCmdSetLineWidth-lineWidth-00788", VALIDATION_ERROR_1d600628}, - {"VUID-vkCmdSetLineWidth-commandBuffer-parameter", VALIDATION_ERROR_1d602401}, - {"VUID-vkCmdSetLineWidth-commandBuffer-recording", VALIDATION_ERROR_1d602413}, - {"VUID-vkCmdSetLineWidth-commandBuffer-cmdpool", VALIDATION_ERROR_1d602415}, - {"VUID-vkCmdSetScissor-None-00590", VALIDATION_ERROR_1d80049c}, - {"VUID-vkCmdSetScissor-firstScissor-00591", VALIDATION_ERROR_1d80049e}, - {"VUID-vkCmdSetScissor-firstScissor-00592", VALIDATION_ERROR_1d8004a0}, - {"VUID-vkCmdSetScissor-firstScissor-00593", VALIDATION_ERROR_1d8004a2}, - {"VUID-vkCmdSetScissor-scissorCount-00594", VALIDATION_ERROR_1d8004a4}, - {"VUID-vkCmdSetScissor-x-00595", VALIDATION_ERROR_1d8004a6}, - {"VUID-vkCmdSetScissor-offset-00596", VALIDATION_ERROR_1d8004a8}, - {"VUID-vkCmdSetScissor-offset-00597", VALIDATION_ERROR_1d8004aa}, - {"VUID-vkCmdSetScissor-commandBuffer-parameter", VALIDATION_ERROR_1d802401}, - {"VUID-vkCmdSetScissor-commandBuffer-recording", VALIDATION_ERROR_1d802413}, - {"VUID-vkCmdSetScissor-commandBuffer-cmdpool", VALIDATION_ERROR_1d802415}, - {"VUID-vkCmdSetScissor-pScissors-parameter", VALIDATION_ERROR_1d822601}, - {"VUID-vkCmdSetScissor-scissorCount-arraylength", VALIDATION_ERROR_1d82b61b}, - {"VUID-vkCmdSetStencilCompareMask-None-00602", VALIDATION_ERROR_1da004b4}, - {"VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter", VALIDATION_ERROR_1da02401}, - {"VUID-vkCmdSetStencilCompareMask-commandBuffer-recording", VALIDATION_ERROR_1da02413}, - {"VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool", VALIDATION_ERROR_1da02415}, - {"VUID-vkCmdSetStencilCompareMask-faceMask-parameter", VALIDATION_ERROR_1da08401}, - {"VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask", VALIDATION_ERROR_1da08403}, - {"VUID-vkCmdSetStencilReference-None-00604", VALIDATION_ERROR_1dc004b8}, - {"VUID-vkCmdSetStencilReference-commandBuffer-parameter", VALIDATION_ERROR_1dc02401}, - {"VUID-vkCmdSetStencilReference-commandBuffer-recording", VALIDATION_ERROR_1dc02413}, - {"VUID-vkCmdSetStencilReference-commandBuffer-cmdpool", VALIDATION_ERROR_1dc02415}, - {"VUID-vkCmdSetStencilReference-faceMask-parameter", VALIDATION_ERROR_1dc08401}, - {"VUID-vkCmdSetStencilReference-faceMask-requiredbitmask", VALIDATION_ERROR_1dc08403}, - {"VUID-vkCmdSetStencilWriteMask-None-00603", VALIDATION_ERROR_1de004b6}, - {"VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter", VALIDATION_ERROR_1de02401}, - {"VUID-vkCmdSetStencilWriteMask-commandBuffer-recording", VALIDATION_ERROR_1de02413}, - {"VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool", VALIDATION_ERROR_1de02415}, - {"VUID-vkCmdSetStencilWriteMask-faceMask-parameter", VALIDATION_ERROR_1de08401}, - {"VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask", VALIDATION_ERROR_1de08403}, - {"VUID-vkCmdSetViewport-None-01221", VALIDATION_ERROR_1e00098a}, - {"VUID-vkCmdSetViewport-firstViewport-01222", VALIDATION_ERROR_1e00098c}, - {"VUID-vkCmdSetViewport-firstViewport-01223", VALIDATION_ERROR_1e00098e}, - {"VUID-vkCmdSetViewport-firstViewport-01224", VALIDATION_ERROR_1e000990}, - {"VUID-vkCmdSetViewport-viewportCount-01225", VALIDATION_ERROR_1e000992}, - {"VUID-vkCmdSetViewport-commandBuffer-parameter", VALIDATION_ERROR_1e002401}, - {"VUID-vkCmdSetViewport-commandBuffer-recording", VALIDATION_ERROR_1e002413}, - {"VUID-vkCmdSetViewport-commandBuffer-cmdpool", VALIDATION_ERROR_1e002415}, - {"VUID-vkCmdSetViewport-viewportCount-arraylength", VALIDATION_ERROR_1e030a1b}, - {"VUID-vkCmdSetViewport-pViewports-parameter", VALIDATION_ERROR_1e03fa01}, - {"VUID-vkCmdSetViewportWScalingNV-None-01322", VALIDATION_ERROR_1e200a54}, - {"VUID-vkCmdSetViewportWScalingNV-firstViewport-01323", VALIDATION_ERROR_1e200a56}, - {"VUID-vkCmdSetViewportWScalingNV-firstViewport-01324", VALIDATION_ERROR_1e200a58}, - {"VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter", VALIDATION_ERROR_1e202401}, - {"VUID-vkCmdSetViewportWScalingNV-commandBuffer-recording", VALIDATION_ERROR_1e202413}, - {"VUID-vkCmdSetViewportWScalingNV-commandBuffer-cmdpool", VALIDATION_ERROR_1e202415}, - {"VUID-vkCmdSetViewportWScalingNV-viewportCount-arraylength", VALIDATION_ERROR_1e230a1b}, - {"VUID-vkCmdSetViewportWScalingNV-pViewportWScalings-parameter", VALIDATION_ERROR_1e23fc01}, - {"VUID-vkCmdUpdateBuffer-commonparent", VALIDATION_ERROR_1e400009}, - {"VUID-vkCmdUpdateBuffer-renderpass", VALIDATION_ERROR_1e400017}, - {"VUID-vkCmdUpdateBuffer-dstOffset-00032", VALIDATION_ERROR_1e400040}, - {"VUID-vkCmdUpdateBuffer-dataSize-00033", VALIDATION_ERROR_1e400042}, - {"VUID-vkCmdUpdateBuffer-dstBuffer-00034", VALIDATION_ERROR_1e400044}, - {"VUID-vkCmdUpdateBuffer-dstBuffer-00035", VALIDATION_ERROR_1e400046}, - {"VUID-vkCmdUpdateBuffer-dstOffset-00036", VALIDATION_ERROR_1e400048}, - {"VUID-vkCmdUpdateBuffer-dataSize-00037", VALIDATION_ERROR_1e40004a}, - {"VUID-vkCmdUpdateBuffer-dataSize-00038", VALIDATION_ERROR_1e40004c}, - {"VUID-vkCmdUpdateBuffer-commandBuffer-01813", VALIDATION_ERROR_1e400e2a}, - {"VUID-vkCmdUpdateBuffer-commandBuffer-01814", VALIDATION_ERROR_1e400e2c}, - {"VUID-vkCmdUpdateBuffer-commandBuffer-parameter", VALIDATION_ERROR_1e402401}, - {"VUID-vkCmdUpdateBuffer-commandBuffer-recording", VALIDATION_ERROR_1e402413}, - {"VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool", VALIDATION_ERROR_1e402415}, - {"VUID-vkCmdUpdateBuffer-dataSize-arraylength", VALIDATION_ERROR_1e403c1b}, - {"VUID-vkCmdUpdateBuffer-dstBuffer-parameter", VALIDATION_ERROR_1e406c01}, - {"VUID-vkCmdUpdateBuffer-pData-parameter", VALIDATION_ERROR_1e412201}, - {"VUID-vkCmdWaitEvents-commonparent", VALIDATION_ERROR_1e600009}, - {"VUID-vkCmdWaitEvents-srcStageMask-01158", VALIDATION_ERROR_1e60090c}, - {"VUID-vkCmdWaitEvents-srcStageMask-01159", VALIDATION_ERROR_1e60090e}, - {"VUID-vkCmdWaitEvents-dstStageMask-01160", VALIDATION_ERROR_1e600910}, - {"VUID-vkCmdWaitEvents-srcStageMask-01161", VALIDATION_ERROR_1e600912}, - {"VUID-vkCmdWaitEvents-dstStageMask-01162", VALIDATION_ERROR_1e600914}, - {"VUID-vkCmdWaitEvents-pEvents-01163", VALIDATION_ERROR_1e600916}, - {"VUID-vkCmdWaitEvents-srcStageMask-01164", VALIDATION_ERROR_1e600918}, - {"VUID-vkCmdWaitEvents-pMemoryBarriers-01165", VALIDATION_ERROR_1e60091a}, - {"VUID-vkCmdWaitEvents-pMemoryBarriers-01166", VALIDATION_ERROR_1e60091c}, - {"VUID-vkCmdWaitEvents-commandBuffer-01167", VALIDATION_ERROR_1e60091e}, - {"VUID-vkCmdWaitEvents-commandBuffer-parameter", VALIDATION_ERROR_1e602401}, - {"VUID-vkCmdWaitEvents-commandBuffer-recording", VALIDATION_ERROR_1e602413}, - {"VUID-vkCmdWaitEvents-commandBuffer-cmdpool", VALIDATION_ERROR_1e602415}, - {"VUID-vkCmdWaitEvents-dstStageMask-parameter", VALIDATION_ERROR_1e607801}, - {"VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask", VALIDATION_ERROR_1e607803}, - {"VUID-vkCmdWaitEvents-eventCount-arraylength", VALIDATION_ERROR_1e60801b}, - {"VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter", VALIDATION_ERROR_1e610401}, - {"VUID-vkCmdWaitEvents-pEvents-parameter", VALIDATION_ERROR_1e616001}, - {"VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter", VALIDATION_ERROR_1e618a01}, - {"VUID-vkCmdWaitEvents-pMemoryBarriers-parameter", VALIDATION_ERROR_1e61ac01}, - {"VUID-vkCmdWaitEvents-srcStageMask-parameter", VALIDATION_ERROR_1e62d401}, - {"VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask", VALIDATION_ERROR_1e62d403}, - {"VUID-vkCmdWriteTimestamp-commonparent", VALIDATION_ERROR_1e800009}, - {"VUID-vkCmdWriteTimestamp-queryPool-00828", VALIDATION_ERROR_1e800678}, - {"VUID-vkCmdWriteTimestamp-timestampValidBits-00829", VALIDATION_ERROR_1e80067a}, - {"VUID-vkCmdWriteTimestamp-None-00830", VALIDATION_ERROR_1e80067c}, - {"VUID-vkCmdWriteTimestamp-query-00831", VALIDATION_ERROR_1e80067e}, - {"VUID-vkCmdWriteTimestamp-queryPool-01416", VALIDATION_ERROR_1e800b10}, - {"VUID-vkCmdWriteTimestamp-commandBuffer-parameter", VALIDATION_ERROR_1e802401}, - {"VUID-vkCmdWriteTimestamp-commandBuffer-recording", VALIDATION_ERROR_1e802413}, - {"VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool", VALIDATION_ERROR_1e802415}, - {"VUID-vkCmdWriteTimestamp-pipelineStage-parameter", VALIDATION_ERROR_1e828401}, - {"VUID-vkCmdWriteTimestamp-queryPool-parameter", VALIDATION_ERROR_1e829801}, - {"VUID-vkCreateAndroidSurfaceKHR-instance-parameter", VALIDATION_ERROR_1ea0bc01}, - {"VUID-vkCreateAndroidSurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_1ea0ec01}, - {"VUID-vkCreateAndroidSurfaceKHR-pCreateInfo-parameter", VALIDATION_ERROR_1ea11e01}, - {"VUID-vkCreateAndroidSurfaceKHR-pSurface-parameter", VALIDATION_ERROR_1ea24801}, - {"VUID-vkCreateBuffer-flags-00911", VALIDATION_ERROR_1ec0071e}, - {"VUID-vkCreateBuffer-device-parameter", VALIDATION_ERROR_1ec05601}, - {"VUID-vkCreateBuffer-pAllocator-parameter", VALIDATION_ERROR_1ec0ec01}, - {"VUID-vkCreateBuffer-pBuffer-parameter", VALIDATION_ERROR_1ec10001}, - {"VUID-vkCreateBuffer-pCreateInfo-parameter", VALIDATION_ERROR_1ec11e01}, - {"VUID-vkCreateBufferView-device-parameter", VALIDATION_ERROR_1ee05601}, - {"VUID-vkCreateBufferView-pAllocator-parameter", VALIDATION_ERROR_1ee0ec01}, - {"VUID-vkCreateBufferView-pCreateInfo-parameter", VALIDATION_ERROR_1ee11e01}, - {"VUID-vkCreateBufferView-pView-parameter", VALIDATION_ERROR_1ee26a01}, - {"VUID-vkCreateCommandPool-device-parameter", VALIDATION_ERROR_1f005601}, - {"VUID-vkCreateCommandPool-pAllocator-parameter", VALIDATION_ERROR_1f00ec01}, - {"VUID-vkCreateCommandPool-pCommandPool-parameter", VALIDATION_ERROR_1f011601}, - {"VUID-vkCreateCommandPool-pCreateInfo-parameter", VALIDATION_ERROR_1f011e01}, - {"VUID-vkCreateComputePipelines-flags-00695", VALIDATION_ERROR_1f20056e}, - {"VUID-vkCreateComputePipelines-flags-00696", VALIDATION_ERROR_1f200570}, - {"VUID-vkCreateComputePipelines-createInfoCount-arraylength", VALIDATION_ERROR_1f20381b}, - {"VUID-vkCreateComputePipelines-device-parameter", VALIDATION_ERROR_1f205601}, - {"VUID-vkCreateComputePipelines-pAllocator-parameter", VALIDATION_ERROR_1f20ec01}, - {"VUID-vkCreateComputePipelines-pCreateInfos-parameter", VALIDATION_ERROR_1f212001}, - {"VUID-vkCreateComputePipelines-pPipelines-parameter", VALIDATION_ERROR_1f21e201}, - {"VUID-vkCreateComputePipelines-pipelineCache-parameter", VALIDATION_ERROR_1f228001}, - {"VUID-vkCreateComputePipelines-pipelineCache-parent", VALIDATION_ERROR_1f228007}, - {"VUID-vkCreateDebugReportCallbackEXT-instance-parameter", VALIDATION_ERROR_1f40bc01}, - {"VUID-vkCreateDebugReportCallbackEXT-pAllocator-parameter", VALIDATION_ERROR_1f40ec01}, - {"VUID-vkCreateDebugReportCallbackEXT-pCallback-parameter", VALIDATION_ERROR_1f410801}, - {"VUID-vkCreateDebugReportCallbackEXT-pCreateInfo-parameter", VALIDATION_ERROR_1f411e01}, - {"VUID-vkCreateDescriptorPool-device-parameter", VALIDATION_ERROR_1f605601}, - {"VUID-vkCreateDescriptorPool-pAllocator-parameter", VALIDATION_ERROR_1f60ec01}, - {"VUID-vkCreateDescriptorPool-pCreateInfo-parameter", VALIDATION_ERROR_1f611e01}, - {"VUID-vkCreateDescriptorPool-pDescriptorPool-parameter", VALIDATION_ERROR_1f612e01}, - {"VUID-vkCreateDescriptorSetLayout-device-parameter", VALIDATION_ERROR_1f805601}, - {"VUID-vkCreateDescriptorSetLayout-pAllocator-parameter", VALIDATION_ERROR_1f80ec01}, - {"VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter", VALIDATION_ERROR_1f811e01}, - {"VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter", VALIDATION_ERROR_1f822a01}, - {"VUID-vkCreateDescriptorUpdateTemplate-device-parameter", VALIDATION_ERROR_1fa05601}, - {"VUID-vkCreateDescriptorUpdateTemplate-pAllocator-parameter", VALIDATION_ERROR_1fa0ec01}, - {"VUID-vkCreateDescriptorUpdateTemplate-pCreateInfo-parameter", VALIDATION_ERROR_1fa11e01}, - {"VUID-vkCreateDescriptorUpdateTemplate-pDescriptorUpdateTemplate-parameter", VALIDATION_ERROR_1fa13401}, - {"VUID-vkCreateDevice-ppEnabledExtensionNames-01387", VALIDATION_ERROR_1fc00ad6}, - {"VUID-vkCreateDevice-pAllocator-parameter", VALIDATION_ERROR_1fc0ec01}, - {"VUID-vkCreateDevice-pCreateInfo-parameter", VALIDATION_ERROR_1fc11e01}, - {"VUID-vkCreateDevice-pDevice-parameter", VALIDATION_ERROR_1fc13801}, - {"VUID-vkCreateDevice-physicalDevice-parameter", VALIDATION_ERROR_1fc27a01}, - {"VUID-vkCreateDisplayModeKHR-display-parameter", VALIDATION_ERROR_1fe06001}, - {"VUID-vkCreateDisplayModeKHR-pAllocator-parameter", VALIDATION_ERROR_1fe0ec01}, - {"VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter", VALIDATION_ERROR_1fe11e01}, - {"VUID-vkCreateDisplayModeKHR-pMode-parameter", VALIDATION_ERROR_1fe1bc01}, - {"VUID-vkCreateDisplayModeKHR-physicalDevice-parameter", VALIDATION_ERROR_1fe27a01}, - {"VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter", VALIDATION_ERROR_2000bc01}, - {"VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_2000ec01}, - {"VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter", VALIDATION_ERROR_20011e01}, - {"VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter", VALIDATION_ERROR_20024801}, - {"VUID-vkCreateEvent-device-parameter", VALIDATION_ERROR_20205601}, - {"VUID-vkCreateEvent-pAllocator-parameter", VALIDATION_ERROR_2020ec01}, - {"VUID-vkCreateEvent-pCreateInfo-parameter", VALIDATION_ERROR_20211e01}, - {"VUID-vkCreateEvent-pEvent-parameter", VALIDATION_ERROR_20215e01}, - {"VUID-vkCreateFence-device-parameter", VALIDATION_ERROR_20405601}, - {"VUID-vkCreateFence-pAllocator-parameter", VALIDATION_ERROR_2040ec01}, - {"VUID-vkCreateFence-pCreateInfo-parameter", VALIDATION_ERROR_20411e01}, - {"VUID-vkCreateFence-pFence-parameter", VALIDATION_ERROR_20417001}, - {"VUID-vkCreateFramebuffer-device-parameter", VALIDATION_ERROR_20605601}, - {"VUID-vkCreateFramebuffer-pAllocator-parameter", VALIDATION_ERROR_2060ec01}, - {"VUID-vkCreateFramebuffer-pCreateInfo-parameter", VALIDATION_ERROR_20611e01}, - {"VUID-vkCreateFramebuffer-pFramebuffer-parameter", VALIDATION_ERROR_20617801}, - {"VUID-vkCreateGraphicsPipelines-flags-00720", VALIDATION_ERROR_208005a0}, - {"VUID-vkCreateGraphicsPipelines-flags-00721", VALIDATION_ERROR_208005a2}, - {"VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength", VALIDATION_ERROR_2080381b}, - {"VUID-vkCreateGraphicsPipelines-device-parameter", VALIDATION_ERROR_20805601}, - {"VUID-vkCreateGraphicsPipelines-pAllocator-parameter", VALIDATION_ERROR_2080ec01}, - {"VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter", VALIDATION_ERROR_20812001}, - {"VUID-vkCreateGraphicsPipelines-pPipelines-parameter", VALIDATION_ERROR_2081e201}, - {"VUID-vkCreateGraphicsPipelines-pipelineCache-parameter", VALIDATION_ERROR_20828001}, - {"VUID-vkCreateGraphicsPipelines-pipelineCache-parent", VALIDATION_ERROR_20828007}, - {"VUID-vkCreateIOSSurfaceMVK-instance-parameter", VALIDATION_ERROR_20a0bc01}, - {"VUID-vkCreateIOSSurfaceMVK-pAllocator-parameter", VALIDATION_ERROR_20a0ec01}, - {"VUID-vkCreateIOSSurfaceMVK-pCreateInfo-parameter", VALIDATION_ERROR_20a11e01}, - {"VUID-vkCreateIOSSurfaceMVK-pSurface-parameter", VALIDATION_ERROR_20a24801}, - {"VUID-vkCreateImage-flags-00939", VALIDATION_ERROR_20c00756}, - {"VUID-vkCreateImage-device-parameter", VALIDATION_ERROR_20c05601}, - {"VUID-vkCreateImage-pAllocator-parameter", VALIDATION_ERROR_20c0ec01}, - {"VUID-vkCreateImage-pCreateInfo-parameter", VALIDATION_ERROR_20c11e01}, - {"VUID-vkCreateImage-pImage-parameter", VALIDATION_ERROR_20c17e01}, - {"VUID-vkCreateImageView-device-parameter", VALIDATION_ERROR_20e05601}, - {"VUID-vkCreateImageView-pAllocator-parameter", VALIDATION_ERROR_20e0ec01}, - {"VUID-vkCreateImageView-pCreateInfo-parameter", VALIDATION_ERROR_20e11e01}, - {"VUID-vkCreateImageView-pView-parameter", VALIDATION_ERROR_20e26a01}, - {"VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter", VALIDATION_ERROR_21005601}, - {"VUID-vkCreateIndirectCommandsLayoutNVX-pAllocator-parameter", VALIDATION_ERROR_2100ec01}, - {"VUID-vkCreateIndirectCommandsLayoutNVX-pCreateInfo-parameter", VALIDATION_ERROR_21011e01}, - {"VUID-vkCreateIndirectCommandsLayoutNVX-pIndirectCommandsLayout-parameter", VALIDATION_ERROR_21019201}, - {"VUID-vkCreateInstance-ppEnabledExtensionNames-01388", VALIDATION_ERROR_21200ad8}, - {"VUID-vkCreateInstance-pAllocator-parameter", VALIDATION_ERROR_2120ec01}, - {"VUID-vkCreateInstance-pCreateInfo-parameter", VALIDATION_ERROR_21211e01}, - {"VUID-vkCreateInstance-pInstance-parameter", VALIDATION_ERROR_21219c01}, - {"VUID-vkCreateMacOSSurfaceMVK-instance-parameter", VALIDATION_ERROR_2140bc01}, - {"VUID-vkCreateMacOSSurfaceMVK-pAllocator-parameter", VALIDATION_ERROR_2140ec01}, - {"VUID-vkCreateMacOSSurfaceMVK-pCreateInfo-parameter", VALIDATION_ERROR_21411e01}, - {"VUID-vkCreateMacOSSurfaceMVK-pSurface-parameter", VALIDATION_ERROR_21424801}, - {"VUID-vkCreateMirSurfaceKHR-instance-parameter", VALIDATION_ERROR_2160bc01}, - {"VUID-vkCreateMirSurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_2160ec01}, - {"VUID-vkCreateMirSurfaceKHR-pCreateInfo-parameter", VALIDATION_ERROR_21611e01}, - {"VUID-vkCreateMirSurfaceKHR-pSurface-parameter", VALIDATION_ERROR_21624801}, - {"VUID-vkCreateObjectTableNVX-device-parameter", VALIDATION_ERROR_21805601}, - {"VUID-vkCreateObjectTableNVX-pAllocator-parameter", VALIDATION_ERROR_2180ec01}, - {"VUID-vkCreateObjectTableNVX-pCreateInfo-parameter", VALIDATION_ERROR_21811e01}, - {"VUID-vkCreateObjectTableNVX-pObjectTable-parameter", VALIDATION_ERROR_2181d001}, - {"VUID-vkCreatePipelineCache-device-parameter", VALIDATION_ERROR_21a05601}, - {"VUID-vkCreatePipelineCache-pAllocator-parameter", VALIDATION_ERROR_21a0ec01}, - {"VUID-vkCreatePipelineCache-pCreateInfo-parameter", VALIDATION_ERROR_21a11e01}, - {"VUID-vkCreatePipelineCache-pPipelineCache-parameter", VALIDATION_ERROR_21a1de01}, - {"VUID-vkCreatePipelineLayout-device-parameter", VALIDATION_ERROR_21c05601}, - {"VUID-vkCreatePipelineLayout-pAllocator-parameter", VALIDATION_ERROR_21c0ec01}, - {"VUID-vkCreatePipelineLayout-pCreateInfo-parameter", VALIDATION_ERROR_21c11e01}, - {"VUID-vkCreatePipelineLayout-pPipelineLayout-parameter", VALIDATION_ERROR_21c1e001}, - {"VUID-vkCreateQueryPool-device-parameter", VALIDATION_ERROR_21e05601}, - {"VUID-vkCreateQueryPool-pAllocator-parameter", VALIDATION_ERROR_21e0ec01}, - {"VUID-vkCreateQueryPool-pCreateInfo-parameter", VALIDATION_ERROR_21e11e01}, - {"VUID-vkCreateQueryPool-pQueryPool-parameter", VALIDATION_ERROR_21e1fa01}, - {"VUID-vkCreateRenderPass-device-parameter", VALIDATION_ERROR_22005601}, - {"VUID-vkCreateRenderPass-pAllocator-parameter", VALIDATION_ERROR_2200ec01}, - {"VUID-vkCreateRenderPass-pCreateInfo-parameter", VALIDATION_ERROR_22011e01}, - {"VUID-vkCreateRenderPass-pRenderPass-parameter", VALIDATION_ERROR_22021601}, - {"VUID-vkCreateSampler-device-parameter", VALIDATION_ERROR_22205601}, - {"VUID-vkCreateSampler-pAllocator-parameter", VALIDATION_ERROR_2220ec01}, - {"VUID-vkCreateSampler-pCreateInfo-parameter", VALIDATION_ERROR_22211e01}, - {"VUID-vkCreateSampler-pSampler-parameter", VALIDATION_ERROR_22222401}, - {"VUID-vkCreateSemaphore-device-parameter", VALIDATION_ERROR_22405601}, - {"VUID-vkCreateSemaphore-pAllocator-parameter", VALIDATION_ERROR_2240ec01}, - {"VUID-vkCreateSemaphore-pCreateInfo-parameter", VALIDATION_ERROR_22411e01}, - {"VUID-vkCreateSemaphore-pSemaphore-parameter", VALIDATION_ERROR_22422801}, - {"VUID-vkCreateShaderModule-device-parameter", VALIDATION_ERROR_22605601}, - {"VUID-vkCreateShaderModule-pAllocator-parameter", VALIDATION_ERROR_2260ec01}, - {"VUID-vkCreateShaderModule-pCreateInfo-parameter", VALIDATION_ERROR_22611e01}, - {"VUID-vkCreateShaderModule-pShaderModule-parameter", VALIDATION_ERROR_22622e01}, - {"VUID-vkCreateSharedSwapchainsKHR-device-parameter", VALIDATION_ERROR_22805601}, - {"VUID-vkCreateSharedSwapchainsKHR-pAllocator-parameter", VALIDATION_ERROR_2280ec01}, - {"VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter", VALIDATION_ERROR_22812001}, - {"VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter", VALIDATION_ERROR_22825801}, - {"VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength", VALIDATION_ERROR_2282f21b}, - {"VUID-vkCreateSwapchainKHR-device-parameter", VALIDATION_ERROR_22a05601}, - {"VUID-vkCreateSwapchainKHR-pAllocator-parameter", VALIDATION_ERROR_22a0ec01}, - {"VUID-vkCreateSwapchainKHR-pCreateInfo-parameter", VALIDATION_ERROR_22a11e01}, - {"VUID-vkCreateSwapchainKHR-pSwapchain-parameter", VALIDATION_ERROR_22a25201}, - {"VUID-vkCreateViSurfaceNN-instance-parameter", VALIDATION_ERROR_22c0bc01}, - {"VUID-vkCreateViSurfaceNN-pAllocator-parameter", VALIDATION_ERROR_22c0ec01}, - {"VUID-vkCreateViSurfaceNN-pCreateInfo-parameter", VALIDATION_ERROR_22c11e01}, - {"VUID-vkCreateViSurfaceNN-pSurface-parameter", VALIDATION_ERROR_22c24801}, - {"VUID-vkCreateWaylandSurfaceKHR-instance-parameter", VALIDATION_ERROR_22e0bc01}, - {"VUID-vkCreateWaylandSurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_22e0ec01}, - {"VUID-vkCreateWaylandSurfaceKHR-pCreateInfo-parameter", VALIDATION_ERROR_22e11e01}, - {"VUID-vkCreateWaylandSurfaceKHR-pSurface-parameter", VALIDATION_ERROR_22e24801}, - {"VUID-vkCreateWin32SurfaceKHR-instance-parameter", VALIDATION_ERROR_2300bc01}, - {"VUID-vkCreateWin32SurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_2300ec01}, - {"VUID-vkCreateWin32SurfaceKHR-pCreateInfo-parameter", VALIDATION_ERROR_23011e01}, - {"VUID-vkCreateWin32SurfaceKHR-pSurface-parameter", VALIDATION_ERROR_23024801}, - {"VUID-vkCreateXcbSurfaceKHR-instance-parameter", VALIDATION_ERROR_2320bc01}, - {"VUID-vkCreateXcbSurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_2320ec01}, - {"VUID-vkCreateXcbSurfaceKHR-pCreateInfo-parameter", VALIDATION_ERROR_23211e01}, - {"VUID-vkCreateXcbSurfaceKHR-pSurface-parameter", VALIDATION_ERROR_23224801}, - {"VUID-vkCreateXlibSurfaceKHR-instance-parameter", VALIDATION_ERROR_2340bc01}, - {"VUID-vkCreateXlibSurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_2340ec01}, - {"VUID-vkCreateXlibSurfaceKHR-pCreateInfo-parameter", VALIDATION_ERROR_23411e01}, - {"VUID-vkCreateXlibSurfaceKHR-pSurface-parameter", VALIDATION_ERROR_23424801}, - {"VUID-vkDebugMarkerSetObjectNameEXT-device-parameter", VALIDATION_ERROR_23605601}, - {"VUID-vkDebugMarkerSetObjectNameEXT-pNameInfo-parameter", VALIDATION_ERROR_2361c201}, - {"VUID-vkDebugMarkerSetObjectTagEXT-device-parameter", VALIDATION_ERROR_23805601}, - {"VUID-vkDebugMarkerSetObjectTagEXT-pTagInfo-parameter", VALIDATION_ERROR_23825c01}, - {"VUID-vkDebugReportMessageEXT-object-01241", VALIDATION_ERROR_23a009b2}, - {"VUID-vkDebugReportMessageEXT-objectType-01498", VALIDATION_ERROR_23a00bb4}, - {"VUID-vkDebugReportMessageEXT-flags-parameter", VALIDATION_ERROR_23a09001}, - {"VUID-vkDebugReportMessageEXT-flags-requiredbitmask", VALIDATION_ERROR_23a09003}, - {"VUID-vkDebugReportMessageEXT-instance-parameter", VALIDATION_ERROR_23a0bc01}, - {"VUID-vkDebugReportMessageEXT-objectType-parameter", VALIDATION_ERROR_23a0da01}, - {"VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter", VALIDATION_ERROR_23a1a001}, - {"VUID-vkDebugReportMessageEXT-pMessage-parameter", VALIDATION_ERROR_23a1b801}, - {"VUID-vkDestroyBuffer-buffer-00922", VALIDATION_ERROR_23c00734}, - {"VUID-vkDestroyBuffer-buffer-00923", VALIDATION_ERROR_23c00736}, - {"VUID-vkDestroyBuffer-buffer-00924", VALIDATION_ERROR_23c00738}, - {"VUID-vkDestroyBuffer-buffer-parameter", VALIDATION_ERROR_23c01a01}, - {"VUID-vkDestroyBuffer-buffer-parent", VALIDATION_ERROR_23c01a07}, - {"VUID-vkDestroyBuffer-device-parameter", VALIDATION_ERROR_23c05601}, - {"VUID-vkDestroyBuffer-pAllocator-parameter", VALIDATION_ERROR_23c0ec01}, - {"VUID-vkDestroyBufferView-bufferView-00936", VALIDATION_ERROR_23e00750}, - {"VUID-vkDestroyBufferView-bufferView-00937", VALIDATION_ERROR_23e00752}, - {"VUID-vkDestroyBufferView-bufferView-00938", VALIDATION_ERROR_23e00754}, - {"VUID-vkDestroyBufferView-bufferView-parameter", VALIDATION_ERROR_23e01c01}, - {"VUID-vkDestroyBufferView-bufferView-parent", VALIDATION_ERROR_23e01c07}, - {"VUID-vkDestroyBufferView-device-parameter", VALIDATION_ERROR_23e05601}, - {"VUID-vkDestroyBufferView-pAllocator-parameter", VALIDATION_ERROR_23e0ec01}, - {"VUID-vkDestroyCommandPool-commandPool-00041", VALIDATION_ERROR_24000052}, - {"VUID-vkDestroyCommandPool-commandPool-00042", VALIDATION_ERROR_24000054}, - {"VUID-vkDestroyCommandPool-commandPool-00043", VALIDATION_ERROR_24000056}, - {"VUID-vkDestroyCommandPool-commandPool-parameter", VALIDATION_ERROR_24002801}, - {"VUID-vkDestroyCommandPool-commandPool-parent", VALIDATION_ERROR_24002807}, - {"VUID-vkDestroyCommandPool-device-parameter", VALIDATION_ERROR_24005601}, - {"VUID-vkDestroyCommandPool-pAllocator-parameter", VALIDATION_ERROR_2400ec01}, - {"VUID-vkDestroyDebugReportCallbackEXT-instance-01242", VALIDATION_ERROR_242009b4}, - {"VUID-vkDestroyDebugReportCallbackEXT-instance-01243", VALIDATION_ERROR_242009b6}, - {"VUID-vkDestroyDebugReportCallbackEXT-callback-parameter", VALIDATION_ERROR_24201e01}, - {"VUID-vkDestroyDebugReportCallbackEXT-callback-parent", VALIDATION_ERROR_24201e07}, - {"VUID-vkDestroyDebugReportCallbackEXT-instance-parameter", VALIDATION_ERROR_2420bc01}, - {"VUID-vkDestroyDebugReportCallbackEXT-pAllocator-parameter", VALIDATION_ERROR_2420ec01}, - {"VUID-vkDestroyDescriptorPool-descriptorPool-00303", VALIDATION_ERROR_2440025e}, - {"VUID-vkDestroyDescriptorPool-descriptorPool-00304", VALIDATION_ERROR_24400260}, - {"VUID-vkDestroyDescriptorPool-descriptorPool-00305", VALIDATION_ERROR_24400262}, - {"VUID-vkDestroyDescriptorPool-descriptorPool-parameter", VALIDATION_ERROR_24404601}, - {"VUID-vkDestroyDescriptorPool-descriptorPool-parent", VALIDATION_ERROR_24404607}, - {"VUID-vkDestroyDescriptorPool-device-parameter", VALIDATION_ERROR_24405601}, - {"VUID-vkDestroyDescriptorPool-pAllocator-parameter", VALIDATION_ERROR_2440ec01}, - {"VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284", VALIDATION_ERROR_24600238}, - {"VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285", VALIDATION_ERROR_2460023a}, - {"VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter", VALIDATION_ERROR_24604c01}, - {"VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent", VALIDATION_ERROR_24604c07}, - {"VUID-vkDestroyDescriptorSetLayout-device-parameter", VALIDATION_ERROR_24605601}, - {"VUID-vkDestroyDescriptorSetLayout-pAllocator-parameter", VALIDATION_ERROR_2460ec01}, - {"VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", VALIDATION_ERROR_248002c8}, - {"VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357", VALIDATION_ERROR_248002ca}, - {"VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter", VALIDATION_ERROR_24805201}, - {"VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent", VALIDATION_ERROR_24805207}, - {"VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", VALIDATION_ERROR_24805601}, - {"VUID-vkDestroyDescriptorUpdateTemplate-pAllocator-parameter", VALIDATION_ERROR_2480ec01}, - {"VUID-vkDestroyDevice-device-00378", VALIDATION_ERROR_24a002f4}, - {"VUID-vkDestroyDevice-device-00379", VALIDATION_ERROR_24a002f6}, - {"VUID-vkDestroyDevice-device-00380", VALIDATION_ERROR_24a002f8}, - {"VUID-vkDestroyDevice-device-parameter", VALIDATION_ERROR_24a05601}, - {"VUID-vkDestroyDevice-pAllocator-parameter", VALIDATION_ERROR_24a0ec01}, - {"VUID-vkDestroyEvent-event-01145", VALIDATION_ERROR_24c008f2}, - {"VUID-vkDestroyEvent-event-01146", VALIDATION_ERROR_24c008f4}, - {"VUID-vkDestroyEvent-event-01147", VALIDATION_ERROR_24c008f6}, - {"VUID-vkDestroyEvent-device-parameter", VALIDATION_ERROR_24c05601}, - {"VUID-vkDestroyEvent-event-parameter", VALIDATION_ERROR_24c07e01}, - {"VUID-vkDestroyEvent-event-parent", VALIDATION_ERROR_24c07e07}, - {"VUID-vkDestroyEvent-pAllocator-parameter", VALIDATION_ERROR_24c0ec01}, - {"VUID-vkDestroyFence-fence-01120", VALIDATION_ERROR_24e008c0}, - {"VUID-vkDestroyFence-fence-01121", VALIDATION_ERROR_24e008c2}, - {"VUID-vkDestroyFence-fence-01122", VALIDATION_ERROR_24e008c4}, - {"VUID-vkDestroyFence-device-parameter", VALIDATION_ERROR_24e05601}, - {"VUID-vkDestroyFence-fence-parameter", VALIDATION_ERROR_24e08801}, - {"VUID-vkDestroyFence-fence-parent", VALIDATION_ERROR_24e08807}, - {"VUID-vkDestroyFence-pAllocator-parameter", VALIDATION_ERROR_24e0ec01}, - {"VUID-vkDestroyFramebuffer-framebuffer-00892", VALIDATION_ERROR_250006f8}, - {"VUID-vkDestroyFramebuffer-framebuffer-00893", VALIDATION_ERROR_250006fa}, - {"VUID-vkDestroyFramebuffer-framebuffer-00894", VALIDATION_ERROR_250006fc}, - {"VUID-vkDestroyFramebuffer-device-parameter", VALIDATION_ERROR_25005601}, - {"VUID-vkDestroyFramebuffer-framebuffer-parameter", VALIDATION_ERROR_25009401}, - {"VUID-vkDestroyFramebuffer-framebuffer-parent", VALIDATION_ERROR_25009407}, - {"VUID-vkDestroyFramebuffer-pAllocator-parameter", VALIDATION_ERROR_2500ec01}, - {"VUID-vkDestroyImage-image-01000", VALIDATION_ERROR_252007d0}, - {"VUID-vkDestroyImage-image-01001", VALIDATION_ERROR_252007d2}, - {"VUID-vkDestroyImage-image-01002", VALIDATION_ERROR_252007d4}, - {"VUID-vkDestroyImage-device-parameter", VALIDATION_ERROR_25205601}, - {"VUID-vkDestroyImage-image-parameter", VALIDATION_ERROR_2520a001}, - {"VUID-vkDestroyImage-image-parent", VALIDATION_ERROR_2520a007}, - {"VUID-vkDestroyImage-pAllocator-parameter", VALIDATION_ERROR_2520ec01}, - {"VUID-vkDestroyImageView-imageView-01026", VALIDATION_ERROR_25400804}, - {"VUID-vkDestroyImageView-imageView-01027", VALIDATION_ERROR_25400806}, - {"VUID-vkDestroyImageView-imageView-01028", VALIDATION_ERROR_25400808}, - {"VUID-vkDestroyImageView-device-parameter", VALIDATION_ERROR_25405601}, - {"VUID-vkDestroyImageView-imageView-parameter", VALIDATION_ERROR_2540b001}, - {"VUID-vkDestroyImageView-imageView-parent", VALIDATION_ERROR_2540b007}, - {"VUID-vkDestroyImageView-pAllocator-parameter", VALIDATION_ERROR_2540ec01}, - {"VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-01352", VALIDATION_ERROR_25600a90}, - {"VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01353", VALIDATION_ERROR_25600a92}, - {"VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01354", VALIDATION_ERROR_25600a94}, - {"VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter", VALIDATION_ERROR_25605601}, - {"VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter", VALIDATION_ERROR_2560b401}, - {"VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent", VALIDATION_ERROR_2560b407}, - {"VUID-vkDestroyIndirectCommandsLayoutNVX-pAllocator-parameter", VALIDATION_ERROR_2560ec01}, - {"VUID-vkDestroyInstance-instance-00629", VALIDATION_ERROR_258004ea}, - {"VUID-vkDestroyInstance-instance-00630", VALIDATION_ERROR_258004ec}, - {"VUID-vkDestroyInstance-instance-00631", VALIDATION_ERROR_258004ee}, - {"VUID-vkDestroyInstance-instance-parameter", VALIDATION_ERROR_2580bc01}, - {"VUID-vkDestroyInstance-pAllocator-parameter", VALIDATION_ERROR_2580ec01}, - {"VUID-vkDestroyObjectTableNVX-objectTable-01361", VALIDATION_ERROR_25a00aa2}, - {"VUID-vkDestroyObjectTableNVX-objectTable-01362", VALIDATION_ERROR_25a00aa4}, - {"VUID-vkDestroyObjectTableNVX-objectTable-01363", VALIDATION_ERROR_25a00aa6}, - {"VUID-vkDestroyObjectTableNVX-device-parameter", VALIDATION_ERROR_25a05601}, - {"VUID-vkDestroyObjectTableNVX-objectTable-parameter", VALIDATION_ERROR_25a0d801}, - {"VUID-vkDestroyObjectTableNVX-objectTable-parent", VALIDATION_ERROR_25a0d807}, - {"VUID-vkDestroyObjectTableNVX-pAllocator-parameter", VALIDATION_ERROR_25a0ec01}, - {"VUID-vkDestroyPipeline-pipeline-00765", VALIDATION_ERROR_25c005fa}, - {"VUID-vkDestroyPipeline-pipeline-00766", VALIDATION_ERROR_25c005fc}, - {"VUID-vkDestroyPipeline-pipeline-00767", VALIDATION_ERROR_25c005fe}, - {"VUID-vkDestroyPipeline-device-parameter", VALIDATION_ERROR_25c05601}, - {"VUID-vkDestroyPipeline-pAllocator-parameter", VALIDATION_ERROR_25c0ec01}, - {"VUID-vkDestroyPipeline-pipeline-parameter", VALIDATION_ERROR_25c27c01}, - {"VUID-vkDestroyPipeline-pipeline-parent", VALIDATION_ERROR_25c27c07}, - {"VUID-vkDestroyPipelineCache-pipelineCache-00771", VALIDATION_ERROR_25e00606}, - {"VUID-vkDestroyPipelineCache-pipelineCache-00772", VALIDATION_ERROR_25e00608}, - {"VUID-vkDestroyPipelineCache-device-parameter", VALIDATION_ERROR_25e05601}, - {"VUID-vkDestroyPipelineCache-pAllocator-parameter", VALIDATION_ERROR_25e0ec01}, - {"VUID-vkDestroyPipelineCache-pipelineCache-parameter", VALIDATION_ERROR_25e28001}, - {"VUID-vkDestroyPipelineCache-pipelineCache-parent", VALIDATION_ERROR_25e28007}, - {"VUID-vkDestroyPipelineLayout-pipelineLayout-00299", VALIDATION_ERROR_26000256}, - {"VUID-vkDestroyPipelineLayout-pipelineLayout-00300", VALIDATION_ERROR_26000258}, - {"VUID-vkDestroyPipelineLayout-device-parameter", VALIDATION_ERROR_26005601}, - {"VUID-vkDestroyPipelineLayout-pAllocator-parameter", VALIDATION_ERROR_2600ec01}, - {"VUID-vkDestroyPipelineLayout-pipelineLayout-parameter", VALIDATION_ERROR_26028201}, - {"VUID-vkDestroyPipelineLayout-pipelineLayout-parent", VALIDATION_ERROR_26028207}, - {"VUID-vkDestroyQueryPool-queryPool-00793", VALIDATION_ERROR_26200632}, - {"VUID-vkDestroyQueryPool-queryPool-00794", VALIDATION_ERROR_26200634}, - {"VUID-vkDestroyQueryPool-queryPool-00795", VALIDATION_ERROR_26200636}, - {"VUID-vkDestroyQueryPool-device-parameter", VALIDATION_ERROR_26205601}, - {"VUID-vkDestroyQueryPool-pAllocator-parameter", VALIDATION_ERROR_2620ec01}, - {"VUID-vkDestroyQueryPool-queryPool-parameter", VALIDATION_ERROR_26229801}, - {"VUID-vkDestroyQueryPool-queryPool-parent", VALIDATION_ERROR_26229807}, - {"VUID-vkDestroyRenderPass-renderPass-00873", VALIDATION_ERROR_264006d2}, - {"VUID-vkDestroyRenderPass-renderPass-00874", VALIDATION_ERROR_264006d4}, - {"VUID-vkDestroyRenderPass-renderPass-00875", VALIDATION_ERROR_264006d6}, - {"VUID-vkDestroyRenderPass-device-parameter", VALIDATION_ERROR_26405601}, - {"VUID-vkDestroyRenderPass-pAllocator-parameter", VALIDATION_ERROR_2640ec01}, - {"VUID-vkDestroyRenderPass-renderPass-parameter", VALIDATION_ERROR_2642ae01}, - {"VUID-vkDestroyRenderPass-renderPass-parent", VALIDATION_ERROR_2642ae07}, - {"VUID-vkDestroySampler-sampler-01082", VALIDATION_ERROR_26600874}, - {"VUID-vkDestroySampler-sampler-01083", VALIDATION_ERROR_26600876}, - {"VUID-vkDestroySampler-sampler-01084", VALIDATION_ERROR_26600878}, - {"VUID-vkDestroySampler-device-parameter", VALIDATION_ERROR_26605601}, - {"VUID-vkDestroySampler-pAllocator-parameter", VALIDATION_ERROR_2660ec01}, - {"VUID-vkDestroySampler-sampler-parameter", VALIDATION_ERROR_2662b201}, - {"VUID-vkDestroySampler-sampler-parent", VALIDATION_ERROR_2662b207}, - {"VUID-vkDestroySemaphore-semaphore-01137", VALIDATION_ERROR_268008e2}, - {"VUID-vkDestroySemaphore-semaphore-01138", VALIDATION_ERROR_268008e4}, - {"VUID-vkDestroySemaphore-semaphore-01139", VALIDATION_ERROR_268008e6}, - {"VUID-vkDestroySemaphore-device-parameter", VALIDATION_ERROR_26805601}, - {"VUID-vkDestroySemaphore-pAllocator-parameter", VALIDATION_ERROR_2680ec01}, - {"VUID-vkDestroySemaphore-semaphore-parameter", VALIDATION_ERROR_2682b801}, - {"VUID-vkDestroySemaphore-semaphore-parent", VALIDATION_ERROR_2682b807}, - {"VUID-vkDestroyShaderModule-shaderModule-01092", VALIDATION_ERROR_26a00888}, - {"VUID-vkDestroyShaderModule-shaderModule-01093", VALIDATION_ERROR_26a0088a}, - {"VUID-vkDestroyShaderModule-device-parameter", VALIDATION_ERROR_26a05601}, - {"VUID-vkDestroyShaderModule-pAllocator-parameter", VALIDATION_ERROR_26a0ec01}, - {"VUID-vkDestroyShaderModule-shaderModule-parameter", VALIDATION_ERROR_26a2be01}, - {"VUID-vkDestroyShaderModule-shaderModule-parent", VALIDATION_ERROR_26a2be07}, - {"VUID-vkDestroySurfaceKHR-surface-01266", VALIDATION_ERROR_26c009e4}, - {"VUID-vkDestroySurfaceKHR-surface-01267", VALIDATION_ERROR_26c009e6}, - {"VUID-vkDestroySurfaceKHR-surface-01268", VALIDATION_ERROR_26c009e8}, - {"VUID-vkDestroySurfaceKHR-instance-parameter", VALIDATION_ERROR_26c0bc01}, - {"VUID-vkDestroySurfaceKHR-pAllocator-parameter", VALIDATION_ERROR_26c0ec01}, - {"VUID-vkDestroySurfaceKHR-surface-parameter", VALIDATION_ERROR_26c2ec01}, - {"VUID-vkDestroySurfaceKHR-surface-parent", VALIDATION_ERROR_26c2ec07}, - {"VUID-vkDestroySwapchainKHR-commonparent", VALIDATION_ERROR_26e00009}, - {"VUID-vkDestroySwapchainKHR-swapchain-01282", VALIDATION_ERROR_26e00a04}, - {"VUID-vkDestroySwapchainKHR-swapchain-01283", VALIDATION_ERROR_26e00a06}, - {"VUID-vkDestroySwapchainKHR-swapchain-01284", VALIDATION_ERROR_26e00a08}, - {"VUID-vkDestroySwapchainKHR-device-parameter", VALIDATION_ERROR_26e05601}, - {"VUID-vkDestroySwapchainKHR-pAllocator-parameter", VALIDATION_ERROR_26e0ec01}, - {"VUID-vkDestroySwapchainKHR-swapchain-parameter", VALIDATION_ERROR_26e2f001}, - {"VUID-vkDeviceWaitIdle-device-parameter", VALIDATION_ERROR_27005601}, - {"VUID-vkDisplayPowerControlEXT-device-parameter", VALIDATION_ERROR_27205601}, - {"VUID-vkDisplayPowerControlEXT-display-parameter", VALIDATION_ERROR_27206001}, - {"VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter", VALIDATION_ERROR_27214e01}, - {"VUID-vkEndCommandBuffer-commandBuffer-00059", VALIDATION_ERROR_27400076}, - {"VUID-vkEndCommandBuffer-commandBuffer-00060", VALIDATION_ERROR_27400078}, - {"VUID-vkEndCommandBuffer-commandBuffer-00061", VALIDATION_ERROR_2740007a}, - {"VUID-vkEndCommandBuffer-commandBuffer-00062", VALIDATION_ERROR_2740007c}, - {"VUID-vkEndCommandBuffer-commandBuffer-01815", VALIDATION_ERROR_27400e2e}, - {"VUID-vkEndCommandBuffer-commandBuffer-parameter", VALIDATION_ERROR_27402401}, - {"VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter", VALIDATION_ERROR_27619e01}, - {"VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter", VALIDATION_ERROR_2761f401}, - {"VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter", VALIDATION_ERROR_2761f601}, - {"VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", VALIDATION_ERROR_27627a01}, - {"VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter", VALIDATION_ERROR_2781f401}, - {"VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter", VALIDATION_ERROR_2781f601}, - {"VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", VALIDATION_ERROR_27827a01}, - {"VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter", VALIDATION_ERROR_27a19e01}, - {"VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter", VALIDATION_ERROR_27a1f401}, - {"VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter", VALIDATION_ERROR_27a1f601}, - {"VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter", VALIDATION_ERROR_27c1f401}, - {"VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter", VALIDATION_ERROR_27c1f601}, - {"VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", VALIDATION_ERROR_27e0bc01}, - {"VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter", VALIDATION_ERROR_27e1d801}, - {"VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter", VALIDATION_ERROR_27e1da01}, - {"VUID-vkEnumeratePhysicalDevices-instance-parameter", VALIDATION_ERROR_2800bc01}, - {"VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter", VALIDATION_ERROR_2801d601}, - {"VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter", VALIDATION_ERROR_2801dc01}, - {"VUID-vkFlushMappedMemoryRanges-device-parameter", VALIDATION_ERROR_28205601}, - {"VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength", VALIDATION_ERROR_2820c81b}, - {"VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter", VALIDATION_ERROR_2821b201}, - {"VUID-vkFreeCommandBuffers-pCommandBuffers-00047", VALIDATION_ERROR_2840005e}, - {"VUID-vkFreeCommandBuffers-pCommandBuffers-00048", VALIDATION_ERROR_28400060}, - {"VUID-vkFreeCommandBuffers-commandBufferCount-arraylength", VALIDATION_ERROR_2840261b}, - {"VUID-vkFreeCommandBuffers-commandPool-parameter", VALIDATION_ERROR_28402801}, - {"VUID-vkFreeCommandBuffers-commandPool-parent", VALIDATION_ERROR_28402807}, - {"VUID-vkFreeCommandBuffers-device-parameter", VALIDATION_ERROR_28405601}, - {"VUID-vkFreeCommandBuffers-pCommandBuffers-parent", VALIDATION_ERROR_28411407}, - {"VUID-vkFreeDescriptorSets-pDescriptorSets-00309", VALIDATION_ERROR_2860026a}, - {"VUID-vkFreeDescriptorSets-pDescriptorSets-00310", VALIDATION_ERROR_2860026c}, - {"VUID-vkFreeDescriptorSets-pDescriptorSets-00311", VALIDATION_ERROR_2860026e}, - {"VUID-vkFreeDescriptorSets-descriptorPool-00312", VALIDATION_ERROR_28600270}, - {"VUID-vkFreeDescriptorSets-descriptorPool-parameter", VALIDATION_ERROR_28604601}, - {"VUID-vkFreeDescriptorSets-descriptorPool-parent", VALIDATION_ERROR_28604607}, - {"VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength", VALIDATION_ERROR_28604a1b}, - {"VUID-vkFreeDescriptorSets-device-parameter", VALIDATION_ERROR_28605601}, - {"VUID-vkFreeDescriptorSets-pDescriptorSets-parent", VALIDATION_ERROR_28613007}, - {"VUID-vkFreeMemory-memory-00677", VALIDATION_ERROR_2880054a}, - {"VUID-vkFreeMemory-device-parameter", VALIDATION_ERROR_28805601}, - {"VUID-vkFreeMemory-memory-parameter", VALIDATION_ERROR_2880c601}, - {"VUID-vkFreeMemory-memory-parent", VALIDATION_ERROR_2880c607}, - {"VUID-vkFreeMemory-pAllocator-parameter", VALIDATION_ERROR_2880ec01}, - {"VUID-vkGetBufferMemoryRequirements-buffer-parameter", VALIDATION_ERROR_28a01a01}, - {"VUID-vkGetBufferMemoryRequirements-buffer-parent", VALIDATION_ERROR_28a01a07}, - {"VUID-vkGetBufferMemoryRequirements-device-parameter", VALIDATION_ERROR_28a05601}, - {"VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter", VALIDATION_ERROR_28a1b401}, - {"VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691", VALIDATION_ERROR_28c00566}, - {"VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692", VALIDATION_ERROR_28c00568}, - {"VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693", VALIDATION_ERROR_28c0056a}, - {"VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694", VALIDATION_ERROR_28c0056c}, - {"VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", VALIDATION_ERROR_28c05601}, - {"VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter", VALIDATION_ERROR_28c1d401}, - {"VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-requiredbitmask", VALIDATION_ERROR_28c1d403}, - {"VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter", VALIDATION_ERROR_28e05601}, - {"VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter", VALIDATION_ERROR_28e13c01}, - {"VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent", VALIDATION_ERROR_29000009}, - {"VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter", VALIDATION_ERROR_29005601}, - {"VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter", VALIDATION_ERROR_2901be01}, - {"VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter", VALIDATION_ERROR_2902ec01}, - {"VUID-vkGetDeviceMemoryCommitment-memory-00690", VALIDATION_ERROR_29200564}, - {"VUID-vkGetDeviceMemoryCommitment-device-parameter", VALIDATION_ERROR_29205601}, - {"VUID-vkGetDeviceMemoryCommitment-memory-parameter", VALIDATION_ERROR_2920c601}, - {"VUID-vkGetDeviceMemoryCommitment-memory-parent", VALIDATION_ERROR_2920c607}, - {"VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter", VALIDATION_ERROR_29211801}, - {"VUID-vkGetDeviceProcAddr-device-parameter", VALIDATION_ERROR_29405601}, - {"VUID-vkGetDeviceProcAddr-pName-parameter", VALIDATION_ERROR_2941c001}, - {"VUID-vkGetDeviceQueue-queueFamilyIndex-00384", VALIDATION_ERROR_29600300}, - {"VUID-vkGetDeviceQueue-queueIndex-00385", VALIDATION_ERROR_29600302}, - {"VUID-vkGetDeviceQueue-flags-01841", VALIDATION_ERROR_29600e62}, - {"VUID-vkGetDeviceQueue-device-parameter", VALIDATION_ERROR_29605601}, - {"VUID-vkGetDeviceQueue-pQueue-parameter", VALIDATION_ERROR_2961fc01}, - {"VUID-vkGetDisplayModePropertiesKHR-display-parameter", VALIDATION_ERROR_29806001}, - {"VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter", VALIDATION_ERROR_2981f401}, - {"VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter", VALIDATION_ERROR_2981f601}, - {"VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", VALIDATION_ERROR_29827a01}, - {"VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter", VALIDATION_ERROR_29a0ce01}, - {"VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter", VALIDATION_ERROR_29a10a01}, - {"VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter", VALIDATION_ERROR_29a27a01}, - {"VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249", VALIDATION_ERROR_29c009c2}, - {"VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter", VALIDATION_ERROR_29c14a01}, - {"VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter", VALIDATION_ERROR_29c15201}, - {"VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", VALIDATION_ERROR_29c27a01}, - {"VUID-vkGetEventStatus-device-parameter", VALIDATION_ERROR_29e05601}, - {"VUID-vkGetEventStatus-event-parameter", VALIDATION_ERROR_29e07e01}, - {"VUID-vkGetEventStatus-event-parent", VALIDATION_ERROR_29e07e07}, - {"VUID-vkGetFenceStatus-device-parameter", VALIDATION_ERROR_2a005601}, - {"VUID-vkGetFenceStatus-fence-parameter", VALIDATION_ERROR_2a008801}, - {"VUID-vkGetFenceStatus-fence-parent", VALIDATION_ERROR_2a008807}, - {"VUID-vkGetImageMemoryRequirements-image-01588", VALIDATION_ERROR_2a200c68}, - {"VUID-vkGetImageMemoryRequirements-device-parameter", VALIDATION_ERROR_2a205601}, - {"VUID-vkGetImageMemoryRequirements-image-parameter", VALIDATION_ERROR_2a20a001}, - {"VUID-vkGetImageMemoryRequirements-image-parent", VALIDATION_ERROR_2a20a007}, - {"VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter", VALIDATION_ERROR_2a21b401}, - {"VUID-vkGetImageSparseMemoryRequirements-device-parameter", VALIDATION_ERROR_2a405601}, - {"VUID-vkGetImageSparseMemoryRequirements-image-parameter", VALIDATION_ERROR_2a40a001}, - {"VUID-vkGetImageSparseMemoryRequirements-image-parent", VALIDATION_ERROR_2a40a007}, - {"VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirementCount-parameter", VALIDATION_ERROR_2a423601}, - {"VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirements-parameter", VALIDATION_ERROR_2a423801}, - {"VUID-vkGetImageSubresourceLayout-image-00996", VALIDATION_ERROR_2a6007c8}, - {"VUID-vkGetImageSubresourceLayout-aspectMask-00997", VALIDATION_ERROR_2a6007ca}, - {"VUID-vkGetImageSubresourceLayout-format-01581", VALIDATION_ERROR_2a600c5a}, - {"VUID-vkGetImageSubresourceLayout-format-01582", VALIDATION_ERROR_2a600c5c}, - {"VUID-vkGetImageSubresourceLayout-mipLevel-01716", VALIDATION_ERROR_2a600d68}, - {"VUID-vkGetImageSubresourceLayout-arrayLayer-01717", VALIDATION_ERROR_2a600d6a}, - {"VUID-vkGetImageSubresourceLayout-image-01895", VALIDATION_ERROR_2a600ece}, - {"VUID-vkGetImageSubresourceLayout-device-parameter", VALIDATION_ERROR_2a605601}, - {"VUID-vkGetImageSubresourceLayout-image-parameter", VALIDATION_ERROR_2a60a001}, - {"VUID-vkGetImageSubresourceLayout-image-parent", VALIDATION_ERROR_2a60a007}, - {"VUID-vkGetImageSubresourceLayout-pLayout-parameter", VALIDATION_ERROR_2a61a201}, - {"VUID-vkGetImageSubresourceLayout-pSubresource-parameter", VALIDATION_ERROR_2a624401}, - {"VUID-vkGetInstanceProcAddr-instance-parameter", VALIDATION_ERROR_2a80bc01}, - {"VUID-vkGetInstanceProcAddr-pName-parameter", VALIDATION_ERROR_2a81c001}, - {"VUID-vkGetMemoryFdKHR-device-parameter", VALIDATION_ERROR_2aa05601}, - {"VUID-vkGetMemoryFdKHR-pFd-parameter", VALIDATION_ERROR_2aa16c01}, - {"VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter", VALIDATION_ERROR_2aa39e01}, - {"VUID-vkGetMemoryFdPropertiesKHR-fd-00673", VALIDATION_ERROR_2ac00542}, - {"VUID-vkGetMemoryFdPropertiesKHR-handleType-00674", VALIDATION_ERROR_2ac00544}, - {"VUID-vkGetMemoryFdPropertiesKHR-device-parameter", VALIDATION_ERROR_2ac05601}, - {"VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter", VALIDATION_ERROR_2ac09c01}, - {"VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter", VALIDATION_ERROR_2ac1ae01}, - {"VUID-vkGetMemoryWin32HandleKHR-device-parameter", VALIDATION_ERROR_2ae05601}, - {"VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter", VALIDATION_ERROR_2ae17c01}, - {"VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter", VALIDATION_ERROR_2ae3a001}, - {"VUID-vkGetMemoryWin32HandleNV-handleType-01326", VALIDATION_ERROR_2b000a5c}, - {"VUID-vkGetMemoryWin32HandleNV-device-parameter", VALIDATION_ERROR_2b005601}, - {"VUID-vkGetMemoryWin32HandleNV-handleType-parameter", VALIDATION_ERROR_2b009c01}, - {"VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask", VALIDATION_ERROR_2b009c03}, - {"VUID-vkGetMemoryWin32HandleNV-memory-parameter", VALIDATION_ERROR_2b00c601}, - {"VUID-vkGetMemoryWin32HandleNV-memory-parent", VALIDATION_ERROR_2b00c607}, - {"VUID-vkGetMemoryWin32HandleNV-pHandle-parameter", VALIDATION_ERROR_2b017c01}, - {"VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665", VALIDATION_ERROR_2b200532}, - {"VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666", VALIDATION_ERROR_2b200534}, - {"VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter", VALIDATION_ERROR_2b205601}, - {"VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter", VALIDATION_ERROR_2b209c01}, - {"VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter", VALIDATION_ERROR_2b21b601}, - {"VUID-vkGetPastPresentationTimingGOOGLE-commonparent", VALIDATION_ERROR_2b400009}, - {"VUID-vkGetPastPresentationTimingGOOGLE-device-parameter", VALIDATION_ERROR_2b405601}, - {"VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter", VALIDATION_ERROR_2b41ec01}, - {"VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter", VALIDATION_ERROR_2b41ee01}, - {"VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter", VALIDATION_ERROR_2b42f001}, - {"VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter", VALIDATION_ERROR_2b61f401}, - {"VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter", VALIDATION_ERROR_2b61f601}, - {"VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter", VALIDATION_ERROR_2b627a01}, - {"VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter", VALIDATION_ERROR_2b81f401}, - {"VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter", VALIDATION_ERROR_2b81f601}, - {"VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", VALIDATION_ERROR_2b827a01}, - {"VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter", VALIDATION_ERROR_2ba16201}, - {"VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter", VALIDATION_ERROR_2ba16401}, - {"VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", VALIDATION_ERROR_2ba27a01}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter", VALIDATION_ERROR_2bc08201}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter", VALIDATION_ERROR_2bc09001}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter", VALIDATION_ERROR_2bc09201}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter", VALIDATION_ERROR_2bc16601}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter", VALIDATION_ERROR_2bc27a01}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter", VALIDATION_ERROR_2bc2fa01}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter", VALIDATION_ERROR_2bc30401}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter", VALIDATION_ERROR_2bc30601}, - {"VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask", VALIDATION_ERROR_2bc30603}, - {"VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter", VALIDATION_ERROR_2be16801}, - {"VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter", VALIDATION_ERROR_2be16a01}, - {"VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", VALIDATION_ERROR_2be27a01}, - {"VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter", VALIDATION_ERROR_2c016e01}, - {"VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter", VALIDATION_ERROR_2c027a01}, - {"VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter", VALIDATION_ERROR_2c216e01}, - {"VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", VALIDATION_ERROR_2c227a01}, - {"VUID-vkGetPhysicalDeviceFormatProperties-format-parameter", VALIDATION_ERROR_2c409201}, - {"VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter", VALIDATION_ERROR_2c417601}, - {"VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter", VALIDATION_ERROR_2c427a01}, - {"VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter", VALIDATION_ERROR_2c609201}, - {"VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter", VALIDATION_ERROR_2c617601}, - {"VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", VALIDATION_ERROR_2c627a01}, - {"VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pFeatures-parameter", VALIDATION_ERROR_2c816e01}, - {"VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pLimits-parameter", VALIDATION_ERROR_2c81a401}, - {"VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter", VALIDATION_ERROR_2c827a01}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter", VALIDATION_ERROR_2ca09001}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter", VALIDATION_ERROR_2ca09201}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter", VALIDATION_ERROR_2ca18401}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter", VALIDATION_ERROR_2ca27a01}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter", VALIDATION_ERROR_2ca2fa01}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter", VALIDATION_ERROR_2ca30401}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter", VALIDATION_ERROR_2ca30601}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask", VALIDATION_ERROR_2ca30603}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868", VALIDATION_ERROR_2cc00e98}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter", VALIDATION_ERROR_2cc18201}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", VALIDATION_ERROR_2cc18401}, - {"VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", VALIDATION_ERROR_2cc27a01}, - {"VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter", VALIDATION_ERROR_2ce1b001}, - {"VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter", VALIDATION_ERROR_2ce27a01}, - {"VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter", VALIDATION_ERROR_2d01b001}, - {"VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", VALIDATION_ERROR_2d027a01}, - {"VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-queueFamilyIndex-01265", VALIDATION_ERROR_2d2009e2}, - {"VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-connection-parameter", VALIDATION_ERROR_2d203001}, - {"VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-physicalDevice-parameter", VALIDATION_ERROR_2d227a01}, - {"VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent", VALIDATION_ERROR_2d400009}, - {"VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter", VALIDATION_ERROR_2d420a01}, - {"VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter", VALIDATION_ERROR_2d420e01}, - {"VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter", VALIDATION_ERROR_2d427a01}, - {"VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter", VALIDATION_ERROR_2d42ec01}, - {"VUID-vkGetPhysicalDeviceProperties-pProperties-parameter", VALIDATION_ERROR_2d61f401}, - {"VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter", VALIDATION_ERROR_2d627a01}, - {"VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter", VALIDATION_ERROR_2d81f401}, - {"VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", VALIDATION_ERROR_2d827a01}, - {"VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter", VALIDATION_ERROR_2da20001}, - {"VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter", VALIDATION_ERROR_2da20201}, - {"VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", VALIDATION_ERROR_2da27a01}, - {"VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter", VALIDATION_ERROR_2dc20001}, - {"VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter", VALIDATION_ERROR_2dc20201}, - {"VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", VALIDATION_ERROR_2dc27a01}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094", VALIDATION_ERROR_2de0088c}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter", VALIDATION_ERROR_2de09201}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter", VALIDATION_ERROR_2de1f401}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pPropertyCount-parameter", VALIDATION_ERROR_2de1f601}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter", VALIDATION_ERROR_2de27a01}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter", VALIDATION_ERROR_2de2b401}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter", VALIDATION_ERROR_2de2fa01}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter", VALIDATION_ERROR_2de30401}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter", VALIDATION_ERROR_2de30601}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask", VALIDATION_ERROR_2de30603}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pFormatInfo-parameter", VALIDATION_ERROR_2e017401}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pProperties-parameter", VALIDATION_ERROR_2e01f401}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pPropertyCount-parameter", VALIDATION_ERROR_2e01f601}, - {"VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", VALIDATION_ERROR_2e027a01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent", VALIDATION_ERROR_2e200009}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter", VALIDATION_ERROR_2e224a01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter", VALIDATION_ERROR_2e227a01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter", VALIDATION_ERROR_2e22ec01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter", VALIDATION_ERROR_2e424a01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter", VALIDATION_ERROR_2e425001}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter", VALIDATION_ERROR_2e427a01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent", VALIDATION_ERROR_2e600009}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter", VALIDATION_ERROR_2e624a01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter", VALIDATION_ERROR_2e627a01}, - {"VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter", VALIDATION_ERROR_2e62ec01}, - {"VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter", VALIDATION_ERROR_2e824c01}, - {"VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter", VALIDATION_ERROR_2e824e01}, - {"VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter", VALIDATION_ERROR_2e825001}, - {"VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter", VALIDATION_ERROR_2e827a01}, - {"VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent", VALIDATION_ERROR_2ea00009}, - {"VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter", VALIDATION_ERROR_2ea24c01}, - {"VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter", VALIDATION_ERROR_2ea24e01}, - {"VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter", VALIDATION_ERROR_2ea27a01}, - {"VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter", VALIDATION_ERROR_2ea2ec01}, - {"VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent", VALIDATION_ERROR_2ec00009}, - {"VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter", VALIDATION_ERROR_2ec1e801}, - {"VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter", VALIDATION_ERROR_2ec1ea01}, - {"VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter", VALIDATION_ERROR_2ec27a01}, - {"VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter", VALIDATION_ERROR_2ec2ec01}, - {"VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent", VALIDATION_ERROR_2ee00009}, - {"VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269", VALIDATION_ERROR_2ee009ea}, - {"VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter", VALIDATION_ERROR_2ee24601}, - {"VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter", VALIDATION_ERROR_2ee27a01}, - {"VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter", VALIDATION_ERROR_2ee2ec01}, - {"VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306", VALIDATION_ERROR_2f000a34}, - {"VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-display-parameter", VALIDATION_ERROR_2f006001}, - {"VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter", VALIDATION_ERROR_2f027a01}, - {"VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309", VALIDATION_ERROR_2f200a3a}, - {"VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter", VALIDATION_ERROR_2f227a01}, - {"VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312", VALIDATION_ERROR_2f400a40}, - {"VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-connection-parameter", VALIDATION_ERROR_2f403001}, - {"VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter", VALIDATION_ERROR_2f427a01}, - {"VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315", VALIDATION_ERROR_2f600a46}, - {"VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-dpy-parameter", VALIDATION_ERROR_2f606601}, - {"VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter", VALIDATION_ERROR_2f627a01}, - {"VUID-vkGetPipelineCacheData-device-parameter", VALIDATION_ERROR_2f805601}, - {"VUID-vkGetPipelineCacheData-pData-parameter", VALIDATION_ERROR_2f812201}, - {"VUID-vkGetPipelineCacheData-pDataSize-parameter", VALIDATION_ERROR_2f812401}, - {"VUID-vkGetPipelineCacheData-pipelineCache-parameter", VALIDATION_ERROR_2f828001}, - {"VUID-vkGetPipelineCacheData-pipelineCache-parent", VALIDATION_ERROR_2f828007}, - {"VUID-vkGetQueryPoolResults-firstQuery-00813", VALIDATION_ERROR_2fa0065a}, - {"VUID-vkGetQueryPoolResults-flags-00814", VALIDATION_ERROR_2fa0065c}, - {"VUID-vkGetQueryPoolResults-flags-00815", VALIDATION_ERROR_2fa0065e}, - {"VUID-vkGetQueryPoolResults-firstQuery-00816", VALIDATION_ERROR_2fa00660}, - {"VUID-vkGetQueryPoolResults-dataSize-00817", VALIDATION_ERROR_2fa00662}, - {"VUID-vkGetQueryPoolResults-queryType-00818", VALIDATION_ERROR_2fa00664}, - {"VUID-vkGetQueryPoolResults-dataSize-arraylength", VALIDATION_ERROR_2fa03c1b}, - {"VUID-vkGetQueryPoolResults-device-parameter", VALIDATION_ERROR_2fa05601}, - {"VUID-vkGetQueryPoolResults-flags-parameter", VALIDATION_ERROR_2fa09001}, - {"VUID-vkGetQueryPoolResults-pData-parameter", VALIDATION_ERROR_2fa12201}, - {"VUID-vkGetQueryPoolResults-queryPool-parameter", VALIDATION_ERROR_2fa29801}, - {"VUID-vkGetQueryPoolResults-queryPool-parent", VALIDATION_ERROR_2fa29807}, - {"VUID-vkGetRandROutputDisplayEXT-dpy-parameter", VALIDATION_ERROR_2fc06601}, - {"VUID-vkGetRandROutputDisplayEXT-pDisplay-parameter", VALIDATION_ERROR_2fc14801}, - {"VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter", VALIDATION_ERROR_2fc27a01}, - {"VUID-vkGetRefreshCycleDurationGOOGLE-commonparent", VALIDATION_ERROR_2fe00009}, - {"VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter", VALIDATION_ERROR_2fe05601}, - {"VUID-vkGetRefreshCycleDurationGOOGLE-pDisplayTimingProperties-parameter", VALIDATION_ERROR_2fe15001}, - {"VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter", VALIDATION_ERROR_2fe2f001}, - {"VUID-vkGetRenderAreaGranularity-device-parameter", VALIDATION_ERROR_30005601}, - {"VUID-vkGetRenderAreaGranularity-pGranularity-parameter", VALIDATION_ERROR_30017a01}, - {"VUID-vkGetRenderAreaGranularity-renderPass-parameter", VALIDATION_ERROR_3002ae01}, - {"VUID-vkGetRenderAreaGranularity-renderPass-parent", VALIDATION_ERROR_3002ae07}, - {"VUID-vkGetSemaphoreFdKHR-device-parameter", VALIDATION_ERROR_30205601}, - {"VUID-vkGetSemaphoreFdKHR-pFd-parameter", VALIDATION_ERROR_30216c01}, - {"VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter", VALIDATION_ERROR_30239e01}, - {"VUID-vkGetSemaphoreWin32HandleKHR-device-parameter", VALIDATION_ERROR_30405601}, - {"VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter", VALIDATION_ERROR_30417c01}, - {"VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter", VALIDATION_ERROR_3043a001}, - {"VUID-vkGetSwapchainCounterEXT-commonparent", VALIDATION_ERROR_30600009}, - {"VUID-vkGetSwapchainCounterEXT-swapchain-01245", VALIDATION_ERROR_306009ba}, - {"VUID-vkGetSwapchainCounterEXT-counter-parameter", VALIDATION_ERROR_30603601}, - {"VUID-vkGetSwapchainCounterEXT-device-parameter", VALIDATION_ERROR_30605601}, - {"VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter", VALIDATION_ERROR_30611c01}, - {"VUID-vkGetSwapchainCounterEXT-swapchain-parameter", VALIDATION_ERROR_3062f001}, - {"VUID-vkGetSwapchainImagesKHR-commonparent", VALIDATION_ERROR_30800009}, - {"VUID-vkGetSwapchainImagesKHR-device-parameter", VALIDATION_ERROR_30805601}, - {"VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter", VALIDATION_ERROR_30825401}, - {"VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter", VALIDATION_ERROR_30825601}, - {"VUID-vkGetSwapchainImagesKHR-swapchain-parameter", VALIDATION_ERROR_3082f001}, - {"VUID-vkGetSwapchainStatusKHR-commonparent", VALIDATION_ERROR_30a00009}, - {"VUID-vkGetSwapchainStatusKHR-device-parameter", VALIDATION_ERROR_30a05601}, - {"VUID-vkGetSwapchainStatusKHR-swapchain-parameter", VALIDATION_ERROR_30a2f001}, - {"VUID-vkImportSemaphoreFdKHR-semaphore-01142", VALIDATION_ERROR_30c008ec}, - {"VUID-vkImportSemaphoreFdKHR-device-parameter", VALIDATION_ERROR_30c05601}, - {"VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter", VALIDATION_ERROR_30c18e01}, - {"VUID-vkImportSemaphoreWin32HandleKHR-device-parameter", VALIDATION_ERROR_30e05601}, - {"VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter", VALIDATION_ERROR_30e19001}, - {"VUID-vkInvalidateMappedMemoryRanges-device-parameter", VALIDATION_ERROR_31005601}, - {"VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength", VALIDATION_ERROR_3100c81b}, - {"VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter", VALIDATION_ERROR_3101b201}, - {"VUID-vkMapMemory-memory-00678", VALIDATION_ERROR_3120054c}, - {"VUID-vkMapMemory-offset-00679", VALIDATION_ERROR_3120054e}, - {"VUID-vkMapMemory-size-00680", VALIDATION_ERROR_31200550}, - {"VUID-vkMapMemory-size-00681", VALIDATION_ERROR_31200552}, - {"VUID-vkMapMemory-memory-00682", VALIDATION_ERROR_31200554}, - {"VUID-vkMapMemory-memory-00683", VALIDATION_ERROR_31200556}, - {"VUID-vkMapMemory-device-parameter", VALIDATION_ERROR_31205601}, - {"VUID-vkMapMemory-flags-zerobitmask", VALIDATION_ERROR_31209005}, - {"VUID-vkMapMemory-memory-parameter", VALIDATION_ERROR_3120c601}, - {"VUID-vkMapMemory-memory-parent", VALIDATION_ERROR_3120c607}, - {"VUID-vkMapMemory-ppData-parameter", VALIDATION_ERROR_31228c01}, - {"VUID-vkMergePipelineCaches-dstCache-00770", VALIDATION_ERROR_31400604}, - {"VUID-vkMergePipelineCaches-device-parameter", VALIDATION_ERROR_31405601}, - {"VUID-vkMergePipelineCaches-dstCache-parameter", VALIDATION_ERROR_31406e01}, - {"VUID-vkMergePipelineCaches-dstCache-parent", VALIDATION_ERROR_31406e07}, - {"VUID-vkMergePipelineCaches-pSrcCaches-parameter", VALIDATION_ERROR_31423c01}, - {"VUID-vkMergePipelineCaches-pSrcCaches-parent", VALIDATION_ERROR_31423c07}, - {"VUID-vkMergePipelineCaches-srcCacheCount-arraylength", VALIDATION_ERROR_3142ca1b}, - {"VUID-vkQueueBindSparse-commonparent", VALIDATION_ERROR_31600009}, - {"VUID-vkQueueBindSparse-queuetype", VALIDATION_ERROR_31600011}, - {"VUID-vkQueueBindSparse-fence-01113", VALIDATION_ERROR_316008b2}, - {"VUID-vkQueueBindSparse-fence-01114", VALIDATION_ERROR_316008b4}, - {"VUID-vkQueueBindSparse-pSignalSemaphores-01115", VALIDATION_ERROR_316008b6}, - {"VUID-vkQueueBindSparse-pWaitSemaphores-01116", VALIDATION_ERROR_316008b8}, - {"VUID-vkQueueBindSparse-pWaitSemaphores-01117", VALIDATION_ERROR_316008ba}, - {"VUID-vkQueueBindSparse-fence-parameter", VALIDATION_ERROR_31608801}, - {"VUID-vkQueueBindSparse-pBindInfo-parameter", VALIDATION_ERROR_3160f801}, - {"VUID-vkQueueBindSparse-queue-parameter", VALIDATION_ERROR_31629c01}, - {"VUID-vkQueuePresentKHR-pSwapchains-01292", VALIDATION_ERROR_31800a18}, - {"VUID-vkQueuePresentKHR-pSwapchains-01293", VALIDATION_ERROR_31800a1a}, - {"VUID-vkQueuePresentKHR-pWaitSemaphores-01294", VALIDATION_ERROR_31800a1c}, - {"VUID-vkQueuePresentKHR-pWaitSemaphores-01295", VALIDATION_ERROR_31800a1e}, - {"VUID-vkQueuePresentKHR-pPresentInfo-parameter", VALIDATION_ERROR_3181e601}, - {"VUID-vkQueuePresentKHR-queue-parameter", VALIDATION_ERROR_31829c01}, - {"VUID-vkQueueSubmit-commonparent", VALIDATION_ERROR_31a00009}, - {"VUID-vkQueueSubmit-fence-00063", VALIDATION_ERROR_31a0007e}, - {"VUID-vkQueueSubmit-fence-00064", VALIDATION_ERROR_31a00080}, - {"VUID-vkQueueSubmit-pCommandBuffers-00065", VALIDATION_ERROR_31a00082}, - {"VUID-vkQueueSubmit-pWaitDstStageMask-00066", VALIDATION_ERROR_31a00084}, - {"VUID-vkQueueSubmit-pSignalSemaphores-00067", VALIDATION_ERROR_31a00086}, - {"VUID-vkQueueSubmit-pWaitSemaphores-00068", VALIDATION_ERROR_31a00088}, - {"VUID-vkQueueSubmit-pWaitSemaphores-00069", VALIDATION_ERROR_31a0008a}, - {"VUID-vkQueueSubmit-pCommandBuffers-00070", VALIDATION_ERROR_31a0008c}, - {"VUID-vkQueueSubmit-pCommandBuffers-00071", VALIDATION_ERROR_31a0008e}, - {"VUID-vkQueueSubmit-pCommandBuffers-00072", VALIDATION_ERROR_31a00090}, - {"VUID-vkQueueSubmit-pCommandBuffers-00073", VALIDATION_ERROR_31a00092}, - {"VUID-vkQueueSubmit-pCommandBuffers-00074", VALIDATION_ERROR_31a00094}, - {"VUID-vkQueueSubmit-fence-parameter", VALIDATION_ERROR_31a08801}, - {"VUID-vkQueueSubmit-pSubmits-parameter", VALIDATION_ERROR_31a24001}, - {"VUID-vkQueueSubmit-queue-parameter", VALIDATION_ERROR_31a29c01}, - {"VUID-vkQueueWaitIdle-queue-parameter", VALIDATION_ERROR_31c29c01}, - {"VUID-vkRegisterDeviceEventEXT-device-parameter", VALIDATION_ERROR_31e05601}, - {"VUID-vkRegisterDeviceEventEXT-pAllocator-parameter", VALIDATION_ERROR_31e0ec01}, - {"VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter", VALIDATION_ERROR_31e13a01}, - {"VUID-vkRegisterDeviceEventEXT-pFence-parameter", VALIDATION_ERROR_31e17001}, - {"VUID-vkRegisterDisplayEventEXT-device-parameter", VALIDATION_ERROR_32005601}, - {"VUID-vkRegisterDisplayEventEXT-display-parameter", VALIDATION_ERROR_32006001}, - {"VUID-vkRegisterDisplayEventEXT-pAllocator-parameter", VALIDATION_ERROR_3200ec01}, - {"VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter", VALIDATION_ERROR_32014c01}, - {"VUID-vkRegisterDisplayEventEXT-pFence-parameter", VALIDATION_ERROR_32017001}, - {"VUID-vkRegisterObjectsNVX-pObjectTableEntry-01364", VALIDATION_ERROR_32200aa8}, - {"VUID-vkRegisterObjectsNVX-pObjectIndices-01365", VALIDATION_ERROR_32200aaa}, - {"VUID-vkRegisterObjectsNVX-pObjectIndices-01366", VALIDATION_ERROR_32200aac}, - {"VUID-vkRegisterObjectsNVX-device-parameter", VALIDATION_ERROR_32205601}, - {"VUID-vkRegisterObjectsNVX-objectCount-arraylength", VALIDATION_ERROR_3220d61b}, - {"VUID-vkRegisterObjectsNVX-objectTable-parameter", VALIDATION_ERROR_3220d801}, - {"VUID-vkRegisterObjectsNVX-objectTable-parent", VALIDATION_ERROR_3220d807}, - {"VUID-vkRegisterObjectsNVX-pObjectIndices-parameter", VALIDATION_ERROR_3221cc01}, - {"VUID-vkRegisterObjectsNVX-ppObjectTableEntries-parameter", VALIDATION_ERROR_32229201}, - {"VUID-vkReleaseDisplayEXT-display-parameter", VALIDATION_ERROR_32406001}, - {"VUID-vkReleaseDisplayEXT-physicalDevice-parameter", VALIDATION_ERROR_32427a01}, - {"VUID-vkResetCommandBuffer-commandBuffer-00045", VALIDATION_ERROR_3260005a}, - {"VUID-vkResetCommandBuffer-commandBuffer-00046", VALIDATION_ERROR_3260005c}, - {"VUID-vkResetCommandBuffer-commandBuffer-parameter", VALIDATION_ERROR_32602401}, - {"VUID-vkResetCommandBuffer-flags-parameter", VALIDATION_ERROR_32609001}, - {"VUID-vkResetCommandPool-commandPool-00040", VALIDATION_ERROR_32800050}, - {"VUID-vkResetCommandPool-commandPool-parameter", VALIDATION_ERROR_32802801}, - {"VUID-vkResetCommandPool-commandPool-parent", VALIDATION_ERROR_32802807}, - {"VUID-vkResetCommandPool-device-parameter", VALIDATION_ERROR_32805601}, - {"VUID-vkResetCommandPool-flags-parameter", VALIDATION_ERROR_32809001}, - {"VUID-vkResetDescriptorPool-descriptorPool-00313", VALIDATION_ERROR_32a00272}, - {"VUID-vkResetDescriptorPool-descriptorPool-parameter", VALIDATION_ERROR_32a04601}, - {"VUID-vkResetDescriptorPool-descriptorPool-parent", VALIDATION_ERROR_32a04607}, - {"VUID-vkResetDescriptorPool-device-parameter", VALIDATION_ERROR_32a05601}, - {"VUID-vkResetDescriptorPool-flags-zerobitmask", VALIDATION_ERROR_32a09005}, - {"VUID-vkResetEvent-event-01148", VALIDATION_ERROR_32c008f8}, - {"VUID-vkResetEvent-device-parameter", VALIDATION_ERROR_32c05601}, - {"VUID-vkResetEvent-event-parameter", VALIDATION_ERROR_32c07e01}, - {"VUID-vkResetEvent-event-parent", VALIDATION_ERROR_32c07e07}, - {"VUID-vkResetFences-pFences-01123", VALIDATION_ERROR_32e008c6}, - {"VUID-vkResetFences-device-parameter", VALIDATION_ERROR_32e05601}, - {"VUID-vkResetFences-fenceCount-arraylength", VALIDATION_ERROR_32e08a1b}, - {"VUID-vkResetFences-pFences-parameter", VALIDATION_ERROR_32e17201}, - {"VUID-vkResetFences-pFences-parent", VALIDATION_ERROR_32e17207}, - {"VUID-vkSetEvent-device-parameter", VALIDATION_ERROR_33005601}, - {"VUID-vkSetEvent-event-parameter", VALIDATION_ERROR_33007e01}, - {"VUID-vkSetEvent-event-parent", VALIDATION_ERROR_33007e07}, - {"VUID-vkSetHdrMetadataEXT-commonparent", VALIDATION_ERROR_33200009}, - {"VUID-vkSetHdrMetadataEXT-device-parameter", VALIDATION_ERROR_33205601}, - {"VUID-vkSetHdrMetadataEXT-pMetadata-parameter", VALIDATION_ERROR_3321ba01}, - {"VUID-vkSetHdrMetadataEXT-pSwapchains-parameter", VALIDATION_ERROR_33225801}, - {"VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength", VALIDATION_ERROR_3322f21b}, - {"VUID-vkTrimCommandPool-commandPool-parameter", VALIDATION_ERROR_33402801}, - {"VUID-vkTrimCommandPool-commandPool-parent", VALIDATION_ERROR_33402807}, - {"VUID-vkTrimCommandPool-device-parameter", VALIDATION_ERROR_33405601}, - {"VUID-vkTrimCommandPool-flags-zerobitmask", VALIDATION_ERROR_33409005}, - {"VUID-vkUnmapMemory-memory-00689", VALIDATION_ERROR_33600562}, - {"VUID-vkUnmapMemory-device-parameter", VALIDATION_ERROR_33605601}, - {"VUID-vkUnmapMemory-memory-parameter", VALIDATION_ERROR_3360c601}, - {"VUID-vkUnmapMemory-memory-parent", VALIDATION_ERROR_3360c607}, - {"VUID-vkUnregisterObjectsNVX-pObjectIndices-01373", VALIDATION_ERROR_33800aba}, - {"VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-01374", VALIDATION_ERROR_33800abc}, - {"VUID-vkUnregisterObjectsNVX-None-01375", VALIDATION_ERROR_33800abe}, - {"VUID-vkUnregisterObjectsNVX-device-parameter", VALIDATION_ERROR_33805601}, - {"VUID-vkUnregisterObjectsNVX-objectCount-arraylength", VALIDATION_ERROR_3380d61b}, - {"VUID-vkUnregisterObjectsNVX-objectTable-parameter", VALIDATION_ERROR_3380d801}, - {"VUID-vkUnregisterObjectsNVX-objectTable-parent", VALIDATION_ERROR_3380d807}, - {"VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-parameter", VALIDATION_ERROR_3381c801}, - {"VUID-vkUnregisterObjectsNVX-pObjectIndices-parameter", VALIDATION_ERROR_3381cc01}, - {"VUID-vkUpdateDescriptorSetWithTemplate-pData-01685", VALIDATION_ERROR_33a00d2a}, - {"VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter", VALIDATION_ERROR_33a04801}, - {"VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter", VALIDATION_ERROR_33a05201}, - {"VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent", VALIDATION_ERROR_33a05207}, - {"VUID-vkUpdateDescriptorSetWithTemplate-device-parameter", VALIDATION_ERROR_33a05601}, - {"VUID-vkUpdateDescriptorSets-dstSet-00314", VALIDATION_ERROR_33c00274}, - {"VUID-vkUpdateDescriptorSets-None-03047", VALIDATION_ERROR_33c017ce}, - {"VUID-vkUpdateDescriptorSets-device-parameter", VALIDATION_ERROR_33c05601}, - {"VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter", VALIDATION_ERROR_33c12c01}, - {"VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter", VALIDATION_ERROR_33c13601}, - {"VUID-vkWaitForFences-device-parameter", VALIDATION_ERROR_33e05601}, - {"VUID-vkWaitForFences-fenceCount-arraylength", VALIDATION_ERROR_33e08a1b}, - {"VUID-vkWaitForFences-pFences-parameter", VALIDATION_ERROR_33e17201}, - {"VUID-vkWaitForFences-pFences-parent", VALIDATION_ERROR_33e17207}, - {"VUID-VkPhysicalDeviceProperties2-pNext-pNext", VALIDATION_ERROR_3401c40d}, - {"VUID-VkPhysicalDeviceProperties2-sType-sType", VALIDATION_ERROR_3402b00b}, - {"VUID-VkPhysicalDeviceProperties2-sType-unique", VALIDATION_ERROR_3402b00f}, - {"VUID-VkFormatProperties2-pNext-pNext", VALIDATION_ERROR_3421c40d}, - {"VUID-VkFormatProperties2-sType-sType", VALIDATION_ERROR_3422b00b}, - {"VUID-VkImageFormatProperties2-pNext-pNext", VALIDATION_ERROR_3441c40d}, - {"VUID-VkImageFormatProperties2-sType-sType", VALIDATION_ERROR_3442b00b}, - {"VUID-VkImageFormatProperties2-sType-unique", VALIDATION_ERROR_3442b00f}, - {"VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext", VALIDATION_ERROR_3461c40d}, - {"VUID-VkPhysicalDeviceMemoryProperties2-sType-sType", VALIDATION_ERROR_3462b00b}, - {"VUID-VkSurfaceCapabilities2KHR-pNext-pNext", VALIDATION_ERROR_3481c40d}, - {"VUID-VkSurfaceCapabilities2KHR-sType-sType", VALIDATION_ERROR_3482b00b}, - {"VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext", VALIDATION_ERROR_34a1c40d}, - {"VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType", VALIDATION_ERROR_34a2b00b}, - {"VUID-VkExternalBufferProperties-pNext-pNext", VALIDATION_ERROR_34c1c40d}, - {"VUID-VkExternalBufferProperties-sType-sType", VALIDATION_ERROR_34c2b00b}, - {"VUID-VkExternalSemaphoreProperties-pNext-pNext", VALIDATION_ERROR_3521c40d}, - {"VUID-VkExternalSemaphoreProperties-sType-sType", VALIDATION_ERROR_3522b00b}, - {"VUID-VkQueueFamilyProperties2-pNext-pNext", VALIDATION_ERROR_3541c40d}, - {"VUID-VkQueueFamilyProperties2-sType-sType", VALIDATION_ERROR_3542b00b}, - {"VUID-VkSparseImageFormatProperties2-pNext-pNext", VALIDATION_ERROR_3561c40d}, - {"VUID-VkSparseImageFormatProperties2-sType-sType", VALIDATION_ERROR_3562b00b}, - {"VUID-VkSurfaceFormat2KHR-pNext-pNext", VALIDATION_ERROR_3581c40d}, - {"VUID-VkSurfaceFormat2KHR-sType-sType", VALIDATION_ERROR_3582b00b}, - {"VUID-VkPhysicalDeviceMultiviewProperties-sType-sType", VALIDATION_ERROR_35c2b00b}, - {"VUID-VkExternalImageFormatProperties-sType-sType", VALIDATION_ERROR_3602b00b}, - {"VUID-VkPhysicalDeviceIDProperties-sType-sType", VALIDATION_ERROR_3622b00b}, - {"VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType", VALIDATION_ERROR_3642b00b}, - {"VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType", VALIDATION_ERROR_37e2b00b}, - {"VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType", VALIDATION_ERROR_3822b00b}, - {"VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType", VALIDATION_ERROR_3842b00b}, - {"VUID-VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT-sType-sType", VALIDATION_ERROR_3862b00b}, - {"VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424", VALIDATION_ERROR_38800b20}, - {"VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425", VALIDATION_ERROR_38800b22}, - {"VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426", VALIDATION_ERROR_38800b24}, - {"VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType", VALIDATION_ERROR_3882b00b}, - {"VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter", VALIDATION_ERROR_38834a01}, - {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405", VALIDATION_ERROR_38a00afa}, - {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask", VALIDATION_ERROR_38a09005}, - {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType", VALIDATION_ERROR_38a2b00b}, - {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter", VALIDATION_ERROR_38a34c01}, - {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableCount-arraylength", VALIDATION_ERROR_38a34e1b}, - {"VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404", VALIDATION_ERROR_38c00af8}, - {"VUID-VkPipelineCoverageToColorStateCreateInfoNV-flags-zerobitmask", VALIDATION_ERROR_38c09005}, - {"VUID-VkPipelineCoverageToColorStateCreateInfoNV-sType-sType", VALIDATION_ERROR_38c2b00b}, - {"VUID-VkSamplerReductionModeCreateInfoEXT-sType-sType", VALIDATION_ERROR_38e2b00b}, - {"VUID-VkSamplerReductionModeCreateInfoEXT-reductionMode-parameter", VALIDATION_ERROR_38e35001}, - {"VUID-VkExportFenceCreateInfo-handleTypes-01446", VALIDATION_ERROR_39400b4c}, - {"VUID-VkExportFenceCreateInfo-handleTypes-parameter", VALIDATION_ERROR_39409e01}, - {"VUID-VkExportFenceCreateInfo-sType-sType", VALIDATION_ERROR_3942b00b}, - {"VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter", VALIDATION_ERROR_39609c01}, - {"VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext", VALIDATION_ERROR_3961c40d}, - {"VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType", VALIDATION_ERROR_3962b00b}, - {"VUID-VkExternalFenceProperties-pNext-pNext", VALIDATION_ERROR_3981c40d}, - {"VUID-VkExternalFenceProperties-sType-sType", VALIDATION_ERROR_3982b00b}, - {"VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", VALIDATION_ERROR_39a27a01}, - {"VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter", VALIDATION_ERROR_39a3a201}, - {"VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter", VALIDATION_ERROR_39a3a401}, - {"VUID-VkImportFenceFdInfoKHR-handleType-01464", VALIDATION_ERROR_39c00b70}, - {"VUID-VkImportFenceFdInfoKHR-fd-01541", VALIDATION_ERROR_39c00c0a}, - {"VUID-VkImportFenceFdInfoKHR-fence-parameter", VALIDATION_ERROR_39c08801}, - {"VUID-VkImportFenceFdInfoKHR-flags-parameter", VALIDATION_ERROR_39c09001}, - {"VUID-VkImportFenceFdInfoKHR-handleType-parameter", VALIDATION_ERROR_39c09c01}, - {"VUID-VkImportFenceFdInfoKHR-pNext-pNext", VALIDATION_ERROR_39c1c40d}, - {"VUID-VkImportFenceFdInfoKHR-sType-sType", VALIDATION_ERROR_39c2b00b}, - {"VUID-VkFenceGetFdInfoKHR-handleType-01453", VALIDATION_ERROR_39e00b5a}, - {"VUID-VkFenceGetFdInfoKHR-handleType-01454", VALIDATION_ERROR_39e00b5c}, - {"VUID-VkFenceGetFdInfoKHR-fence-01455", VALIDATION_ERROR_39e00b5e}, - {"VUID-VkFenceGetFdInfoKHR-handleType-01456", VALIDATION_ERROR_39e00b60}, - {"VUID-VkFenceGetFdInfoKHR-fence-parameter", VALIDATION_ERROR_39e08801}, - {"VUID-VkFenceGetFdInfoKHR-handleType-parameter", VALIDATION_ERROR_39e09c01}, - {"VUID-VkFenceGetFdInfoKHR-pNext-pNext", VALIDATION_ERROR_39e1c40d}, - {"VUID-VkFenceGetFdInfoKHR-sType-sType", VALIDATION_ERROR_39e2b00b}, - {"VUID-vkImportFenceFdKHR-fence-01463", VALIDATION_ERROR_3a000b6e}, - {"VUID-vkImportFenceFdKHR-device-parameter", VALIDATION_ERROR_3a005601}, - {"VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter", VALIDATION_ERROR_3a03a801}, - {"VUID-vkGetFenceFdKHR-device-parameter", VALIDATION_ERROR_3a205601}, - {"VUID-vkGetFenceFdKHR-pFd-parameter", VALIDATION_ERROR_3a216c01}, - {"VUID-vkGetFenceFdKHR-pGetFdInfo-parameter", VALIDATION_ERROR_3a239e01}, - {"VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457", VALIDATION_ERROR_3a400b62}, - {"VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459", VALIDATION_ERROR_3a400b66}, - {"VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460", VALIDATION_ERROR_3a400b68}, - {"VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461", VALIDATION_ERROR_3a400b6a}, - {"VUID-VkImportFenceWin32HandleInfoKHR-handle-01462", VALIDATION_ERROR_3a400b6c}, - {"VUID-VkImportFenceWin32HandleInfoKHR-handle-01539", VALIDATION_ERROR_3a400c06}, - {"VUID-VkImportFenceWin32HandleInfoKHR-name-01540", VALIDATION_ERROR_3a400c08}, - {"VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter", VALIDATION_ERROR_3a408801}, - {"VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter", VALIDATION_ERROR_3a409001}, - {"VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter", VALIDATION_ERROR_3a409c01}, - {"VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext", VALIDATION_ERROR_3a41c40d}, - {"VUID-VkImportFenceWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_3a42b00b}, - {"VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447", VALIDATION_ERROR_3a600b4e}, - {"VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter", VALIDATION_ERROR_3a60f401}, - {"VUID-VkExportFenceWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_3a62b00b}, - {"VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448", VALIDATION_ERROR_3a800b50}, - {"VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449", VALIDATION_ERROR_3a800b52}, - {"VUID-VkFenceGetWin32HandleInfoKHR-fence-01450", VALIDATION_ERROR_3a800b54}, - {"VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451", VALIDATION_ERROR_3a800b56}, - {"VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452", VALIDATION_ERROR_3a800b58}, - {"VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter", VALIDATION_ERROR_3a808801}, - {"VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter", VALIDATION_ERROR_3a809c01}, - {"VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext", VALIDATION_ERROR_3a81c40d}, - {"VUID-VkFenceGetWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_3a82b00b}, - {"VUID-vkImportFenceWin32HandleKHR-device-parameter", VALIDATION_ERROR_3aa05601}, - {"VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter", VALIDATION_ERROR_3aa3aa01}, - {"VUID-vkGetFenceWin32HandleKHR-device-parameter", VALIDATION_ERROR_3ac05601}, - {"VUID-vkGetFenceWin32HandleKHR-pHandle-parameter", VALIDATION_ERROR_3ac17c01}, - {"VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter", VALIDATION_ERROR_3ac3a001}, - {"VUID-VkSemaphoreGetFdInfoKHR-handleType-01132", VALIDATION_ERROR_3ae008d8}, - {"VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133", VALIDATION_ERROR_3ae008da}, - {"VUID-VkSemaphoreGetFdInfoKHR-handleType-01134", VALIDATION_ERROR_3ae008dc}, - {"VUID-VkSemaphoreGetFdInfoKHR-handleType-01135", VALIDATION_ERROR_3ae008de}, - {"VUID-VkSemaphoreGetFdInfoKHR-handleType-01136", VALIDATION_ERROR_3ae008e0}, - {"VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter", VALIDATION_ERROR_3ae09c01}, - {"VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext", VALIDATION_ERROR_3ae1c40d}, - {"VUID-VkSemaphoreGetFdInfoKHR-sType-sType", VALIDATION_ERROR_3ae2b00b}, - {"VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter", VALIDATION_ERROR_3ae2b801}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126", VALIDATION_ERROR_3b0008cc}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127", VALIDATION_ERROR_3b0008ce}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128", VALIDATION_ERROR_3b0008d0}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129", VALIDATION_ERROR_3b0008d2}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130", VALIDATION_ERROR_3b0008d4}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131", VALIDATION_ERROR_3b0008d6}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter", VALIDATION_ERROR_3b009c01}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext", VALIDATION_ERROR_3b01c40d}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_3b02b00b}, - {"VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter", VALIDATION_ERROR_3b02b801}, - {"VUID-VkMemoryGetFdInfoKHR-handleType-00671", VALIDATION_ERROR_3b20053e}, - {"VUID-VkMemoryGetFdInfoKHR-handleType-00672", VALIDATION_ERROR_3b200540}, - {"VUID-VkMemoryGetFdInfoKHR-handleType-parameter", VALIDATION_ERROR_3b209c01}, - {"VUID-VkMemoryGetFdInfoKHR-memory-parameter", VALIDATION_ERROR_3b20c601}, - {"VUID-VkMemoryGetFdInfoKHR-pNext-pNext", VALIDATION_ERROR_3b21c40d}, - {"VUID-VkMemoryGetFdInfoKHR-sType-sType", VALIDATION_ERROR_3b22b00b}, - {"VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662", VALIDATION_ERROR_3b40052c}, - {"VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663", VALIDATION_ERROR_3b40052e}, - {"VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664", VALIDATION_ERROR_3b400530}, - {"VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter", VALIDATION_ERROR_3b409c01}, - {"VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter", VALIDATION_ERROR_3b40c601}, - {"VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext", VALIDATION_ERROR_3b41c40d}, - {"VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType", VALIDATION_ERROR_3b42b00b}, - {"VUID-VkMemoryDedicatedRequirements-sType-sType", VALIDATION_ERROR_3b62b00b}, - {"VUID-VkMemoryDedicatedAllocateInfo-commonparent", VALIDATION_ERROR_3b800009}, - {"VUID-VkMemoryDedicatedAllocateInfo-image-01432", VALIDATION_ERROR_3b800b30}, - {"VUID-VkMemoryDedicatedAllocateInfo-image-01433", VALIDATION_ERROR_3b800b32}, - {"VUID-VkMemoryDedicatedAllocateInfo-image-01434", VALIDATION_ERROR_3b800b34}, - {"VUID-VkMemoryDedicatedAllocateInfo-buffer-01435", VALIDATION_ERROR_3b800b36}, - {"VUID-VkMemoryDedicatedAllocateInfo-buffer-01436", VALIDATION_ERROR_3b800b38}, - {"VUID-VkMemoryDedicatedAllocateInfo-image-01797", VALIDATION_ERROR_3b800e0a}, - {"VUID-VkMemoryDedicatedAllocateInfo-image-01876", VALIDATION_ERROR_3b800ea8}, - {"VUID-VkMemoryDedicatedAllocateInfo-buffer-01877", VALIDATION_ERROR_3b800eaa}, - {"VUID-VkMemoryDedicatedAllocateInfo-image-01878", VALIDATION_ERROR_3b800eac}, - {"VUID-VkMemoryDedicatedAllocateInfo-buffer-01879", VALIDATION_ERROR_3b800eae}, - {"VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter", VALIDATION_ERROR_3b801a01}, - {"VUID-VkMemoryDedicatedAllocateInfo-image-parameter", VALIDATION_ERROR_3b80a001}, - {"VUID-VkMemoryDedicatedAllocateInfo-sType-sType", VALIDATION_ERROR_3b82b00b}, - {"VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", VALIDATION_ERROR_3ba01a01}, - {"VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext", VALIDATION_ERROR_3ba1c40d}, - {"VUID-VkBufferMemoryRequirementsInfo2-sType-sType", VALIDATION_ERROR_3ba2b00b}, - {"VUID-VkImageMemoryRequirementsInfo2-image-01589", VALIDATION_ERROR_3bc00c6a}, - {"VUID-VkImageMemoryRequirementsInfo2-image-01590", VALIDATION_ERROR_3bc00c6c}, - {"VUID-VkImageMemoryRequirementsInfo2-image-01591", VALIDATION_ERROR_3bc00c6e}, - {"VUID-VkImageMemoryRequirementsInfo2-image-01897", VALIDATION_ERROR_3bc00ed2}, - {"VUID-VkImageMemoryRequirementsInfo2-image-parameter", VALIDATION_ERROR_3bc0a001}, - {"VUID-VkImageMemoryRequirementsInfo2-pNext-pNext", VALIDATION_ERROR_3bc1c40d}, - {"VUID-VkImageMemoryRequirementsInfo2-sType-sType", VALIDATION_ERROR_3bc2b00b}, - {"VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter", VALIDATION_ERROR_3be0a001}, - {"VUID-VkImageSparseMemoryRequirementsInfo2-pNext-pNext", VALIDATION_ERROR_3be1c40d}, - {"VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType", VALIDATION_ERROR_3be2b00b}, - {"VUID-VkMemoryRequirements2-pNext-pNext", VALIDATION_ERROR_3c01c40d}, - {"VUID-VkMemoryRequirements2-sType-sType", VALIDATION_ERROR_3c02b00b}, - {"VUID-VkSparseImageMemoryRequirements2-pNext-pNext", VALIDATION_ERROR_3c21c40d}, - {"VUID-VkSparseImageMemoryRequirements2-sType-sType", VALIDATION_ERROR_3c22b00b}, - {"VUID-vkGetImageMemoryRequirements2-device-parameter", VALIDATION_ERROR_3c405601}, - {"VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter", VALIDATION_ERROR_3c41b401}, - {"VUID-vkGetImageMemoryRequirements2-pInfo-parameter", VALIDATION_ERROR_3c439c01}, - {"VUID-vkGetBufferMemoryRequirements2-device-parameter", VALIDATION_ERROR_3c605601}, - {"VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter", VALIDATION_ERROR_3c61b401}, - {"VUID-vkGetBufferMemoryRequirements2-pInfo-parameter", VALIDATION_ERROR_3c639c01}, - {"VUID-vkGetImageSparseMemoryRequirements2-device-parameter", VALIDATION_ERROR_3c805601}, - {"VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirementCount-parameter", VALIDATION_ERROR_3c823601}, - {"VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirements-parameter", VALIDATION_ERROR_3c823801}, - {"VUID-vkGetImageSparseMemoryRequirements2-pInfo-parameter", VALIDATION_ERROR_3c839c01}, - {"VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType", VALIDATION_ERROR_3ca2b00b}, - {"VUID-VkPhysicalDeviceVariablePointerFeatures-variablePointers-01431", VALIDATION_ERROR_3cc00b2e}, - {"VUID-VkPhysicalDeviceVariablePointerFeatures-sType-sType", VALIDATION_ERROR_3cc2b00b}, - {"VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526", VALIDATION_ERROR_3ce00bec}, - {"VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527", VALIDATION_ERROR_3ce00bee}, - {"VUID-VkSampleLocationsInfoEXT-sType-sType", VALIDATION_ERROR_3ce2b00b}, - {"VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter", VALIDATION_ERROR_3ce3b201}, - {"VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength", VALIDATION_ERROR_3ce3b41b}, - {"VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter", VALIDATION_ERROR_3ce3b601}, - {"VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType", VALIDATION_ERROR_3d02b00b}, - {"VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter", VALIDATION_ERROR_3d03ba01}, - {"VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter", VALIDATION_ERROR_3d03e801}, - {"VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType", VALIDATION_ERROR_3d22b00b}, - {"VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter", VALIDATION_ERROR_3d23c601}, - {"VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType", VALIDATION_ERROR_3d42b00b}, - {"VUID-VkMultisamplePropertiesEXT-pNext-pNext", VALIDATION_ERROR_3d61c40d}, - {"VUID-VkMultisamplePropertiesEXT-sType-sType", VALIDATION_ERROR_3d62b00b}, - {"VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter", VALIDATION_ERROR_3d827a01}, - {"VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter", VALIDATION_ERROR_3d82b401}, - {"VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter", VALIDATION_ERROR_3d83ca01}, - {"VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534", VALIDATION_ERROR_3da00bfc}, - {"VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535", VALIDATION_ERROR_3da00bfe}, - {"VUID-VkValidationCacheCreateInfoEXT-flags-zerobitmask", VALIDATION_ERROR_3da09005}, - {"VUID-VkValidationCacheCreateInfoEXT-pInitialData-parameter", VALIDATION_ERROR_3da19601}, - {"VUID-VkValidationCacheCreateInfoEXT-pNext-pNext", VALIDATION_ERROR_3da1c40d}, - {"VUID-VkValidationCacheCreateInfoEXT-sType-sType", VALIDATION_ERROR_3da2b00b}, - {"VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType", VALIDATION_ERROR_3dc2b00b}, - {"VUID-VkShaderModuleValidationCacheCreateInfoEXT-validationCache-parameter", VALIDATION_ERROR_3dc3c401}, - {"VUID-vkCreateValidationCacheEXT-device-parameter", VALIDATION_ERROR_3de05601}, - {"VUID-vkCreateValidationCacheEXT-pAllocator-parameter", VALIDATION_ERROR_3de0ec01}, - {"VUID-vkCreateValidationCacheEXT-pCreateInfo-parameter", VALIDATION_ERROR_3de11e01}, - {"VUID-vkCreateValidationCacheEXT-pValidationCache-parameter", VALIDATION_ERROR_3de3c201}, - {"VUID-vkGetValidationCacheDataEXT-device-parameter", VALIDATION_ERROR_3e005601}, - {"VUID-vkGetValidationCacheDataEXT-pData-parameter", VALIDATION_ERROR_3e012201}, - {"VUID-vkGetValidationCacheDataEXT-pDataSize-parameter", VALIDATION_ERROR_3e012401}, - {"VUID-vkGetValidationCacheDataEXT-validationCache-parameter", VALIDATION_ERROR_3e03c401}, - {"VUID-vkGetValidationCacheDataEXT-validationCache-parent", VALIDATION_ERROR_3e03c407}, - {"VUID-vkCmdSetSampleLocationsEXT-None-01528", VALIDATION_ERROR_3e200bf0}, - {"VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529", VALIDATION_ERROR_3e200bf2}, - {"VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530", VALIDATION_ERROR_3e200bf4}, - {"VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter", VALIDATION_ERROR_3e202401}, - {"VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording", VALIDATION_ERROR_3e202413}, - {"VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool", VALIDATION_ERROR_3e202415}, - {"VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter", VALIDATION_ERROR_3e23c801}, - {"VUID-vkDestroyValidationCacheEXT-validationCache-01537", VALIDATION_ERROR_3e400c02}, - {"VUID-vkDestroyValidationCacheEXT-validationCache-01538", VALIDATION_ERROR_3e400c04}, - {"VUID-vkDestroyValidationCacheEXT-device-parameter", VALIDATION_ERROR_3e405601}, - {"VUID-vkDestroyValidationCacheEXT-pAllocator-parameter", VALIDATION_ERROR_3e40ec01}, - {"VUID-vkDestroyValidationCacheEXT-validationCache-parameter", VALIDATION_ERROR_3e43c401}, - {"VUID-vkDestroyValidationCacheEXT-validationCache-parent", VALIDATION_ERROR_3e43c407}, - {"VUID-vkMergeValidationCachesEXT-dstCache-01536", VALIDATION_ERROR_3e600c00}, - {"VUID-vkMergeValidationCachesEXT-device-parameter", VALIDATION_ERROR_3e605601}, - {"VUID-vkMergeValidationCachesEXT-dstCache-parameter", VALIDATION_ERROR_3e606e01}, - {"VUID-vkMergeValidationCachesEXT-dstCache-parent", VALIDATION_ERROR_3e606e07}, - {"VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter", VALIDATION_ERROR_3e623c01}, - {"VUID-vkMergeValidationCachesEXT-pSrcCaches-parent", VALIDATION_ERROR_3e623c07}, - {"VUID-vkMergeValidationCachesEXT-srcCacheCount-arraylength", VALIDATION_ERROR_3e62ca1b}, - {"VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531", VALIDATION_ERROR_3e800bf6}, - {"VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter", VALIDATION_ERROR_3e83c601}, - {"VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532", VALIDATION_ERROR_3ea00bf8}, - {"VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter", VALIDATION_ERROR_3ea3c601}, - {"VUID-VkPhysicalDevicePointClippingProperties-sType-sType", VALIDATION_ERROR_3ec2b00b}, - {"VUID-VkInputAttachmentAspectReference-aspectMask-parameter", VALIDATION_ERROR_3ee00c01}, - {"VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask", VALIDATION_ERROR_3ee00c03}, - {"VUID-VkInputAttachmentAspectReference-pCreateInfo-01568", VALIDATION_ERROR_3ee00c40}, - {"VUID-VkInputAttachmentAspectReference-None-01569", VALIDATION_ERROR_3ee00c42}, - {"VUID-VkInputAttachmentAspectReference-aspectMask-01570", VALIDATION_ERROR_3ee00c44}, - {"VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType", VALIDATION_ERROR_3f02b00b}, - {"VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength", VALIDATION_ERROR_3f03ce1b}, - {"VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter", VALIDATION_ERROR_3f03d001}, - {"VUID-VkImageViewUsageCreateInfo-usage-01587", VALIDATION_ERROR_3f200c66}, - {"VUID-VkImageViewUsageCreateInfo-sType-sType", VALIDATION_ERROR_3f22b00b}, - {"VUID-VkImageViewUsageCreateInfo-usage-parameter", VALIDATION_ERROR_3f230601}, - {"VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask", VALIDATION_ERROR_3f230603}, - {"VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType", VALIDATION_ERROR_3f42b00b}, - {"VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter", VALIDATION_ERROR_3f43d201}, - {"VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01578", VALIDATION_ERROR_3f600c54}, - {"VUID-VkImageFormatListCreateInfoKHR-flags-01579", VALIDATION_ERROR_3f600c56}, - {"VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01580", VALIDATION_ERROR_3f600c58}, - {"VUID-VkImageFormatListCreateInfoKHR-sType-sType", VALIDATION_ERROR_3f62b00b}, - {"VUID-VkImageFormatListCreateInfoKHR-pViewFormats-parameter", VALIDATION_ERROR_3f63e401}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-format-01649", VALIDATION_ERROR_3f800ce2}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-format-01650", VALIDATION_ERROR_3f800ce4}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651", VALIDATION_ERROR_3f800ce6}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652", VALIDATION_ERROR_3f800ce8}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-format-01653", VALIDATION_ERROR_3f800cea}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-None-01654", VALIDATION_ERROR_3f800cec}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655", VALIDATION_ERROR_3f800cee}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656", VALIDATION_ERROR_3f800cf0}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657", VALIDATION_ERROR_3f800cf2}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-format-01904", VALIDATION_ERROR_3f800ee0}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter", VALIDATION_ERROR_3f802c01}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter", VALIDATION_ERROR_3f809201}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", VALIDATION_ERROR_3f81c40d}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType", VALIDATION_ERROR_3f82b00b}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter", VALIDATION_ERROR_3f83d401}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter", VALIDATION_ERROR_3f83d601}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter", VALIDATION_ERROR_3f83d801}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter", VALIDATION_ERROR_3f83da01}, - {"VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter", VALIDATION_ERROR_3f83dc01}, - {"VUID-VkBindImagePlaneMemoryInfo-planeAspect-01642", VALIDATION_ERROR_3fa00cd4}, - {"VUID-VkBindImagePlaneMemoryInfo-None-01643", VALIDATION_ERROR_3fa00cd6}, - {"VUID-VkBindImagePlaneMemoryInfo-sType-sType", VALIDATION_ERROR_3fa2b00b}, - {"VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter", VALIDATION_ERROR_3fa3de01}, - {"VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-01592", VALIDATION_ERROR_3fc00c70}, - {"VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType", VALIDATION_ERROR_3fc2b00b}, - {"VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter", VALIDATION_ERROR_3fc3de01}, - {"VUID-vkCreateSamplerYcbcrConversion-None-01648", VALIDATION_ERROR_3fe00ce0}, - {"VUID-vkCreateSamplerYcbcrConversion-device-parameter", VALIDATION_ERROR_3fe05601}, - {"VUID-vkCreateSamplerYcbcrConversion-pAllocator-parameter", VALIDATION_ERROR_3fe0ec01}, - {"VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", VALIDATION_ERROR_3fe11e01}, - {"VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter", VALIDATION_ERROR_3fe3e001}, - {"VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606", VALIDATION_ERROR_40000c8c}, - {"VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607", VALIDATION_ERROR_40000c8e}, - {"VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter", VALIDATION_ERROR_40013e01}, - {"VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType", VALIDATION_ERROR_4002b00b}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633", VALIDATION_ERROR_40200cc2}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634", VALIDATION_ERROR_40200cc4}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635", VALIDATION_ERROR_40200cc6}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636", VALIDATION_ERROR_40200cc8}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637", VALIDATION_ERROR_40200cca}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638", VALIDATION_ERROR_40200ccc}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639", VALIDATION_ERROR_40200cce}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640", VALIDATION_ERROR_40200cd0}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641", VALIDATION_ERROR_40200cd2}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter", VALIDATION_ERROR_40213e01}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType", VALIDATION_ERROR_4022b00b}, - {"VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter", VALIDATION_ERROR_4023fe01}, - {"VUID-vkDestroySamplerYcbcrConversion-device-parameter", VALIDATION_ERROR_40405601}, - {"VUID-vkDestroySamplerYcbcrConversion-pAllocator-parameter", VALIDATION_ERROR_4040ec01}, - {"VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", VALIDATION_ERROR_4043e201}, - {"VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent", VALIDATION_ERROR_4043e207}, - {"VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType", VALIDATION_ERROR_4062b00b}, - {"VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType", VALIDATION_ERROR_4082b00b}, - {"VUID-VkSamplerYcbcrConversionInfo-sType-sType", VALIDATION_ERROR_40a2b00b}, - {"VUID-VkSamplerYcbcrConversionInfo-conversion-parameter", VALIDATION_ERROR_40a3e601}, - {"VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType", VALIDATION_ERROR_40c2b00b}, - {"VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter", VALIDATION_ERROR_40c3ea01}, - {"VUID-vkGetShaderInfoAMD-device-parameter", VALIDATION_ERROR_40e05601}, - {"VUID-vkGetShaderInfoAMD-pipeline-parameter", VALIDATION_ERROR_40e27c01}, - {"VUID-vkGetShaderInfoAMD-pipeline-parent", VALIDATION_ERROR_40e27c07}, - {"VUID-vkGetShaderInfoAMD-pInfo-parameter", VALIDATION_ERROR_40e39c01}, - {"VUID-vkGetShaderInfoAMD-shaderStage-parameter", VALIDATION_ERROR_40e3ec01}, - {"VUID-vkGetShaderInfoAMD-infoType-parameter", VALIDATION_ERROR_40e3ee01}, - {"VUID-vkGetShaderInfoAMD-pInfoSize-parameter", VALIDATION_ERROR_40e3f001}, - {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747", VALIDATION_ERROR_41200da6}, - {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748", VALIDATION_ERROR_41200da8}, - {"VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749", VALIDATION_ERROR_41200daa}, - {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750", VALIDATION_ERROR_41200dac}, - {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751", VALIDATION_ERROR_41200dae}, - {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter", VALIDATION_ERROR_41209c01}, - {"VUID-VkImportMemoryHostPointerInfoEXT-sType-sType", VALIDATION_ERROR_4122b00b}, - {"VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext", VALIDATION_ERROR_4141c40d}, - {"VUID-VkMemoryHostPointerPropertiesEXT-sType-sType", VALIDATION_ERROR_4142b00b}, - {"VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType", VALIDATION_ERROR_4162b00b}, - {"VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752", VALIDATION_ERROR_41800db0}, - {"VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753", VALIDATION_ERROR_41800db2}, - {"VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754", VALIDATION_ERROR_41800db4}, - {"VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755", VALIDATION_ERROR_41800db6}, - {"VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter", VALIDATION_ERROR_41805601}, - {"VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter", VALIDATION_ERROR_41809c01}, - {"VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter", VALIDATION_ERROR_4183f401}, - {"VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType", VALIDATION_ERROR_41a2b00b}, - {"VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769", VALIDATION_ERROR_41c00dd2}, - {"VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask", VALIDATION_ERROR_41c09005}, - {"VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType", VALIDATION_ERROR_41c2b00b}, - {"VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter", VALIDATION_ERROR_41c3f801}, - {"VUID-vkCmdWriteBufferMarkerAMD-commonparent", VALIDATION_ERROR_41e00009}, - {"VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798", VALIDATION_ERROR_41e00e0c}, - {"VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799", VALIDATION_ERROR_41e00e0e}, - {"VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800", VALIDATION_ERROR_41e00e10}, - {"VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801", VALIDATION_ERROR_41e00e12}, - {"VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter", VALIDATION_ERROR_41e02401}, - {"VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording", VALIDATION_ERROR_41e02413}, - {"VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool", VALIDATION_ERROR_41e02415}, - {"VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter", VALIDATION_ERROR_41e06c01}, - {"VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter", VALIDATION_ERROR_41e28401}, - {"VUID-VkDescriptorSetLayoutSupport-pNext-pNext", VALIDATION_ERROR_4201c40d}, - {"VUID-VkDescriptorSetLayoutSupport-sType-sType", VALIDATION_ERROR_4202b00b}, - {"VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842", VALIDATION_ERROR_42200e64}, - {"VUID-VkDeviceQueueInfo2-queueIndex-01843", VALIDATION_ERROR_42200e66}, - {"VUID-VkDeviceQueueInfo2-flags-parameter", VALIDATION_ERROR_42209001}, - {"VUID-VkDeviceQueueInfo2-flags-requiredbitmask", VALIDATION_ERROR_42209003}, - {"VUID-VkDeviceQueueInfo2-pNext-pNext", VALIDATION_ERROR_4221c40d}, - {"VUID-VkDeviceQueueInfo2-sType-sType", VALIDATION_ERROR_4222b00b}, - {"VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType", VALIDATION_ERROR_4242b00b}, - {"VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType", VALIDATION_ERROR_4262b00b}, - {"VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType", VALIDATION_ERROR_4282b00b}, - {"VUID-VkPhysicalDeviceShaderDrawParameterFeatures-sType-sType", VALIDATION_ERROR_42a2b00b}, - {"VUID-VkPhysicalDeviceSubgroupProperties-sType-sType", VALIDATION_ERROR_42c2b00b}, - {"VUID-VkProtectedSubmitInfo-protectedSubmit-01816", VALIDATION_ERROR_42e00e30}, - {"VUID-VkProtectedSubmitInfo-protectedSubmit-01817", VALIDATION_ERROR_42e00e32}, - {"VUID-VkProtectedSubmitInfo-protectedSubmit-01818", VALIDATION_ERROR_42e00e34}, - {"VUID-VkProtectedSubmitInfo-pNext-01819", VALIDATION_ERROR_42e00e36}, - {"VUID-VkProtectedSubmitInfo-sType-sType", VALIDATION_ERROR_42e2b00b}, - {"VUID-vkEnumerateInstanceVersion-pApiVersion-parameter", VALIDATION_ERROR_43040001}, - {"VUID-vkGetDescriptorSetLayoutSupport-device-parameter", VALIDATION_ERROR_43205601}, - {"VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter", VALIDATION_ERROR_43211e01}, - {"VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter", VALIDATION_ERROR_43240201}, - {"VUID-vkGetDeviceQueue2-device-parameter", VALIDATION_ERROR_43405601}, - {"VUID-vkGetDeviceQueue2-pQueue-parameter", VALIDATION_ERROR_4341fc01}, - {"VUID-vkGetDeviceQueue2-pQueueInfo-parameter", VALIDATION_ERROR_43440401}, - {"VUID-VkDebugUtilsObjectNameInfoEXT-objectType-01905", VALIDATION_ERROR_43600ee2}, - {"VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01906", VALIDATION_ERROR_43600ee4}, - {"VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01907", VALIDATION_ERROR_43600ee6}, - {"VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter", VALIDATION_ERROR_4360da01}, - {"VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext", VALIDATION_ERROR_4361c40d}, - {"VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter", VALIDATION_ERROR_4361ce01}, - {"VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType", VALIDATION_ERROR_4362b00b}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908", VALIDATION_ERROR_43800ee8}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01909", VALIDATION_ERROR_43800eea}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910", VALIDATION_ERROR_43800eec}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter", VALIDATION_ERROR_4380da01}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext", VALIDATION_ERROR_4381c40d}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter", VALIDATION_ERROR_43825a01}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType", VALIDATION_ERROR_4382b00b}, - {"VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength", VALIDATION_ERROR_4382f41b}, - {"VUID-VkDebugUtilsLabelEXT-pNext-pNext", VALIDATION_ERROR_43a1c40d}, - {"VUID-VkDebugUtilsLabelEXT-sType-sType", VALIDATION_ERROR_43a2b00b}, - {"VUID-VkDebugUtilsLabelEXT-pLabelName-parameter", VALIDATION_ERROR_43a40801}, - {"VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask", VALIDATION_ERROR_43c09005}, - {"VUID-VkDebugUtilsMessengerCallbackDataEXT-objectCount-arraylength", VALIDATION_ERROR_43c0d61b}, - {"VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter", VALIDATION_ERROR_43c1b801}, - {"VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext", VALIDATION_ERROR_43c1c40d}, - {"VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType", VALIDATION_ERROR_43c2b00b}, - {"VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter", VALIDATION_ERROR_43c42201}, - {"VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914", VALIDATION_ERROR_43e00ef4}, - {"VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask", VALIDATION_ERROR_43e09005}, - {"VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType", VALIDATION_ERROR_43e2b00b}, - {"VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter", VALIDATION_ERROR_43e40a01}, - {"VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask", VALIDATION_ERROR_43e40a03}, - {"VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter", VALIDATION_ERROR_43e40c01}, - {"VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask", VALIDATION_ERROR_43e40c03}, - {"VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", VALIDATION_ERROR_4400bc01}, - {"VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-parameter", VALIDATION_ERROR_4400ec01}, - {"VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter", VALIDATION_ERROR_44011e01}, - {"VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter", VALIDATION_ERROR_44041001}, - {"VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter", VALIDATION_ERROR_4420bc01}, - {"VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter", VALIDATION_ERROR_44240a01}, - {"VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter", VALIDATION_ERROR_44241201}, - {"VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask", VALIDATION_ERROR_44241203}, - {"VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter", VALIDATION_ERROR_44242801}, - {"VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType", VALIDATION_ERROR_4442b00b}, - {"VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType", VALIDATION_ERROR_4462b00b}, - {"VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength", VALIDATION_ERROR_4464141b}, - {"VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter", VALIDATION_ERROR_44641601}, - {"VUID-VkExternalFormatANDROID-externalFormat-01894", VALIDATION_ERROR_44800ecc}, - {"VUID-VkExternalFormatANDROID-sType-sType", VALIDATION_ERROR_4482b00b}, - {"VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880", VALIDATION_ERROR_44a00eb0}, - {"VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881", VALIDATION_ERROR_44a00eb2}, - {"VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-parameter", VALIDATION_ERROR_44a01a01}, - {"VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType", VALIDATION_ERROR_44a2b00b}, - {"VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882", VALIDATION_ERROR_44c00eb4}, - {"VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883", VALIDATION_ERROR_44c00eb6}, - {"VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912", VALIDATION_ERROR_44e00ef0}, - {"VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913", VALIDATION_ERROR_44e00ef2}, - {"VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", VALIDATION_ERROR_44e02401}, - {"VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording", VALIDATION_ERROR_44e02413}, - {"VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool", VALIDATION_ERROR_44e02415}, - {"VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915", VALIDATION_ERROR_45000ef6}, - {"VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916", VALIDATION_ERROR_45000ef8}, - {"VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", VALIDATION_ERROR_4500bc01}, - {"VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-parameter", VALIDATION_ERROR_4500ec01}, - {"VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter", VALIDATION_ERROR_45042601}, - {"VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent", VALIDATION_ERROR_45042607}, - {"VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884", VALIDATION_ERROR_45200eb8}, - {"VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-parameter", VALIDATION_ERROR_45201a01}, - {"VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter", VALIDATION_ERROR_45205601}, - {"VUID-vkGetAndroidHardwareBufferPropertiesANDROID-pProperties-parameter", VALIDATION_ERROR_4521f401}, - {"VUID-vkQueueEndDebugUtilsLabelEXT-None-01911", VALIDATION_ERROR_45400eee}, - {"VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter", VALIDATION_ERROR_45429c01}, - {"VUID-VkAndroidHardwareBufferUsageANDROID-sType-sType", VALIDATION_ERROR_4562b00b}, - {"VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter", VALIDATION_ERROR_45a05601}, - {"VUID-vkGetMemoryAndroidHardwareBufferANDROID-pBuffer-parameter", VALIDATION_ERROR_45a10001}, - {"VUID-vkGetMemoryAndroidHardwareBufferANDROID-pInfo-parameter", VALIDATION_ERROR_45a39c01}, - {"VUID-VkAndroidHardwareBufferFormatPropertiesANDROID-sType-sType", VALIDATION_ERROR_45c2b00b}, - {"VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", VALIDATION_ERROR_45e02401}, - {"VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording", VALIDATION_ERROR_45e02413}, - {"VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool", VALIDATION_ERROR_45e02415}, - {"VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter", VALIDATION_ERROR_45e42401}, - {"VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", VALIDATION_ERROR_46002401}, - {"VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording", VALIDATION_ERROR_46002413}, - {"VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool", VALIDATION_ERROR_46002415}, - {"VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter", VALIDATION_ERROR_46042401}, - {"VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter", VALIDATION_ERROR_46229c01}, - {"VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter", VALIDATION_ERROR_46242401}, - {"VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter", VALIDATION_ERROR_46429c01}, - {"VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter", VALIDATION_ERROR_46442401}, - {"VUID-vkSetDebugUtilsObjectNameEXT-device-parameter", VALIDATION_ERROR_46605601}, - {"VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter", VALIDATION_ERROR_4661c201}, - {"VUID-vkSetDebugUtilsObjectTagEXT-device-parameter", VALIDATION_ERROR_46805601}, - {"VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter", VALIDATION_ERROR_46825c01}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-bindingCount-03002", VALIDATION_ERROR_46a01774}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-flags-03003", VALIDATION_ERROR_46a01776}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03004", VALIDATION_ERROR_46a01778}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformBufferUpdateAfterBind-03005", VALIDATION_ERROR_46a0177a}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingSampledImageUpdateAfterBind-03006", VALIDATION_ERROR_46a0177c}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageImageUpdateAfterBind-03007", VALIDATION_ERROR_46a0177e}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageBufferUpdateAfterBind-03008", VALIDATION_ERROR_46a01780}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformTexelBufferUpdateAfterBind-03009", VALIDATION_ERROR_46a01782}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageTexelBufferUpdateAfterBind-03010", VALIDATION_ERROR_46a01784}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-None-03011", VALIDATION_ERROR_46a01786}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUpdateUnusedWhilePending-03012", VALIDATION_ERROR_46a01788}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingPartiallyBound-03013", VALIDATION_ERROR_46a0178a}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingVariableDescriptorCount-03014", VALIDATION_ERROR_46a0178c}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03015", VALIDATION_ERROR_46a0178e}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-sType-sType", VALIDATION_ERROR_46a2b00b}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-parameter", VALIDATION_ERROR_46a42a01}, - {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-requiredbitmask", VALIDATION_ERROR_46a42a03}, - {"VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-descriptorSetCount-03045", VALIDATION_ERROR_46c017ca}, - {"VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pSetLayouts-03046", VALIDATION_ERROR_46c017cc}, - {"VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-sType-sType", VALIDATION_ERROR_46c2b00b}, - {"VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pDescriptorCounts-parameter", VALIDATION_ERROR_46c42c01}, - {"VUID-VkDescriptorSetVariableDescriptorCountLayoutSupportEXT-sType-sType", VALIDATION_ERROR_46e2b00b}, - {"VUID-VkPhysicalDeviceDescriptorIndexingFeaturesEXT-sType-sType", VALIDATION_ERROR_4702b00b}, - {"VUID-VkPhysicalDeviceDescriptorIndexingPropertiesEXT-sType-sType", VALIDATION_ERROR_4722b00b}, - {"VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType", VALIDATION_ERROR_4742b00b}, - {"VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869", VALIDATION_ERROR_47600e9a}, - {"VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870", VALIDATION_ERROR_47600e9c}, - {"VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871", VALIDATION_ERROR_47600e9e}, -}; diff --git a/layers/vu_csv_stats.sh b/layers/vu_csv_stats.sh deleted file mode 100755 index 4e794695..00000000 --- a/layers/vu_csv_stats.sh +++ /dev/null @@ -1,38 +0,0 @@ -#! /bin/bash -# Basic count stats from the VU database in CSV format for spreadsheet loading. -# Usage: ./vu_csv_stats.sh > stats.csv - -set -o errexit -set -o nounset - -COUNT="grep -c" - -INFILE="./vk_validation_error_database.txt" - -if [ ! -r "$INFILE" ] -then - echo "ERROR: \"$INFILE\" is not readable." >&2 - exit 1 -fi - -echo "\"Generated\",\"`date`\"" -echo "\"Directory\",\"`pwd -P`\"" -echo "\"Commit\",\"$(git describe --all --long)\"" -echo -echo "\"All VUs\"" -echo "\"\",\"Total\",$($COUNT '^VALIDATION_ERROR_' $INFILE)" -echo "\"\",\"Done (Y)\",$($COUNT '~^~Y~^~' $INFILE)" -echo "\"\",\"Not done (N)\",$($COUNT '~^~N~^~' $INFILE)" -echo "\"\",\"Unknown (U)\",$($COUNT '~^~U~^~' $INFILE)" -echo -echo "\"Implicit VUs\"" -echo "\"\",\"Total\",$($COUNT 'implicit' $INFILE)" -echo "\"\",\"Done (Y)\",$(grep 'implicit' $INFILE | $COUNT '~^~Y~^~')" -echo "\"\",\"Not done (N)\",$(grep 'implicit' $INFILE | $COUNT '~^~N~^~')" -echo -echo "\"Tests\"" -echo "\"\",\"None\",$($COUNT '~^~None~^~' $INFILE)" -echo "\"\",\"Unknown\",$($COUNT '~^~Unknown~^~' $INFILE)" -echo "\"\",\"NotTestable\",$($COUNT '~^~NotTestable~^~' $INFILE)" - -# vim: set sw=4 ts=8 et ic ai: diff --git a/layers/windows/VkLayer_core_validation.json b/layers/windows/VkLayer_core_validation.json deleted file mode 100644 index 577db594..00000000 --- a/layers/windows/VkLayer_core_validation.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_core_validation", - "type": "GLOBAL", - "library_path": ".\\VkLayer_core_validation.dll", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - }, - { - "name": "VK_EXT_validation_cache", - "spec_version": "1", - "entrypoints": ["vkCreateValidationCacheEXT", - "vkDestroyValidationCacheEXT", - "vkGetValidationCacheDataEXT", - "vkMergeValidationCachesEXT" - ] - } - ] - } -} diff --git a/layers/windows/VkLayer_object_tracker.json b/layers/windows/VkLayer_object_tracker.json deleted file mode 100644 index e82e899a..00000000 --- a/layers/windows/VkLayer_object_tracker.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_object_tracker", - "type": "GLOBAL", - "library_path": ".\\VkLayer_object_tracker.dll", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - } - ] - } -} diff --git a/layers/windows/VkLayer_parameter_validation.json b/layers/windows/VkLayer_parameter_validation.json deleted file mode 100644 index 7525bac5..00000000 --- a/layers/windows/VkLayer_parameter_validation.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_LUNARG_parameter_validation", - "type": "GLOBAL", - "library_path": ".\\VkLayer_parameter_validation.dll", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "4", - "entrypoints": ["vkDebugMarkerSetObjectTagEXT", - "vkDebugMarkerSetObjectNameEXT", - "vkCmdDebugMarkerBeginEXT", - "vkCmdDebugMarkerEndEXT", - "vkCmdDebugMarkerInsertEXT" - ] - } - ] - } -} diff --git a/layers/windows/VkLayer_standard_validation.json b/layers/windows/VkLayer_standard_validation.json deleted file mode 100644 index 6b752730..00000000 --- a/layers/windows/VkLayer_standard_validation.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "file_format_version": "1.1.1", - "layer": { - "name": "VK_LAYER_LUNARG_standard_validation", - "type": "GLOBAL", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "LunarG Standard Validation", - "component_layers": [ - "VK_LAYER_GOOGLE_threading", - "VK_LAYER_LUNARG_parameter_validation", - "VK_LAYER_LUNARG_object_tracker", - "VK_LAYER_LUNARG_core_validation", - "VK_LAYER_GOOGLE_unique_objects" - ] - } -} diff --git a/layers/windows/VkLayer_threading.json b/layers/windows/VkLayer_threading.json deleted file mode 100644 index 8d51355a..00000000 --- a/layers/windows/VkLayer_threading.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_GOOGLE_threading", - "type": "GLOBAL", - "library_path": ".\\VkLayer_threading.dll", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "Google Validation Layer", - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "6" - } - ] - } -} diff --git a/layers/windows/VkLayer_unique_objects.json b/layers/windows/VkLayer_unique_objects.json deleted file mode 100644 index bcc933fd..00000000 --- a/layers/windows/VkLayer_unique_objects.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "file_format_version" : "1.1.0", - "layer" : { - "name": "VK_LAYER_GOOGLE_unique_objects", - "type": "GLOBAL", - "library_path": ".\\VkLayer_unique_objects.dll", - "api_version": "1.1.74", - "implementation_version": "1", - "description": "Google Validation Layer" - } -} diff --git a/layers/xxhash.c b/layers/xxhash.c deleted file mode 100644 index 833b99f3..00000000 --- a/layers/xxhash.c +++ /dev/null @@ -1,888 +0,0 @@ -/* -* xxHash - Fast Hash algorithm -* Copyright (C) 2012-2016, Yann Collet -* -* BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) -* -* Redistribution and use in source and binary forms, with or without -* modification, are permitted provided that the following conditions are -* met: -* -* * Redistributions of source code must retain the above copyright -* notice, this list of conditions and the following disclaimer. -* * Redistributions in binary form must reproduce the above -* copyright notice, this list of conditions and the following disclaimer -* in the documentation and/or other materials provided with the -* distribution. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -* -* You can contact the author at : -* - xxHash homepage: http://www.xxhash.com -* - xxHash source repository : https://github.com/Cyan4973/xxHash -*/ - - -/* ************************************* -* Tuning parameters -***************************************/ -/*!XXH_FORCE_MEMORY_ACCESS : - * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. - * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. - * The below switch allow to select different access method for improved performance. - * Method 0 (default) : use `memcpy()`. Safe and portable. - * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable). - * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. - * Method 2 : direct access. This method doesn't depend on compiler but violate C standard. - * It can generate buggy code on targets which do not support unaligned memory accesses. - * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) - * See http://stackoverflow.com/a/32095106/646947 for details. - * Prefer these methods in priority order (0 > 1 > 2) - */ -#ifndef XXH_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */ -# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) -# define XXH_FORCE_MEMORY_ACCESS 2 -# elif defined(__INTEL_COMPILER) || \ - (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) )) -# define XXH_FORCE_MEMORY_ACCESS 1 -# endif -#endif - -/*!XXH_ACCEPT_NULL_INPUT_POINTER : - * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer. - * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input. - * By default, this option is disabled. To enable it, uncomment below define : - */ -/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */ - -/*!XXH_FORCE_NATIVE_FORMAT : - * By default, xxHash library provides endian-independent Hash values, based on little-endian convention. - * Results are therefore identical for little-endian and big-endian CPU. - * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. - * Should endian-independence be of no importance for your application, you may set the #define below to 1, - * to improve speed for Big-endian CPU. - * This option has no impact on Little_Endian CPU. - */ -#ifndef XXH_FORCE_NATIVE_FORMAT /* can be defined externally */ -# define XXH_FORCE_NATIVE_FORMAT 0 -#endif - -/*!XXH_FORCE_ALIGN_CHECK : - * This is a minor performance trick, only useful with lots of very small keys. - * It means : check for aligned/unaligned input. - * The check costs one initial branch per hash; - * set it to 0 when the input is guaranteed to be aligned, - * or when alignment doesn't matter for performance. - */ -#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */ -# if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) -# define XXH_FORCE_ALIGN_CHECK 0 -# else -# define XXH_FORCE_ALIGN_CHECK 1 -# endif -#endif - - -/* ************************************* -* Includes & Memory related functions -***************************************/ -/*! Modify the local functions below should you wish to use some other memory routines -* for malloc(), free() */ -#include -static void* XXH_malloc(size_t s) { return malloc(s); } -static void XXH_free (void* p) { free(p); } -/*! and for memcpy() */ -#include -static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); } - -#define XXH_STATIC_LINKING_ONLY -#include "xxhash.h" - - -/* ************************************* -* Compiler Specific Options -***************************************/ -#ifdef _MSC_VER /* Visual Studio */ -# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ -# define FORCE_INLINE static __forceinline -#else -# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ -# ifdef __GNUC__ -# define FORCE_INLINE static inline __attribute__((always_inline)) -# else -# define FORCE_INLINE static inline -# endif -# else -# define FORCE_INLINE static -# endif /* __STDC_VERSION__ */ -#endif - - -/* ************************************* -* Basic Types -***************************************/ -#ifndef MEM_MODULE -# if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) -# include - typedef uint8_t BYTE; - typedef uint16_t U16; - typedef uint32_t U32; -# else - typedef unsigned char BYTE; - typedef unsigned short U16; - typedef unsigned int U32; -# endif -#endif - -#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2)) - -/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */ -static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; } - -#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1)) - -/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ -/* currently only defined for gcc and icc */ -typedef union { U32 u32; } __attribute__((packed)) unalign; -static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } - -#else - -/* portable and safe solution. Generally efficient. - * see : http://stackoverflow.com/a/32095106/646947 - */ -static U32 XXH_read32(const void* memPtr) -{ - U32 val; - memcpy(&val, memPtr, sizeof(val)); - return val; -} - -#endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */ - - -/* **************************************** -* Compiler-specific Functions and Macros -******************************************/ -#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) - -/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */ -#if defined(_MSC_VER) -# define XXH_rotl32(x,r) _rotl(x,r) -# define XXH_rotl64(x,r) _rotl64(x,r) -#else -# define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) -# define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r))) -#endif - -#if defined(_MSC_VER) /* Visual Studio */ -# define XXH_swap32 _byteswap_ulong -#elif XXH_GCC_VERSION >= 403 -# define XXH_swap32 __builtin_bswap32 -#else -static U32 XXH_swap32 (U32 x) -{ - return ((x << 24) & 0xff000000 ) | - ((x << 8) & 0x00ff0000 ) | - ((x >> 8) & 0x0000ff00 ) | - ((x >> 24) & 0x000000ff ); -} -#endif - - -/* ************************************* -* Architecture Macros -***************************************/ -typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess; - -/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */ -#ifndef XXH_CPU_LITTLE_ENDIAN - static const int g_one = 1; -# define XXH_CPU_LITTLE_ENDIAN (*(const char*)(&g_one)) -#endif - - -/* *************************** -* Memory reads -*****************************/ -typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment; - -FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align) -{ - if (align==XXH_unaligned) - return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr)); - else - return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr); -} - -FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian) -{ - return XXH_readLE32_align(ptr, endian, XXH_unaligned); -} - -static U32 XXH_readBE32(const void* ptr) -{ - return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr); -} - - -/* ************************************* -* Macros -***************************************/ -#define XXH_STATIC_ASSERT(c) { enum { XXH_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ -XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; } - - -/* ******************************************************************* -* 32-bits hash functions -*********************************************************************/ -static const U32 PRIME32_1 = 2654435761U; -static const U32 PRIME32_2 = 2246822519U; -static const U32 PRIME32_3 = 3266489917U; -static const U32 PRIME32_4 = 668265263U; -static const U32 PRIME32_5 = 374761393U; - -static U32 XXH32_round(U32 seed, U32 input) -{ - seed += input * PRIME32_2; - seed = XXH_rotl32(seed, 13); - seed *= PRIME32_1; - return seed; -} - -FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align) -{ - const BYTE* p = (const BYTE*)input; - const BYTE* bEnd = p + len; - U32 h32; -#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align) - -#ifdef XXH_ACCEPT_NULL_INPUT_POINTER - if (p==NULL) { - len=0; - bEnd=p=(const BYTE*)(size_t)16; - } -#endif - - if (len>=16) { - const BYTE* const limit = bEnd - 16; - U32 v1 = seed + PRIME32_1 + PRIME32_2; - U32 v2 = seed + PRIME32_2; - U32 v3 = seed + 0; - U32 v4 = seed - PRIME32_1; - - do { - v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4; - v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4; - v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4; - v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4; - } while (p<=limit); - - h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18); - } else { - h32 = seed + PRIME32_5; - } - - h32 += (U32) len; - - while (p+4<=bEnd) { - h32 += XXH_get32bits(p) * PRIME32_3; - h32 = XXH_rotl32(h32, 17) * PRIME32_4 ; - p+=4; - } - - while (p> 15; - h32 *= PRIME32_2; - h32 ^= h32 >> 13; - h32 *= PRIME32_3; - h32 ^= h32 >> 16; - - return h32; -} - - -XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed) -{ -#if 0 - /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ - XXH32_state_t state; - XXH32_reset(&state, seed); - XXH32_update(&state, input, len); - return XXH32_digest(&state); -#else - XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; - - if (XXH_FORCE_ALIGN_CHECK) { - if ((((size_t)input) & 3) == 0) { /* Input is 4-bytes aligned, leverage the speed benefit */ - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); - else - return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); - } } - - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); - else - return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); -#endif -} - - - -/*====== Hash streaming ======*/ - -XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void) -{ - return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t)); -} -XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr) -{ - XXH_free(statePtr); - return XXH_OK; -} - -XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState) -{ - memcpy(dstState, srcState, sizeof(*dstState)); -} - -XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed) -{ - XXH32_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */ - memset(&state, 0, sizeof(state)-4); /* do not write into reserved, for future removal */ - state.v1 = seed + PRIME32_1 + PRIME32_2; - state.v2 = seed + PRIME32_2; - state.v3 = seed + 0; - state.v4 = seed - PRIME32_1; - memcpy(statePtr, &state, sizeof(state)); - return XXH_OK; -} - - -FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian) -{ - const BYTE* p = (const BYTE*)input; - const BYTE* const bEnd = p + len; - -#ifdef XXH_ACCEPT_NULL_INPUT_POINTER - if (input==NULL) return XXH_ERROR; -#endif - - state->total_len_32 += (unsigned)len; - state->large_len |= (len>=16) | (state->total_len_32>=16); - - if (state->memsize + len < 16) { /* fill in tmp buffer */ - XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len); - state->memsize += (unsigned)len; - return XXH_OK; - } - - if (state->memsize) { /* some data left from previous update */ - XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize); - { const U32* p32 = state->mem32; - state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++; - state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++; - state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++; - state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); - } - p += 16-state->memsize; - state->memsize = 0; - } - - if (p <= bEnd-16) { - const BYTE* const limit = bEnd - 16; - U32 v1 = state->v1; - U32 v2 = state->v2; - U32 v3 = state->v3; - U32 v4 = state->v4; - - do { - v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4; - v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4; - v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4; - v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4; - } while (p<=limit); - - state->v1 = v1; - state->v2 = v2; - state->v3 = v3; - state->v4 = v4; - } - - if (p < bEnd) { - XXH_memcpy(state->mem32, p, (size_t)(bEnd-p)); - state->memsize = (unsigned)(bEnd-p); - } - - return XXH_OK; -} - -XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len) -{ - XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; - - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH32_update_endian(state_in, input, len, XXH_littleEndian); - else - return XXH32_update_endian(state_in, input, len, XXH_bigEndian); -} - - - -FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian) -{ - const BYTE * p = (const BYTE*)state->mem32; - const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize; - U32 h32; - - if (state->large_len) { - h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18); - } else { - h32 = state->v3 /* == seed */ + PRIME32_5; - } - - h32 += state->total_len_32; - - while (p+4<=bEnd) { - h32 += XXH_readLE32(p, endian) * PRIME32_3; - h32 = XXH_rotl32(h32, 17) * PRIME32_4; - p+=4; - } - - while (p> 15; - h32 *= PRIME32_2; - h32 ^= h32 >> 13; - h32 *= PRIME32_3; - h32 ^= h32 >> 16; - - return h32; -} - - -XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in) -{ - XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; - - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH32_digest_endian(state_in, XXH_littleEndian); - else - return XXH32_digest_endian(state_in, XXH_bigEndian); -} - - -/*====== Canonical representation ======*/ - -/*! Default XXH result types are basic unsigned 32 and 64 bits. -* The canonical representation follows human-readable write convention, aka big-endian (large digits first). -* These functions allow transformation of hash result into and from its canonical format. -* This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs. -*/ - -XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash) -{ - XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t)); - if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash); - memcpy(dst, &hash, sizeof(*dst)); -} - -XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src) -{ - return XXH_readBE32(src); -} - - -#ifndef XXH_NO_LONG_LONG - -/* ******************************************************************* -* 64-bits hash functions -*********************************************************************/ - -/*====== Memory access ======*/ - -#ifndef MEM_MODULE -# define MEM_MODULE -# if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) -# include - typedef uint64_t U64; -# else - typedef unsigned long long U64; /* if your compiler doesn't support unsigned long long, replace by another 64-bit type here. Note that xxhash.h will also need to be updated. */ -# endif -#endif - - -#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2)) - -/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */ -static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; } - -#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1)) - -/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ -/* currently only defined for gcc and icc */ -typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign64; -static U64 XXH_read64(const void* ptr) { return ((const unalign64*)ptr)->u64; } - -#else - -/* portable and safe solution. Generally efficient. - * see : http://stackoverflow.com/a/32095106/646947 - */ - -static U64 XXH_read64(const void* memPtr) -{ - U64 val; - memcpy(&val, memPtr, sizeof(val)); - return val; -} - -#endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */ - -#if defined(_MSC_VER) /* Visual Studio */ -# define XXH_swap64 _byteswap_uint64 -#elif XXH_GCC_VERSION >= 403 -# define XXH_swap64 __builtin_bswap64 -#else -static U64 XXH_swap64 (U64 x) -{ - return ((x << 56) & 0xff00000000000000ULL) | - ((x << 40) & 0x00ff000000000000ULL) | - ((x << 24) & 0x0000ff0000000000ULL) | - ((x << 8) & 0x000000ff00000000ULL) | - ((x >> 8) & 0x00000000ff000000ULL) | - ((x >> 24) & 0x0000000000ff0000ULL) | - ((x >> 40) & 0x000000000000ff00ULL) | - ((x >> 56) & 0x00000000000000ffULL); -} -#endif - -FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align) -{ - if (align==XXH_unaligned) - return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr)); - else - return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr); -} - -FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian) -{ - return XXH_readLE64_align(ptr, endian, XXH_unaligned); -} - -static U64 XXH_readBE64(const void* ptr) -{ - return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr); -} - - -/*====== xxh64 ======*/ - -static const U64 PRIME64_1 = 11400714785074694791ULL; -static const U64 PRIME64_2 = 14029467366897019727ULL; -static const U64 PRIME64_3 = 1609587929392839161ULL; -static const U64 PRIME64_4 = 9650029242287828579ULL; -static const U64 PRIME64_5 = 2870177450012600261ULL; - -static U64 XXH64_round(U64 acc, U64 input) -{ - acc += input * PRIME64_2; - acc = XXH_rotl64(acc, 31); - acc *= PRIME64_1; - return acc; -} - -static U64 XXH64_mergeRound(U64 acc, U64 val) -{ - val = XXH64_round(0, val); - acc ^= val; - acc = acc * PRIME64_1 + PRIME64_4; - return acc; -} - -FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align) -{ - const BYTE* p = (const BYTE*)input; - const BYTE* bEnd = p + len; - U64 h64; -#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align) - -#ifdef XXH_ACCEPT_NULL_INPUT_POINTER - if (p==NULL) { - len=0; - bEnd=p=(const BYTE*)(size_t)32; - } -#endif - - if (len>=32) { - const BYTE* const limit = bEnd - 32; - U64 v1 = seed + PRIME64_1 + PRIME64_2; - U64 v2 = seed + PRIME64_2; - U64 v3 = seed + 0; - U64 v4 = seed - PRIME64_1; - - do { - v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8; - v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8; - v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8; - v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8; - } while (p<=limit); - - h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); - h64 = XXH64_mergeRound(h64, v1); - h64 = XXH64_mergeRound(h64, v2); - h64 = XXH64_mergeRound(h64, v3); - h64 = XXH64_mergeRound(h64, v4); - - } else { - h64 = seed + PRIME64_5; - } - - h64 += (U64) len; - - while (p+8<=bEnd) { - U64 const k1 = XXH64_round(0, XXH_get64bits(p)); - h64 ^= k1; - h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; - p+=8; - } - - if (p+4<=bEnd) { - h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; - h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; - p+=4; - } - - while (p> 33; - h64 *= PRIME64_2; - h64 ^= h64 >> 29; - h64 *= PRIME64_3; - h64 ^= h64 >> 32; - - return h64; -} - - -XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed) -{ -#if 0 - /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ - XXH64_state_t state; - XXH64_reset(&state, seed); - XXH64_update(&state, input, len); - return XXH64_digest(&state); -#else - XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; - - if (XXH_FORCE_ALIGN_CHECK) { - if ((((size_t)input) & 7)==0) { /* Input is aligned, let's leverage the speed advantage */ - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); - else - return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); - } } - - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); - else - return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); -#endif -} - -/*====== Hash Streaming ======*/ - -XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void) -{ - return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t)); -} -XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr) -{ - XXH_free(statePtr); - return XXH_OK; -} - -XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState) -{ - memcpy(dstState, srcState, sizeof(*dstState)); -} - -XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed) -{ - XXH64_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */ - memset(&state, 0, sizeof(state)-8); /* do not write into reserved, for future removal */ - state.v1 = seed + PRIME64_1 + PRIME64_2; - state.v2 = seed + PRIME64_2; - state.v3 = seed + 0; - state.v4 = seed - PRIME64_1; - memcpy(statePtr, &state, sizeof(state)); - return XXH_OK; -} - -FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian) -{ - const BYTE* p = (const BYTE*)input; - const BYTE* const bEnd = p + len; - -#ifdef XXH_ACCEPT_NULL_INPUT_POINTER - if (input==NULL) return XXH_ERROR; -#endif - - state->total_len += len; - - if (state->memsize + len < 32) { /* fill in tmp buffer */ - XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len); - state->memsize += (U32)len; - return XXH_OK; - } - - if (state->memsize) { /* tmp buffer is full */ - XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize); - state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian)); - state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian)); - state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian)); - state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian)); - p += 32-state->memsize; - state->memsize = 0; - } - - if (p+32 <= bEnd) { - const BYTE* const limit = bEnd - 32; - U64 v1 = state->v1; - U64 v2 = state->v2; - U64 v3 = state->v3; - U64 v4 = state->v4; - - do { - v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8; - v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8; - v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8; - v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8; - } while (p<=limit); - - state->v1 = v1; - state->v2 = v2; - state->v3 = v3; - state->v4 = v4; - } - - if (p < bEnd) { - XXH_memcpy(state->mem64, p, (size_t)(bEnd-p)); - state->memsize = (unsigned)(bEnd-p); - } - - return XXH_OK; -} - -XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len) -{ - XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; - - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH64_update_endian(state_in, input, len, XXH_littleEndian); - else - return XXH64_update_endian(state_in, input, len, XXH_bigEndian); -} - -FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian) -{ - const BYTE * p = (const BYTE*)state->mem64; - const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize; - U64 h64; - - if (state->total_len >= 32) { - U64 const v1 = state->v1; - U64 const v2 = state->v2; - U64 const v3 = state->v3; - U64 const v4 = state->v4; - - h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); - h64 = XXH64_mergeRound(h64, v1); - h64 = XXH64_mergeRound(h64, v2); - h64 = XXH64_mergeRound(h64, v3); - h64 = XXH64_mergeRound(h64, v4); - } else { - h64 = state->v3 + PRIME64_5; - } - - h64 += (U64) state->total_len; - - while (p+8<=bEnd) { - U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian)); - h64 ^= k1; - h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; - p+=8; - } - - if (p+4<=bEnd) { - h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1; - h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; - p+=4; - } - - while (p> 33; - h64 *= PRIME64_2; - h64 ^= h64 >> 29; - h64 *= PRIME64_3; - h64 ^= h64 >> 32; - - return h64; -} - -XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in) -{ - XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; - - if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) - return XXH64_digest_endian(state_in, XXH_littleEndian); - else - return XXH64_digest_endian(state_in, XXH_bigEndian); -} - - -/*====== Canonical representation ======*/ - -XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash) -{ - XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t)); - if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash); - memcpy(dst, &hash, sizeof(*dst)); -} - -XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src) -{ - return XXH_readBE64(src); -} - -#endif /* XXH_NO_LONG_LONG */ diff --git a/layers/xxhash.h b/layers/xxhash.h deleted file mode 100644 index 9d831e03..00000000 --- a/layers/xxhash.h +++ /dev/null @@ -1,293 +0,0 @@ -/* - xxHash - Extremely Fast Hash algorithm - Header File - Copyright (C) 2012-2016, Yann Collet. - - BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - xxHash source repository : https://github.com/Cyan4973/xxHash -*/ - -/* Notice extracted from xxHash homepage : - -xxHash is an extremely fast Hash algorithm, running at RAM speed limits. -It also successfully passes all tests from the SMHasher suite. - -Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz) - -Name Speed Q.Score Author -xxHash 5.4 GB/s 10 -CrapWow 3.2 GB/s 2 Andrew -MumurHash 3a 2.7 GB/s 10 Austin Appleby -SpookyHash 2.0 GB/s 10 Bob Jenkins -SBox 1.4 GB/s 9 Bret Mulvey -Lookup3 1.2 GB/s 9 Bob Jenkins -SuperFastHash 1.2 GB/s 1 Paul Hsieh -CityHash64 1.05 GB/s 10 Pike & Alakuijala -FNV 0.55 GB/s 5 Fowler, Noll, Vo -CRC32 0.43 GB/s 9 -MD5-32 0.33 GB/s 10 Ronald L. Rivest -SHA1-32 0.28 GB/s 10 - -Q.Score is a measure of quality of the hash function. -It depends on successfully passing SMHasher test set. -10 is a perfect score. - -A 64-bits version, named XXH64, is available since r35. -It offers much better speed, but for 64-bits applications only. -Name Speed on 64 bits Speed on 32 bits -XXH64 13.8 GB/s 1.9 GB/s -XXH32 6.8 GB/s 6.0 GB/s -*/ - -#ifndef XXHASH_H_5627135585666179 -#define XXHASH_H_5627135585666179 1 - -#if defined (__cplusplus) -extern "C" { -#endif - - -/* **************************** -* Definitions -******************************/ -#include /* size_t */ -typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; - - -/* **************************** -* API modifier -******************************/ -/** XXH_PRIVATE_API -* This is useful to include xxhash functions in `static` mode -* in order to inline them, and remove their symbol from the public list. -* Methodology : -* #define XXH_PRIVATE_API -* #include "xxhash.h" -* `xxhash.c` is automatically included. -* It's not useful to compile and link it as a separate module. -*/ -#ifdef XXH_PRIVATE_API -# ifndef XXH_STATIC_LINKING_ONLY -# define XXH_STATIC_LINKING_ONLY -# endif -# if defined(__GNUC__) -# define XXH_PUBLIC_API static __inline __attribute__((unused)) -# elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) -# define XXH_PUBLIC_API static inline -# elif defined(_MSC_VER) -# define XXH_PUBLIC_API static __inline -# else -# define XXH_PUBLIC_API static /* this version may generate warnings for unused static functions; disable the relevant warning */ -# endif -#else -# define XXH_PUBLIC_API /* do nothing */ -#endif /* XXH_PRIVATE_API */ - -/*!XXH_NAMESPACE, aka Namespace Emulation : - -If you want to include _and expose_ xxHash functions from within your own library, -but also want to avoid symbol collisions with other libraries which may also include xxHash, - -you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library -with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values). - -Note that no change is required within the calling program as long as it includes `xxhash.h` : -regular symbol name will be automatically translated by this header. -*/ -#ifdef XXH_NAMESPACE -# define XXH_CAT(A,B) A##B -# define XXH_NAME2(A,B) XXH_CAT(A,B) -# define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber) -# define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32) -# define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState) -# define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState) -# define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset) -# define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update) -# define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest) -# define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState) -# define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash) -# define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical) -# define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64) -# define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState) -# define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState) -# define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset) -# define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update) -# define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest) -# define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState) -# define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash) -# define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical) -#endif - - -/* ************************************* -* Version -***************************************/ -#define XXH_VERSION_MAJOR 0 -#define XXH_VERSION_MINOR 6 -#define XXH_VERSION_RELEASE 2 -#define XXH_VERSION_NUMBER (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE) -XXH_PUBLIC_API unsigned XXH_versionNumber (void); - - -/*-********************************************************************** -* 32-bits hash -************************************************************************/ -typedef unsigned int XXH32_hash_t; - -/*! XXH32() : - Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input". - The memory between input & input+length must be valid (allocated and read-accessible). - "seed" can be used to alter the result predictably. - Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */ -XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed); - -/*====== Streaming ======*/ -typedef struct XXH32_state_s XXH32_state_t; /* incomplete type */ -XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void); -XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr); -XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state); - -XXH_PUBLIC_API XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, unsigned int seed); -XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length); -XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr); - -/* -These functions generate the xxHash of an input provided in multiple segments. -Note that, for small input, they are slower than single-call functions, due to state management. -For small input, prefer `XXH32()` and `XXH64()` . - -XXH state must first be allocated, using XXH*_createState() . - -Start a new hash by initializing state with a seed, using XXH*_reset(). - -Then, feed the hash state by calling XXH*_update() as many times as necessary. -Obviously, input must be allocated and read accessible. -The function returns an error code, with 0 meaning OK, and any other value meaning there is an error. - -Finally, a hash value can be produced anytime, by using XXH*_digest(). -This function returns the nn-bits hash as an int or long long. - -It's still possible to continue inserting input into the hash state after a digest, -and generate some new hashes later on, by calling again XXH*_digest(). - -When done, free XXH state space if it was allocated dynamically. -*/ - -/*====== Canonical representation ======*/ - -typedef struct { unsigned char digest[4]; } XXH32_canonical_t; -XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash); -XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src); - -/* Default result type for XXH functions are primitive unsigned 32 and 64 bits. -* The canonical representation uses human-readable write convention, aka big-endian (large digits first). -* These functions allow transformation of hash result into and from its canonical format. -* This way, hash values can be written into a file / memory, and remain comparable on different systems and programs. -*/ - - -#ifndef XXH_NO_LONG_LONG -/*-********************************************************************** -* 64-bits hash -************************************************************************/ -typedef unsigned long long XXH64_hash_t; - -/*! XXH64() : - Calculate the 64-bits hash of sequence of length "len" stored at memory address "input". - "seed" can be used to alter the result predictably. - This function runs faster on 64-bits systems, but slower on 32-bits systems (see benchmark). -*/ -XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed); - -/*====== Streaming ======*/ -typedef struct XXH64_state_s XXH64_state_t; /* incomplete type */ -XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void); -XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr); -XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state); - -XXH_PUBLIC_API XXH_errorcode XXH64_reset (XXH64_state_t* statePtr, unsigned long long seed); -XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length); -XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* statePtr); - -/*====== Canonical representation ======*/ -typedef struct { unsigned char digest[8]; } XXH64_canonical_t; -XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash); -XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src); -#endif /* XXH_NO_LONG_LONG */ - - -#ifdef XXH_STATIC_LINKING_ONLY - -/* ================================================================================================ - This section contains definitions which are not guaranteed to remain stable. - They may change in future versions, becoming incompatible with a different version of the library. - They shall only be used with static linking. - Never use these definitions in association with dynamic linking ! -=================================================================================================== */ - -/* These definitions are only meant to make possible - static allocation of XXH state, on stack or in a struct for example. - Never use members directly. */ - -struct XXH32_state_s { - unsigned total_len_32; - unsigned large_len; - unsigned v1; - unsigned v2; - unsigned v3; - unsigned v4; - unsigned mem32[4]; /* buffer defined as U32 for alignment */ - unsigned memsize; - unsigned reserved; /* never read nor write, will be removed in a future version */ -}; /* typedef'd to XXH32_state_t */ - -#ifndef XXH_NO_LONG_LONG /* remove 64-bits support */ -struct XXH64_state_s { - unsigned long long total_len; - unsigned long long v1; - unsigned long long v2; - unsigned long long v3; - unsigned long long v4; - unsigned long long mem64[4]; /* buffer defined as U64 for alignment */ - unsigned memsize; - unsigned reserved[2]; /* never read nor write, will be removed in a future version */ -}; /* typedef'd to XXH64_state_t */ -#endif - -#ifdef XXH_PRIVATE_API -# include "xxhash.c" /* include xxhash function bodies as `static`, for inlining */ -#endif - -#endif /* XXH_STATIC_LINKING_ONLY */ - - -#if defined (__cplusplus) -} -#endif - -#endif /* XXHASH_H_5627135585666179 */ diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt deleted file mode 100644 index d83d75df..00000000 --- a/loader/CMakeLists.txt +++ /dev/null @@ -1,307 +0,0 @@ -include_directories( - ${CMAKE_CURRENT_SOURCE_DIR} - ${CMAKE_CURRENT_BINARY_DIR} - ${PROJECT_BINARY_DIR} - ${CMAKE_BINARY_DIR} -) - -# Check for the existance of the secure_getenv or __secure_getenv commands -include(CheckFunctionExists) -CHECK_FUNCTION_EXISTS(secure_getenv HAVE_SECURE_GETENV) -CHECK_FUNCTION_EXISTS(__secure_getenv HAVE___SECURE_GETENV) -CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/loader_cmake_config.h.in ${CMAKE_CURRENT_BINARY_DIR}/loader_cmake_config.h) - -# Fetch header version from vulkan_core.h -file(STRINGS "../include/vulkan/vulkan_core.h" lines REGEX "^#define VK_HEADER_VERSION [0-9]+") -list(LENGTH lines len) -if(${len} EQUAL 1) - string(REGEX MATCHALL "[0-9]+" vk_header_version ${lines}) -else() - MESSAGE(FATAL_ERROR "Unable to fetch version from vulkan.h") -endif() - -if(CMAKE_SYSTEM_NAME STREQUAL "Windows") - add_definitions(-DVK_USE_PLATFORM_WIN32_KHR -DWIN32_LEAN_AND_MEAN) - set(DisplayServer Win32) - if (NOT MSVC_VERSION LESS 1900) - # Enable control flow guard - message(STATUS "Building loader with control flow guard") - add_compile_options("$<$:/guard:cf>") - set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /guard:cf") - set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /guard:cf") - endif() -elseif(CMAKE_SYSTEM_NAME STREQUAL "Android") - add_definitions(-DVK_USE_PLATFORM_ANDROID_KHR) -elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") - if (BUILD_WSI_XCB_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_XCB_KHR) - endif() - - if (BUILD_WSI_XLIB_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_XLIB_KHR -DVK_USE_PLATFORM_XLIB_XRANDR_EXT) - endif() - - if (BUILD_WSI_WAYLAND_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR) - endif() - - if (BUILD_WSI_MIR_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_MIR_KHR) - include_directories(${MIR_INCLUDE_DIR}) - endif() -elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") - add_definitions(-DVK_USE_PLATFORM_MACOS_MVK) -else() - message(FATAL_ERROR "Unsupported Platform!") -endif() - -if (WIN32) - FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/vulkan-${MAJOR}.def DEF_FILE) - FILE(READ ${DEF_FILE} DEF_TEXT) - STRING(REGEX REPLACE "vulkan-${MAJOR}.dll" "${API_LOWERCASE}-${MAJOR}.dll" DEF_EDITED "${DEF_TEXT}" ) - FILE(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${API_LOWERCASE}-${MAJOR}.def" "${DEF_EDITED}") -endif() - -# DEBUG enables runtime loader ICD verification -set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG") -set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG") - -set(NORMAL_LOADER_SRCS - extension_manual.c - loader.c - loader.h - vk_loader_platform.h - vk_loader_layer.h - trampoline.c - wsi.c - wsi.h - debug_utils.c - debug_utils.h - gpa_helper.h - cJSON.c - cJSON.h - murmurhash.c - murmurhash.h -) - -set(OPT_LOADER_SRCS - dev_ext_trampoline.c - phys_dev_ext.c -) - -# Check for assembler support -set(ASM_FAILURE_MSG "The build will fall back on building with C code\n") -set(ASM_FAILURE_MSG "${ASM_FAILURE_MSG}Note that this may be unsafe, as the C code requires tail-call optimizations to remove") -set(ASM_FAILURE_MSG "${ASM_FAILURE_MSG} the stack frame for certain calls. If the compiler does not do this, then unknown device") -set(ASM_FAILURE_MSG "${ASM_FAILURE_MSG} extensions will suffer from a corrupted stack.") -if (WIN32) - enable_language(ASM_MASM) - if (CMAKE_ASM_MASM_COMPILER_WORKS) - if (NOT CMAKE_CL_64) - set(CMAKE_ASM_MASM_FLAGS ${CMAKE_ASM_MASM_FLAGS} /safeseh) - endif() - set(OPT_LOADER_SRCS ${OPT_LOADER_SRCS} unknown_ext_chain_masm.asm) - - add_executable(asm_offset asm_offset.c) - add_dependencies(asm_offset generate_helper_files loader_gen_files) - add_custom_command(OUTPUT gen_defines.asm DEPENDS asm_offset COMMAND asm_offset MASM) - add_custom_target(loader_asm_gen_files DEPENDS gen_defines.asm) - set_target_properties(loader_asm_gen_files PROPERTIES FOLDER ${LVL_TARGET_FOLDER}) - else() - message(WARNING "Could not find working MASM assebler\n${ASM_FAILURE_MSG}") - set(OPT_LOADER_SRCS ${OPT_LOADER_SRCS} unknown_ext_chain.c) - add_custom_target(loader_asm_gen_files) - endif() -elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") - # For MacOS, use the C code and force the compiler's tail-call optimization instead of using assembly code. - set(OPT_LOADER_SRCS ${OPT_LOADER_SRCS} unknown_ext_chain.c) - set_source_files_properties(${OPT_LOADER_SRCS} PROPERTIES COMPILE_FLAGS -O) - add_custom_target(loader_asm_gen_files) # This causes no assembly files to be generated. -else() - enable_language(ASM-ATT) - set(CMAKE_ASM-ATT_COMPILE_FLAGS "${CMAKE_ASM-ATT_COMPILE_FLAGS} $ENV{ASFLAGS}") - set(CMAKE_ASM-ATT_COMPILE_FLAGS "${CMAKE_ASM-ATT_COMPILE_FLAGS} -I\"${CMAKE_CURRENT_BINARY_DIR}\"") - - file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/asm_test.asm ".intel_syntax noprefix\n.text\n.global sample\nsample:\nmov ecx, [eax + 16]\n") - try_compile(ASSEMBLER_WORKS ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/asm_test.asm) - file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/asm_test.asm) - if (ASSEMBLER_WORKS) - set(CMAKE_ASM-ATT_FLAGS "$ENV{ASFLAGS} -I\"${CMAKE_CURRENT_BINARY_DIR}\"") - set(OPT_LOADER_SRCS ${OPT_LOADER_SRCS} unknown_ext_chain_gas.asm) - add_executable(asm_offset asm_offset.c) - add_dependencies(asm_offset generate_helper_files loader_gen_files) - add_custom_command(OUTPUT gen_defines.asm DEPENDS asm_offset COMMAND asm_offset GAS) - add_custom_target(loader_asm_gen_files DEPENDS gen_defines.asm) - else() - message(WARNING "Could not find working x86 GAS assembler\n${ASM_FAILURE_MSG}") - set(OPT_LOADER_SRCS ${OPT_LOADER_SRCS} unknown_ext_chain.c) - add_custom_target(loader_asm_gen_files) - endif() -endif() - -run_vk_xml_generate(loader_extension_generator.py vk_loader_extensions.h) -run_vk_xml_generate(loader_extension_generator.py vk_loader_extensions.c) -add_custom_target(loader_gen_files DEPENDS - vk_loader_extensions.h - vk_loader_extensions.c - ) -set_target_properties(loader_gen_files PROPERTIES FOLDER ${LVL_TARGET_FOLDER}) - -if (WIN32) - # Use static MSVCRT libraries - foreach(configuration in CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO - CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELWITHDEBINFO) - if(${configuration} MATCHES "/MD") - string(REGEX REPLACE "/MD" "/MT" ${configuration} "${${configuration}}") - endif() - endforeach() - - if (ENABLE_WIN10_ONECORE) - # Note When linking your app or driver to OneCore.lib, be sure to remove any links to non-umbrella libs (such as kernel32.lib). - set(CMAKE_CXX_STANDARD_LIBRARIES " ") # space is intentional - set(CMAKE_C_STANDARD_LIBRARIES ${CMAKE_CXX_STANDARD_LIBRARIES}) - endif() - - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS") - # Build dev_ext_trampoline.c with -O2 to allow tail-call optimization. - # Build other C files with normal options - # setup two Cmake targets (loader-norm and loader-opt) for the different compilation flags - separate_arguments(LOCAL_C_FLAGS_DBG WINDOWS_COMMAND ${CMAKE_C_FLAGS_DEBUG}) - set(CMAKE_C_FLAGS_DEBUG " ") - separate_arguments(LOCAL_C_FLAGS_REL WINDOWS_COMMAND ${CMAKE_C_FLAGS_RELEASE}) - - add_library(loader-norm-dy OBJECT ${NORMAL_LOADER_SRCS} dirent_on_windows.c) - add_dependencies(loader-norm-dy generate_helper_files loader_gen_files) - target_compile_definitions(loader-norm-dy PUBLIC LOADER_DYNAMIC_LIB) - target_compile_options(loader-norm-dy PUBLIC "$<$:${LOCAL_C_FLAGS_DBG}>") - - add_library(loader-opt-dy OBJECT ${OPT_LOADER_SRCS}) - add_dependencies(loader-opt-dy generate_helper_files loader_gen_files loader_asm_gen_files) - target_compile_definitions(loader-opt-dy PUBLIC LOADER_DYNAMIC_LIB) - target_compile_options(loader-opt-dy PUBLIC "$<$:${LOCAL_C_FLAGS_REL}>") - - add_library(loader-norm-st OBJECT ${NORMAL_LOADER_SRCS} dirent_on_windows.c) - add_dependencies(loader-norm-st generate_helper_files loader_gen_files) - target_compile_options(loader-norm-st PUBLIC "$<$:${LOCAL_C_FLAGS_DBG}>") - - add_library(loader-opt-st OBJECT ${OPT_LOADER_SRCS}) - add_dependencies(loader-opt-st generate_helper_files loader_gen_files loader_asm_gen_files) - target_compile_options(loader-opt-st PUBLIC "$<$:${LOCAL_C_FLAGS_REL}>") - - add_library(${API_LOWERCASE}-${MAJOR} SHARED $ $ ${CMAKE_CURRENT_BINARY_DIR}/${API_LOWERCASE}-${MAJOR}.def ${CMAKE_CURRENT_SOURCE_DIR}/loader.rc) - add_library(VKstatic.${MAJOR} STATIC $ $) - # Suppress conflicting libs warning for debug builds. - set_target_properties(${API_LOWERCASE}-${MAJOR} PROPERTIES LINK_FLAGS_DEBUG /ignore:4098) - set_target_properties(VKstatic.${MAJOR} PROPERTIES OUTPUT_NAME VKstatic.${MAJOR}) - - if (ENABLE_WIN10_ONECORE) - target_link_libraries(${API_LOWERCASE}-${MAJOR} OneCoreUAP.lib LIBCMT.LIB LIBCMTD.LIB LIBVCRUNTIME.LIB LIBUCRT.LIB) - set_target_properties(${API_LOWERCASE}-${MAJOR} PROPERTIES LINK_FLAGS "/NODEFAULTLIB") - else() - target_link_libraries(${API_LOWERCASE}-${MAJOR} Cfgmgr32) - endif() - - add_dependencies(${API_LOWERCASE}-${MAJOR} generate_helper_files loader_gen_files loader_asm_gen_files) - - if (CMAKE_GENERATOR MATCHES "^Visual Studio.*") - file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/$/${API_LOWERCASE}-${MAJOR}.dll COPY_SRC_PATH) - file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/../demos/$/ COPY_DST_PATH) - file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/../tests/$/ COPY_DST_TEST_PATH) - else() - file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/${API_LOWERCASE}-${MAJOR}.dll COPY_SRC_PATH) - file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/../demos/ COPY_DST_PATH) - file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/../tests/ COPY_DST_TEST_PATH) - endif() - add_custom_command(TARGET ${API_LOWERCASE}-${MAJOR} POST_BUILD - COMMAND xcopy /Y /I ${COPY_SRC_PATH} ${COPY_DST_PATH}) - add_custom_command(TARGET ${API_LOWERCASE}-${MAJOR} POST_BUILD - COMMAND xcopy /Y /I ${COPY_SRC_PATH} ${COPY_DST_TEST_PATH}) - -else() - # Linux and MacOS - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wpointer-arith") - - # Clang (and not gcc) warns about redefining a typedef with the same types, so disable that warning. - # Note that it will still throw an error if a typedef is redefined with a different type. - if (CMAKE_C_COMPILER_ID MATCHES "Clang") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-typedef-redefinition") - endif() - - add_library(${API_LOWERCASE} SHARED ${NORMAL_LOADER_SRCS} ${OPT_LOADER_SRCS}) - add_dependencies(${API_LOWERCASE} generate_helper_files loader_gen_files loader_asm_gen_files) - target_compile_definitions(${API_LOWERCASE} PUBLIC -DLOADER_DYNAMIC_LIB) - set_target_properties(${API_LOWERCASE} PROPERTIES SOVERSION "1" VERSION "1.1.${vk_header_version}") - target_link_libraries(${API_LOWERCASE} -ldl -lpthread -lm) - - if(APPLE) - find_library(COREFOUNDATION_LIBRARY NAMES CoreFoundation) - target_link_libraries(${API_LOWERCASE} "-framework CoreFoundation") - - # Build vulkan.framework - set(FRAMEWORK_HEADERS - ${PROJECT_SOURCE_DIR}/include/vulkan/vk_icd.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vk_layer.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vk_platform.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vk_sdk_platform.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_android.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_core.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_ios.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_macos.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_mir.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_vi.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_wayland.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_win32.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_xcb.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_xlib.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan_xlib_xrandr.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan.h - ${PROJECT_SOURCE_DIR}/include/vulkan/vulkan.hpp - ) - add_library(vulkan-framework SHARED ${NORMAL_LOADER_SRCS} ${OPT_LOADER_SRCS} ${FRAMEWORK_HEADERS}) - add_dependencies(vulkan-framework generate_helper_files loader_gen_files loader_asm_gen_files) - target_compile_definitions(vulkan-framework PUBLIC -DLOADER_DYNAMIC_LIB) - target_link_libraries(vulkan-framework -ldl -lpthread -lm "-framework CoreFoundation") - - # The FRAMEWORK_VERSION needs to be "A" here so that Xcode code-signing works when - # a user adds their framework to an Xcode project and does "Sign on Copy". - # It would have been nicer to use "1" to denote Vulkan 1. - # Although Apple docs say that a framework version does not have to be "A", - # this part of the Apple toolchain expects it. - # https://forums.developer.apple.com/thread/65963 - set_target_properties(vulkan-framework PROPERTIES - OUTPUT_NAME vulkan - FRAMEWORK TRUE - FRAMEWORK_VERSION A - VERSION "1.1.${vk_header_version}" # "current version" - SOVERSION "1.0.0" # "compatibility version" - MACOSX_FRAMEWORK_IDENTIFIER com.lunarg.vulkanFramework - PUBLIC_HEADER "${FRAMEWORK_HEADERS}" - ) - install(TARGETS vulkan-framework - PUBLIC_HEADER DESTINATION vulkan - FRAMEWORK DESTINATION loader - ) - endif(APPLE) - - if(INSTALL_LVL_FILES) - install(TARGETS ${API_LOWERCASE} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) - endif() - - if(NOT APPLE) - # Generate pkg-config file. - include(FindPkgConfig QUIET) - if(PKG_CONFIG_FOUND) - set(VK_API_VERSION "1.1.${vk_header_version}") - foreach(LIB ${CMAKE_CXX_IMPLICIT_LINK_LIBRARIES} ${PLATFORM_LIBS}) - set(PRIVATE_LIBS "${PRIVATE_LIBS} -l${LIB}") - endforeach() - configure_file("vulkan.pc.in" "vulkan.pc" @ONLY) - if(INSTALL_LVL_FILES) - install(FILES "${CMAKE_CURRENT_BINARY_DIR}/vulkan.pc" - DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") - endif() - endif() - endif() -endif() - - diff --git a/loader/LoaderAndLayerInterface.md b/loader/LoaderAndLayerInterface.md deleted file mode 100644 index 2313ad03..00000000 --- a/loader/LoaderAndLayerInterface.md +++ /dev/null @@ -1,2756 +0,0 @@ -# Architecture of the Vulkan Loader Interfaces - -## Table of Contents - * [Overview](#overview) - * [Who Should Read This Document](#who-should-read-this-document) - * [The Loader](#the-loader) - * [Layers](#layers) - * [Installable Client Drivers](#installable-client-drivers) - * [Instance Versus Device](#instance-versus-device) - * [Dispatch Tables and Call Chains](#dispatch-tables-and-call-chains) - - * [Application Interface to the Loader](#application-interface-to-the-loader) - * [Interfacing with Vulkan Functions](#interfacing-with-vulkan-functions) - * [Application Layer Usage](#application-layer-usage) - * [Application Usage of Extensions](#application-usage-of-extensions) - - * [Loader and Layer Interface](#loader-and-layer-interface) - * [Layer Discovery](#layer-discovery) - * [Layer Version Negotiation](#layer-version-negotiation) - * [Layer Call Chains and Distributed Dispatch](#layer-call-chains-and-distributed-dispatch) - * [Layer Unknown Physical Device Extensions](#layer-unknown-physical-device-extensions) - * [Layer Intercept Requirements](#layer-intercept-requirements) - * [Distributed Dispatching Requirements](#distributed-dispatching-requirements) - * [Layer Conventions and Rules](#layer-conventions-and-rules) - * [Layer Dispatch Initialization](#layer-dispatch-initialization) - * [Example Code for CreateInstance](#example-code-for-createinstance) - * [Example Code for CreateDevice](#example-code-for-createdevice) - * [Meta-layers](#meta-layers) - * [Pre-Instance Functions](#pre-instance-functions) - * [Special Considerations](#special-considerations) - * [Layer Manifest File Format](#layer-manifest-file-format) - * [Layer Library Versions](#layer-library-versions) - - * [Vulkan Installable Client Driver interface with the loader](#vulkan-installable-client-driver-interface-with-the-loader) - * [ICD Discovery](#icd-discovery) - * [ICD Manifest File Format](#icd-manifest-file-format) - * [ICD Vulkan Entry-Point Discovery](#icd-vulkan-entry-point-discovery) - * [ICD API Version](#icd-api-version) - * [ICD Unknown Physical Device Extensions](#icd-unknown-physical-device-extensions) - * [ICD Dispatchable Object Creation](#icd-dispatchable-object-creation) - * [Handling KHR Surface Objects in WSI Extensions](#handling-khr-surface-objects-in-wsi-extensions) - * [Loader and ICD Interface Negotiation](#loader-and-icd-interface-negotiation) - - * [Table of Debug Environment Variables](#table-of-debug-environment-variables) - * [Glossary of Terms](#glossary-of-terms) - -## Overview - -Vulkan is a layered architecture, made up of the following elements: - * The Vulkan Application - * [The Vulkan Loader](#the-loader) - * [Vulkan Layers](#layers) - * [Installable Client Drivers (ICDs)](#installable-client-drivers) - -![High Level View of Loader](./images/high_level_loader.png) - -The general concepts in this document are applicable to the loaders available -for Windows, Linux, Android and MacOS based systems. - - -#### Who Should Read This Document - -While this document is primarily targeted at developers of Vulkan applications, -drivers and layers, the information contained in it could be useful to anyone -wanting a better understanding of the Vulkan runtime. - - -#### The Loader - -The application sits on one end of, and interfaces directly with, the -loader. On the other end of the loader from the application are the ICDs, which -control the Vulkan-capable hardware. An important point to remember is that -Vulkan-capable hardware can be graphics-based, compute-based, or both. Between -the application and the ICDs the loader can inject a number of optional -[layers](#layers) that provide special functionality. - -The loader is responsible for working with the various layers as well as -supporting multiple GPUs and their drivers. Any Vulkan function may -wind up calling into a diverse set of modules: loader, layers, and ICDs. -The loader is critical to managing the proper dispatching of Vulkan -functions to the appropriate set of layers and ICDs. The Vulkan object -model allows the loader to insert layers into a call chain so that the layers -can process Vulkan functions prior to the ICD being called. - -This document is intended to provide an overview of the necessary interfaces -between each of these. - - -##### Goals of the Loader - -The loader was designed with the following goals in mind. - 1. Support one or more Vulkan-capable ICD on a user's computer system without -them interfering with one another. - 2. Support Vulkan Layers which are optional modules that can be enabled by an -application, developer, or standard system settings. - 3. Impact the overall performance of a Vulkan application in the lowest -possible fashion. - - -#### Layers - -Layers are optional components that augment the Vulkan system. They can -intercept, evaluate, and modify existing Vulkan functions on their way from the -application down to the hardware. Layers are implemented as libraries that can -be enabled in different ways (including by application request) and are loaded -during CreateInstance. Each layer can choose to hook (intercept) any Vulkan -functions which in turn can be ignored or augmented. A layer does not need to -intercept all Vulkan functions. It may choose to intercept all known functions, -or, it may choose to intercept only one function. - -Some examples of features that layers may expose include: - * Validating API usage - * Adding the ability to perform Vulkan API tracing and debugging - * Overlay additional content on the applications surfaces - -Because layers are optionally, you may choose to enable layers for debugging -your application, but then disable any layer usage when you release your -product. - - -#### Installable Client Drivers - -Vulkan allows multiple Installable Client Drivers (ICDs) each supporting one -or more devices (represented by a Vulkan `VkPhysicalDevice` object) to be used -collectively. The loader is responsible for discovering available Vulkan ICDs on -the system. Given a list of available ICDs, the loader can enumerate all the -physical devices available for an application and return this information to -the application. - - -#### Instance Versus Device - -There is an important concept which you will see brought up repeatedly -throughout this document. Many functions, extensions, and other things in -Vulkan are separated into two main groups: - * Instance-related Objects - * Device-related Objects - - -##### Instance-related Objects - -A Vulkan Instance is a high-level construct used to provide Vulkan system-level -information, or functionality. Vulkan objects associated directly with an -instance are: - * `VkInstance` - * `VkPhysicalDevice` - -An Instance function is any Vulkan function which takes as its first parameter -either an object from the Instance list, or nothing at all. Some Vulkan -Instance functions are: - * `vkEnumerateInstanceExtensionProperties` - * `vkEnumeratePhysicalDevices` - * `vkCreateInstance` - * `vkDestroyInstance` - -You query Vulkan Instance functions using `vkGetInstanceProcAddr`. -`vkGetInstanceProcAddr` can be used to query either device or instance entry- -points in addition to all core entry-points. The returned function pointer is -valid for this Instance and any object created under this Instance (including -all `VkDevice` objects). - -Similarly, an Instance extension is a set of Vulkan Instance functions extending -the Vulkan language. These will be discussed in more detail later. - - -##### Device-related Objects - -A Vulkan Device, on the other-hand, is a logical identifier used to associate -functions with a particular physical device on a user's system. Vulkan -constructs associated directly with a device include: - * `VkDevice` - * `VkQueue` - * `VkCommandBuffer` - * Any dispatchable object that is a child of a one of the above. - -A Device function is any Vulkan function which takes any Device Object as its -first parameter. Some Vulkan Device functions are: - * `vkQueueSubmit` - * `vkBeginCommandBuffer` - * `vkCreateEvent` - -You can query Vulkan Device functions using either `vkGetInstanceProcAddr` or -`vkGetDeviceProcAddr`. If you choose to use `vkGetInstanceProcAddr`, it will -have an additional level built into the call chain, which will reduce -performance slightly. However, the function pointer returned can be used for -any device created later, as long as it is associated with the same Vulkan -Instance. If, instead you use `vkGetDeviceProcAddr`, the call chain will be more -optimized to the specific device, but it will **only** work for the device used -to query the function function pointer. Also, unlike `vkGetInstanceProcAddr`, -`vkGetDeviceProcAddr` can only be used on core Vulkan Device functions, or -Device extension functions. - -The best solution is to query Instance extension functions using -`vkGetInstanceProcAddr`, and to query Device extension functions using -`vkGetDeviceProcAddr`. See -[Best Application Performance Setup](#best-application-performance-setup) for -more information on this. - -As with Instance extensions, a Device extension is a set of Vulkan Device -functions extending the Vulkan language. You can read more about these later in -the document. - - -#### Dispatch Tables and Call Chains - -Vulkan uses an object model to control the scope of a particular action / -operation. The object to be acted on is always the first parameter of a Vulkan -call and is a dispatchable object (see Vulkan specification section 2.3 Object -Model). Under the covers, the dispatchable object handle is a pointer to a -structure, which in turn, contains a pointer to a dispatch table maintained by -the loader. This dispatch table contains pointers to the Vulkan functions -appropriate to that object. - -There are two types of dispatch tables the loader maintains: - - Instance Dispatch Table - - Created in the loader during the call to `vkCreateInstance` - - Device Dispatch Table - - Created in the loader during the call to `vkCreateDevice` - -At that time the application and/or system can specify optional layers to be -included. The loader will initialize the specified layers to create a call -chain for each Vulkan function and each entry of the dispatch table will point -to the first element of that chain. Thus, the loader builds an instance call -chain for each `VkInstance` that is created and a device call chain for each -`VkDevice` that is created. - -When an application calls a Vulkan function, this typically will first hit a -*trampoline* function in the loader. These *trampoline* functions are small, -simple functions that jump to the appropriate dispatch table entry for the -object they are given. Additionally, for functions in the instance call chain, -the loader has an additional function, called a *terminator*, which is called -after all enabled layers to marshall the appropriate information to all -available ICDs. - - -##### Instance Call Chain Example - -For example, the diagram below represents what happens in the call chain for -`vkCreateInstance`. After initializing the chain, the loader will call into the -first layer's `vkCreateInstance` which will call the next finally terminating in -the loader again where this function calls every ICD's `vkCreateInstance` and -saves the results. This allows every enabled layer for this chain to set up -what it needs based on the `VkInstanceCreateInfo` structure from the -application. - -![Instance Call Chain](./images/loader_instance_chain.png) - -This also highlights some of the complexity the loader must manage when using -instance call chains. As shown here, the loader's *terminator* must aggregate -information to and from multiple ICDs when they are present. This implies that -the loader has to be aware of any instance-level extensions which work on a -`VkInstance` to aggregate them correctly. - - -##### Device Call Chain Example - -Device call chains are created at `vkCreateDevice` and are generally simpler -because they deal with only a single device and the ICD can always be the -*terminator* of the chain. - -![Loader Device Call Chain](./images/loader_device_chain_loader.png) - - -
-
- -## Application Interface to the Loader - -In this section we'll discuss how an application interacts with the loader, -including: - * [Interfacing with Vulkan Functions](#interfacing-with-vulkan-functions) - * [Vulkan Direct Exports](#vulkan-direct-exports) - * [Directly Linking to the Loader](#directly-linking-to-the-loader) - * [Dynamic Linking](#dynamic-linking) - * [Static Linking](#static-linking) - * [Indirectly Linking to the Loader](#indirectly-linking-to-the-loader) - * [Best Application Performance Setup](#best-application-performance-setup) - * [ABI Versioning](#abi-versioning) - * [Application Layer Usage](#application-layer-usage) - * [Implicit vs Explicit Layers](#implicit-vs-explicit-layers) - * [Forcing Layer Source Folders](#forcing-layer-source-folders) - * [Forcing Layers to be Enabled](#forcing-layers-to-be-enabled) - * [Overall Layer Ordering](#overall-layer-ordering) - * [Application Usage of Extensions](#application-usage-of-extensions) - * [Instance and Device Extensions](#instance-and-device-extensions) - * [WSI Extensions](#wsi-extensions) - * [Unknown Extensions](#unknown-extensions) - - -#### Interfacing with Vulkan Functions -There are several ways you can interface with Vulkan functions through the -loader. - - -##### Vulkan Direct Exports -The loader library on Windows, Linux, Android and MacOS will export all core Vulkan -and all appropriate Window System Interface (WSI) extensions. This is done to -make it simpler to get started with Vulkan development. When an application -links directly to the loader library in this way, the Vulkan calls are simple -*trampoline* functions that jump to the appropriate dispatch table entry for the -object they are given. - - -##### Directly Linking to the Loader - -###### Dynamic Linking -The loader is ordinarily distributed as a dynamic library (.dll on Windows or -.so on Linux or .dylib on MacOS) which gets installed to the system path -for dynamic libraries. -Linking to the dynamic library is generally the preferred method of linking to -the loader, as doing so allows the loader to be updated for bug fixes and -improvements. Furthermore, the dynamic library is generally installed to Windows -systems as part of driver installation and is generally provided on Linux -through the system package manager. This means that applications can usually -expect a copy of the loader to be present on a system. If applications want to -be completely sure that a loader is present, they can include a loader or -runtime installer with their application. - -###### Static Linking -The loader can also be used as a static library (this is shipped in the -Windows SDK as `VKstatic.1.lib`). Linking to the static loader means that the -user does not need to have a Vulkan runtime installed, and it also guarantees -that your application will use a specific version of the loader. However, there -are several downsides to this approach: - - - The static library can never be updated without re-linking the application - - This opens up the possibility that two included libraries could contain - different versions of the loader - - This could potentially cause conflicts between the different loader versions - -As a result, it is recommended that users prefer linking to the .dll and -.so versions of the loader. - - -##### Indirectly Linking to the Loader -Applications are not required to link directly to the loader library, instead -they can use the appropriate platform specific dynamic symbol lookup on the -loader library to initialize the application's own dispatch table. This allows -an application to fail gracefully if the loader cannot be found. It also -provides the fastest mechanism for the application to call Vulkan functions. An -application will only need to query (via system calls such as dlsym()) the -address of `vkGetInstanceProcAddr` from the loader library. Using -`vkGetInstanceProcAddr` the application can then discover the address of all -functions and extensions available, such as `vkCreateInstance`, -`vkEnumerateInstanceExtensionProperties` and -`vkEnumerateInstanceLayerProperties` in a platform-independent way. - - -##### Best Application Performance Setup - -If you desire the best performance possible, you should setup your own -dispatch table so that all your Instance functions are queried using -`vkGetInstanceProcAddr` and all your Device functions are queried using -`vkGetDeviceProcAddr`. - -*Why should you do this?* - -The answer comes in how the call chain of Instance functions are implemented -versus the call chain of a Device functions. Remember, a [Vulkan Instance is a -high-level construct used to provide Vulkan system-level information](#instance- -related-objects). Because of this, Instance functions need to be broadcasted to -every available ICD on the system. The following diagram shows an approximate -view of an Instance call chain with 3 enabled layers: - -![Instance Call Chain](./images/loader_instance_chain.png) - -This is also how a Vulkan Device function call chain looks if you query it -using `vkGetInstanceProcAddr`. On the other hand, a Device -function doesn't need to worry about the broadcast because it knows specifically -which associated ICD and which associated Physical Device the call should -terminate at. Because of this, the loader doesn't need to get involved between -any enabled layers and the ICD. Thus, if you used a loader-exported Vulkan -Device function, the call chain in the same scenario as above would look like: - -![Loader Device Call Chain](./images/loader_device_chain_loader.png) - -An even better solution would be for an application to perform a -`vkGetDeviceProcAddr` call on all Device functions. This further optimizes the -call chain by removing the loader all-together under most scenarios: - -![Application Device Call Chain](./images/loader_device_chain_app.png) - -Also, notice if no layers are enabled, your application function pointer would -point **directly to the ICD**. If called enough, those fewer calls can add up -to performance savings. - -**NOTE:** There are some Device functions which still require the loader to -intercept them with a *trampoline* and *terminator*. There are very few of -these, but they are typically functions which the loader wraps with its own -data. In those cases, even the Device call chain will continue to look like the -Instance call chain. One example of a Device function requiring a *terminator* -is `vkCreateSwapchainKHR`. For that function, the loader needs to potentially -convert the KHR_surface object into an ICD-specific KHR_surface object prior to -passing down the rest of the function's information to the ICD. - -Remember: - * `vkGetInstanceProcAddr` can be used to query -either device or instance entry-points in addition to all core entry-points. - * `vkGetDeviceProcAddr` can only be used to query for device -extension or core device entry-points. - - -##### ABI Versioning - -The Vulkan loader library will be distributed in various ways including Vulkan -SDKs, OS package distributions and Independent Hardware Vendor (IHV) driver -packages. These details are beyond the scope of this document. However, the name -and versioning of the Vulkan loader library is specified so an app can link to -the correct Vulkan ABI library version. Vulkan versioning is such that ABI -backwards compatibility is guaranteed for all versions with the same major -number (e.g. 1.0 and 1.1). On Windows, the loader library encodes the ABI -version in its name such that multiple ABI incompatible versions of the loader -can peacefully coexist on a given system. The Vulkan loader library file name is -`vulkan-.dll`. For example, for Vulkan version 1.X on Windows the -library filename is vulkan-1.dll. And this library file can typically be found -in the windows/system32 directory (on 64-bit Windows installs, the 32-bit -version of the loader with the same name can be found in the windows/sysWOW64 -directory). - -For Linux and MacOS, shared libraries are versioned based on a suffix. Thus, the ABI -number is not encoded in the base of the library filename as on Windows. On -Linux an application wanting to link to the latest Vulkan ABI version would -just link to the name vulkan (libvulkan.so). A specific Vulkan ABI version can -also be linked to by applications (e.g. libvulkan.so.1). -On MacOS, the libraries are libvulkan.dylib abd libvulkan.1.dylib. - - -#### Application Layer Usage - -Applications desiring Vulkan functionality beyond what the core API offers may -use various layers or extensions. A layer cannot introduce new Vulkan core API -entry-points to an application that are not exposed in Vulkan.h. However, -layers may offer extensions that introduce new Vulkan commands that can be -queried through the extension interface. - -A common use of layers is for API validation which can be enabled by -loading the layer during application development, but not loading the layer -for application release. This eliminates the overhead of validating the -application's usage of the API, something that wasn't available on some previous -graphics APIs. - -To find out what layers are available to your application, use -`vkEnumerateInstanceLayerProperties`. This will report all layers -that have been discovered by the loader. The loader looks in various locations -to find layers on the system. For more information see the -[Layer discovery](#layer-discovery) section below. - -To enable a layer, or layers, simply pass the name of the layers you wish to -enable in the `ppEnabledLayerNames` field of the `VkInstanceCreateInfo` during -a call to `vkCreateInstance`. Once done, the layers you have enabled will be -active for all Vulkan functions using the created `VkInstance`, and any of -its child objects. - -**NOTE:** Layer ordering is important in several cases since some layers -interact with each other. Be careful when enabling layers as this may be -the case. See the [Overall Layer Ordering](#overall-layer-ordering) section -for more information. - -The following code section shows how you would go about enabling the -VK_LAYER_LUNARG_standard_validation layer. - -``` - char *instance_validation_layers[] = { - "VK_LAYER_LUNARG_standard_validation" - }; - const VkApplicationInfo app = { - .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, - .pNext = NULL, - .pApplicationName = "TEST_APP", - .applicationVersion = 0, - .pEngineName = "TEST_ENGINE", - .engineVersion = 0, - .apiVersion = VK_API_VERSION_1_0, - }; - VkInstanceCreateInfo inst_info = { - .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - .pNext = NULL, - .pApplicationInfo = &app, - .enabledLayerCount = 1, - .ppEnabledLayerNames = (const char *const *)instance_validation_layers, - .enabledExtensionCount = 0, - .ppEnabledExtensionNames = NULL, - }; - err = vkCreateInstance(&inst_info, NULL, &demo->inst); -``` - -At `vkCreateInstance` and `vkCreateDevice`, the loader constructs call chains -that include the application specified (enabled) layers. Order is important in -the `ppEnabledLayerNames` array; array element 0 is the topmost (closest to the -application) layer inserted in the chain and the last array element is closest -to the driver. See the [Overall Layer Ordering](#overall-layer-ordering) -section for more information on layer ordering. - -**NOTE:** *Device Layers Are Now Deprecated* -> `vkCreateDevice` originally was able to select layers in a similar manner to -`vkCreateInstance`. This lead to the concept of "instance -> layers" and "device layers". It was decided by Khronos to deprecate the -> "device layer" functionality and only consider "instance layers". -> Therefore, `vkCreateDevice` will use the layers specified at -`vkCreateInstance`. -> Because of this, the following items have been deprecated: -> * `VkDeviceCreateInfo` fields: -> * `ppEnabledLayerNames` -> * `enabledLayerCount` -> * The `vkEnumerateDeviceLayerProperties` function - - -##### Implicit vs Explicit Layers - -Explicit layers are layers which are enabled by an application (e.g. with the -vkCreateInstance function), or by an environment variable (as mentioned -previously). - -Implicit layers are those which are enabled by their existence. For example, -certain application environments (e.g. Steam or an automotive infotainment -system) may have layers which they always want enabled for all applications -that they start. Other implicit layers may be for all applications started on a -given system (e.g. layers that overlay frames-per-second). Implicit layers are -enabled automatically, whereas explicit layers must be enabled explicitly. - -Implicit layers have an additional requirement over explicit layers in that they -require being able to be disabled by an environmental variable. This is due -to the fact that they are not visible to the application and could cause issues. -A good principle to keep in mind would be to define both an enable and disable -environment variable so the users can deterministically enable the functionality. -On Desktop platforms (Windows, Linux, and MacOS), these enable/disable settings are -defined in the layer's JSON file. - -Discovery of system-installed implicit and explicit layers is described later in -the [Layer Discovery Section](#layer-discovery). For now, simply know that what -distinguishes a layer as implicit or explicit is dependent on the Operating -system, as shown in the table below. - -| Operating System | Implicit Layer Identification | -|----------------|--------------------| -| Windows | Implicit Layers are located in a different Windows registry location than Explicit Layers. | -| Linux | Implicit Layers are located in a different directory location than Explicit Layers. | -| Android | There is **No Support For Implicit Layers** on Android. | -| MacOS | Implicit Layers are located in a different directory location than Explicit Layers. | - - -##### Forcing Layer Source Folders - -Developers may need to use special, pre-production layers, without modifying the -system-installed layers. You can direct the loader to look for layers in a -specific folder by defining the "VK\_LAYER\_PATH" environment variable. This -will override the mechanism used for finding system-installed layers. Because -layers of interest may exist in several distinct folders on a system, this -environment variable can contains several paths separated by the operating -specific path separator. On Windows, each separate folder should be separated -in the list using a semi-colon. On Linux and MacOS, each folder name should be separated -using a colon. - -If "VK\_LAYER\_PATH" exists, **only** the folders listed in it will be scanned -for layers. Each directory listed should be the full pathname of a folder -containing layer manifest files. - - -##### Forcing Layers to be Enabled on Windows, Linux and MacOS - -Developers may want to enable layers that are not enabled by the given -application they are using. On desktop systems, the environment variable -"VK\_INSTANCE\_LAYERS" can be used to enable additional layers which are -not specified (enabled) by the application at `vkCreateInstance`. -"VK\_INSTANCE\_LAYERS" is a colon (Linux and MacOS)/semi-colon (Windows) separated -list of layer names to enable. Order is relevant with the first layer in the -list being the top-most layer (closest to the application) and the last -layer in the list being the bottom-most layer (closest to the driver). -See the [Overall Layer Ordering](#overall-layer-ordering) section -for more information. - -Application specified layers and user specified layers (via environment -variables) are aggregated and duplicates removed by the loader when enabling -layers. Layers specified via environment variable are top-most (closest to the -application) while layers specified by the application are bottommost. - -An example of using these environment variables to activate the validation -layer `VK_LAYER_LUNARG_parameter_validation` on Windows, Linux or MacOS is as follows: - -``` -> $ export VK_INSTANCE_LAYERS=VK_LAYER_LUNARG_parameter_validation -``` - - -##### Overall Layer Ordering - -The overall ordering of all layers by the loader based on the above looks -as follows: - -![Loader Layer Ordering](./images/loader_layer_order.png) - -Ordering may also be important internal to the list of Explicit Layers. -Some layers may be dependent on other behavior being implemented before -or after the loader calls it. For example: the VK_LAYER_LUNARG_core_validation -layer expects the VK_LAYER_LUNARG_parameter_validation to be called first. -This is because the VK_LAYER_LUNARG_parameter_validation will filter out any -invalid `NULL` pointer calls prior to the rest of the validation checking -done by VK_LAYER_LUNARG_core_validation. If not done properly, you may see -crashes in the VK_LAYER_LUNARG_core_validation layer that would otherwise be -avoided. - - -#### Application Usage of Extensions - -Extensions are optional functionality provided by a layer, the loader or an -ICD. Extensions can modify the behavior of the Vulkan API and need to be -specified and registered with Khronos. These extensions can be created -by an Independent Hardware Vendor (IHV) to expose new hardware functionality, -or by a layer writer to expose some internal feature, or by the loader to -improve functional behavior. Information about various extensions can be -found in the Vulkan Spec, and vulkan.h header file. - - -##### Instance and Device Extensions - -As hinted at in the [Instance Versus Device](#instance-versus-device) section, -there are really two types of extensions: - * Instance Extensions - * Device Extensions - -An Instance extension is an extension which modifies existing behavior or -implements new behavior on instance-level objects, like a `VkInstance` or -a `VkPhysicalDevice`. A Device extension is an extension which does the same, -but for any `VkDevice` object, or any dispatchable object that is a child of a -`VkDevice` (`VkQueue` and `VkCommandBuffer` are examples of these). - -It is **very** important to know what type of extension you are desiring to -enable as you will enable Instance extensions during `vkCreateInstance` and -Device extensions during `vkCreateDevice`. - -The loader discovers and aggregates all -extensions from layers (both explicit and implicit), ICDs and the loader before -reporting them to the application in `vkEnumerateXXXExtensionProperties` -(where XXX is either "Instance" or "Device"). - - Instance extensions are discovered via -`vkEnumerateInstanceExtensionProperties`. - - Device extensions are be discovered via -`vkEnumerateDeviceExtensionProperties`. - -Looking at `vulkan.h`, you'll notice that they are both similar. For example, -`vkEnumerateInstanceExtensionProperties` prototype looks as follows: - -``` - VkResult - vkEnumerateInstanceExtensionProperties(const char *pLayerName, - uint32_t *pPropertyCount, - VkExtensionProperties *pProperties); -``` - -The "pLayerName" parameter in these functions is used to select either a single -layer or the Vulkan platform implementation. If "pLayerName" is NULL, extensions -from Vulkan implementation components (including loader, implicit layers, and -ICDs) are enumerated. If "pLayerName" is equal to a discovered layer module name -then only extensions from that layer (which may be implicit or explicit) are -enumerated. Duplicate extensions (e.g. an implicit layer and ICD might report -support for the same extension) are eliminated by the loader. For duplicates, -the ICD version is reported and the layer version is culled. - -Also, Extensions *must be enabled* (in `vkCreateInstance` or `vkCreateDevice`) -before the functions associated with the extensions can be used. If you get an -Extension function using either `vkGetInstanceProcAddr` or -`vkGetDeviceProcAddr`, but fail to enable it, you could experience undefined -behavior. This should actually be flagged if you run with Validation layers -enabled. - - -##### WSI Extensions - -Khronos approved WSI extensions are available and provide Windows System -Integration support for various execution environments. It is important to -understand that some WSI extensions are valid for all targets, but others are -particular to a given execution environment (and loader). This desktop loader -(currently targeting Windows, Linux, and MacOS) only enables and directly exports those -WSI extensions that are appropriate to the current environment. For the most -part, the selection is done in the loader using compile-time preprocessor flags. -All versions of the desktop loader currently expose at least the following WSI -extension support: -- VK_KHR_surface -- VK_KHR_swapchain -- VK_KHR_display - -In addition, each of the following OS targets for the loader support target- -specific extensions: - -| Windowing System | Extensions available | -|----------------|--------------------| -| Windows | VK_KHR_win32_surface | -| Linux (Default) | VK_KHR_xcb_surface and VK_KHR_xlib_surface | -| Linux (Wayland) | VK_KHR_wayland_surface | -| Linux (Mir) | VK_KHR_mir_surface | -| MacOS (MoltenVK) | VK_MVK_macos_surface | - -**NOTE:** Wayland and Mir targets are not fully supported at this time. Wayland -support is present, but should be considered Beta quality. Mir support is not -completely implemented at this time. - -It is important to understand that while the loader may support the various -entry-points for these extensions, there is a hand-shake required to actually -use them: -* At least one physical device must support the extension(s) -* The application must select such a physical device -* The application must request the extension(s) be enabled while creating the -instance or logical device (This depends on whether or not the given extension -works with an instance or a device). -* The instance and/or logical device creation must succeed. - -Only then can you expect to properly use a WSI extension in your Vulkan program. - - -##### Unknown Extensions - -With the ability to expand Vulkan so easily, extensions will be created that the -loader knows nothing about. If the extension is a device extension, the loader -will pass the unknown entry-point down the device call chain ending with the -appropriate ICD entry-points. The same thing will happen, if the extension is -an instance extension which takes a physical device parameter as it's first -component. However, for all other instance extensions the loader will fail to -load it. - -*But why doesn't the loader support unknown instance extensions?* -
-Let's look again at the Instance call chain: - -![Instance call chain](./images/loader_instance_chain.png) - -Notice that for a normal instance function call, the loader has to handle -passing along the function call to the available ICDs. If the loader has no -idea of the parameters or return value of the instance call, it can't properly -pass information along to the ICDs. There may be ways to do this, which will be -explored in the future. However, for now, this loader does not support -instance extensions which don't take a physical device as their first parameter. - -Because the device call-chain does not normally pass through the loader -*terminator*, this is not a problem for device extensions. Additionally, -since a physical device is associated with one ICD, we can use a generic -*terminator* pointing to one ICD. This is because both of these extensions -terminate directly in the ICD they are associated with. - -*Is this a big problem?* -
-No! Most extension functionality only affects either a physical or logical -device and not an instance. Thus, the overwhelming majority of extensions -should be supported with direct loader support. - -##### Filtering Out Unknown Instance Extension Names -In some cases, an ICD may support instance extensions that the loader does not. -For the above reasons, the loader will filter out the names of these unknown instance -extensions when an application calls `vkEnumerateInstanceExtensionProperties`. -Additionally, this behavior will cause the loader to throw an error during -`vkCreateInstance` if you still attempt to use one of these extensions. The intent is -to protect applications so that they don't inadvertently use functionality -which could lead to a crash. - -On the other-hand, if you know you can safely use the extension, you may disable -the filtering by defining the environment variable `VK_LOADER_DISABLE_INST_EXT_FILTER` -and setting the value to a non-zero number. This will effectively disable the -loader's filtering out of instance extension names. - -
-
- -## Loader and Layer Interface - -In this section we'll discuss how the loader interacts with layers, including: - * [Layer Discovery](#layer-discovery) - * [Layer Manifest File Usage](#layer-manifest-file-usage) - * [Android Layer Discovery](#android-layer-discovery) - * [Windows Layer Discovery](#windows-layer-discovery) - * [Linux Layer Discovery](#linux-layer-discovery) - * [MacOS Layer Discovery](#macos-layer-discovery) - * [Layer Version Negotiation](#layer-version-negotiation) - * [Layer Call Chains and Distributed Dispatch](#layer-call-chains-and-distributed-dispatch) - * [Layer Unknown Physical Device Extensions](#layer-unknown-physical-device-extensions) - * [Layer Intercept Requirements](#layer-intercept-requirements) - * [Distributed Dispatching Requirements](#distributed-dispatching-requirements) - * [Layer Conventions and Rules](#layer-conventions-and-rules) - * [Layer Dispatch Initialization](#layer-dispatch-initialization) - * [Example Code for CreateInstance](#example-code-for-createinstance) - * [Example Code for CreateDevice](#example-code-for-createdevice) - * [Meta-layers](#meta-layers) - * [Pre-Instance Functions](#pre-instance-functions) - * [Special Considerations](#special-considerations) - * [Associating Private Data with Vulkan Objects Within a Layer](#associating-private-data-with-vulkan-objects-within-a-layer) - * [Wrapping](#wrapping) - * [Hash Maps](#hash-maps) - * [Creating New Dispatchable Objects](#creating-new-dispatchable-objects) - * [Layer Manifest File Format](#layer-manifest-file-format) - * [Layer Manifest File Version History](#layer-manifest-file-version-history) - * [Layer Library Versions](#layer-library-versions) - * [Layer Library API Version 2](#layer-library-api-version-2) - * [Layer Library API Version 1](#layer-library-api-version-1) - * [Layer Library API Version 0](#layer-library-api-version-0) - - - -#### Layer Discovery - -As mentioned in the -[Application Interface section](#implicit-vs-explicit-layers), -layers can be categorized into two categories: - * Implicit Layers - * Explicit Layers - -The main difference between the two is that Implicit Layers are automatically -enabled, unless overridden, and Explicit Layers must be enabled. Remember, -Implicit Layers are not present on all Operating Systems (like Android). - -On any system, the loader looks in specific areas for information on the -layers that it can load at a user's request. The process of finding the -available layers on a system is known as Layer Discovery. During discovery, -the loader determines what layers are available, the layer name, the layer -version, and any extensions supported by the layer. This information is -provided back to an application through `vkEnumerateInstanceLayerProperties`. - -The group of layers available to the loader is known as a layer library. This -section defines an extensible interface to discover what layers are contained in -the layer library. - -This section also specifies the minimal conventions and rules a layer must -follow, especially with regards to interacting with the loader and other layers. - -##### Layer Manifest File Usage - -On Windows, Linux, and MacOS systems, JSON formatted manifest files are used to store -layer information. In order to find system-installed layers, the Vulkan loader -will read the JSON files to identify the names and attributes of layers and -their extensions. The use of manifest files allows the loader to avoid loading -any shared library files when the application does not query nor request any -extensions. The format of [Layer Manifest File](#layer-manifest-file-format) -is detailed below. - -The Android loader does not use manifest files. Instead, the loader queries the -layer properties using special functions known as "introspection" functions. -The intent of these functions is to determine the same required information -gathered from reading the manifest files. These introspection functions are -not used by the desktop loader but should be present in layers to maintain -consistency. The specific "introspection" functions are called out in -the [Layer Manifest File Format](#layer-manifest-file-format) table. - - -##### Android Layer Discovery - -On Android, the loader looks for layers to enumerate in the -/data/local/debug/vulkan folder. An application enabled for debug has the -ability to enumerate and enable any layers in that location. - - -##### Windows Layer Discovery - -In order to find system-installed layers, the Vulkan loader will scan the -values in the following Windows registry keys: - -``` - HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\Vulkan\ExplicitLayers - HKEY_CURRENT_USER\SOFTWARE\Khronos\Vulkan\ExplicitLayers - HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\Vulkan\ImplicitLayers - HKEY_CURRENT_USER\SOFTWARE\Khronos\Vulkan\ImplicitLayers -``` - -For each value in these keys which has DWORD data set to 0, the loader opens -the JSON manifest file specified by the name of the value. Each name must be a -full pathname to the manifest file. - -Additionally, the loader will scan through registry keys specific to Display -Adapters and all Software Components associated with these adapters for the -locations of JSON manifest files. These keys are located in device keys -created during driver installation and contain configuration information -for base settings, including Vulkan, OpenGL, and Direct3D ICD location. - -The Device Adapter and Software Component key paths should be obtained through the PnP -Configuration Manager API. The `000X` key will be a numbered key, where each -device is assigned a different number. - -``` - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Adapter GUID}\000X\VulkanExplicitLayers - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Adapter GUID}\000X\VulkanImplicitLayers - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Software Component GUID}\000X\VulkanExplicitLayers - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Software Component GUID}\000X\VulkanImplicitLayers -``` - -In addition, on 64-bit systems there may be another set of registry values, listed -below. These values record the locations of 32-bit layers on 64-bit operating systems, -in the same way as the Windows-on-Windows functionality. - -``` - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Adapter GUID}\000X\VulkanExplicitLayersWow - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Adapter GUID}\000X\VulkanImplicitLayersWow - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Software Component GUID}\000X\VulkanExplicitLayersWow - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Software Component GUID}\000X\VulkanImplicitLayersWow -``` - -If any of the above values exist and is of type `REG_SZ`, the loader will open the JSON -manifest file specified by the key value. Each value must be a full absolute -path to a JSON manifest file. A key value may also be of type `REG_MULTI_SZ`, in -which case the value will be interpreted as a list of paths to JSON manifest files. - -In general, applications should install layers into the `SOFTWARE\Khrosos\Vulkan` -paths. The PnP registry locations are intended specifically for layers that are -distributed as part of a driver installation. An application installer should not -modify the device-specific registries, while a device driver should not modify -the system wide registries. - -The Vulkan loader will open each manifest file that is given -to obtain information about the layer, including the name or pathname of a -shared library (".dll") file. However, if VK\_LAYER\_PATH is defined, then the -loader will instead look at the paths defined by that variable instead of using -the information provided by these registry keys. See -[Forcing Layer Source Folders](#forcing-layer-source-folders) for more -information on this. - - -##### Linux Layer Discovery - -On Linux, the Vulkan loader will scan the files in the following Linux -directories: - - /usr/local/etc/vulkan/explicit_layer.d - /usr/local/etc/vulkan/implicit_layer.d - /usr/local/share/vulkan/explicit_layer.d - /usr/local/share/vulkan/implicit_layer.d - /etc/vulkan/explicit_layer.d - /etc/vulkan/implicit_layer.d - /usr/share/vulkan/explicit_layer.d - /usr/share/vulkan/implicit_layer.d - $HOME/.local/share/vulkan/explicit_layer.d - $HOME/.local/share/vulkan/implicit_layer.d - -Of course, there are some things you have to know about the above folders: - 1. The "/usr/local/*" directories can be configured to be other directories at -build time. - 2. $HOME is the current home directory of the application's user id; this path -will be ignored for suid programs. - 3. The "/usr/local/etc/vulkan/\*\_layer.d" and -"/usr/local/share/vulkan/\*\_layer.d" directories are for layers that are -installed from locally-built sources. - 4. The "/usr/share/vulkan/\*\_layer.d" directories are for layers that are -installed from Linux-distribution-provided packages. - -As on Windows, if VK\_LAYER\_PATH is defined, then the -loader will instead look at the paths defined by that variable instead of using -the information provided by these default paths. However, these -environment variables are only used for non-suid programs. See -[Forcing Layer Source Folders](#forcing-layer-source-folders) for more -information on this. - -##### MacOS Layer Discovery - -On MacOS, the Vulkan loader will scan the files in the following directories: - - /Contents/Resources/vulkan/explicit_layer.d - /Contents/Resources/vulkan/implicit_layer.d - /etc/vulkan/explicit_layer.d - /etc/vulkan/implicit_layer.d - /usr/local/share/vulkan/explicit_layer.d - /usr/local/share/vulkan/implicit_layer.d - /usr/share/vulkan/explicit_layer.d - /usr/share/vulkan/implicit_layer.d - $HOME/.local/share/vulkan/explicit_layer.d - $HOME/.local/share/vulkan/implicit_layer.d - -1. <bundle> is the directory containing a bundled application. It is scanned first. -1. The "/usr/local/*" directories can be configured to be other directories at -build time. -1. $HOME is the current home directory of the application's user id; this path -will be ignored for suid programs. - -As on Windows, if VK\_LAYER\_PATH is defined, then the -loader will instead look at the paths defined by that variable instead of using -the information provided by these default paths. However, these -environment variables are only used for non-suid programs. See -[Forcing Layer Source Folders](#forcing-layer-source-folders) for more -information on this. - -#### Layer Version Negotiation - -Now that a layer has been discovered, an application can choose to load it (or -it is loaded by default if it is an Implicit layer). When the loader attempts -to load the layer, the first thing it does is attempt to negotiate the version -of the loader to layer interface. In order to negotiate the loader/layer -interface version, the layer must implement the -`vkNegotiateLoaderLayerInterfaceVersion` function. The following information is -provided for this interface in include/vulkan/vk_layer.h: - -```cpp - typedef enum VkNegotiateLayerStructType { - LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, - } VkNegotiateLayerStructType; - - typedef struct VkNegotiateLayerInterface { - VkNegotiateLayerStructType sType; - void *pNext; - uint32_t loaderLayerInterfaceVersion; - PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; - PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; - } VkNegotiateLayerInterface; - - VkResult vkNegotiateLoaderLayerInterfaceVersion( - VkNegotiateLayerInterface *pVersionStruct); -``` - -You'll notice the `VkNegotiateLayerInterface` structure is similar to other -Vulkan structures. The "sType" field, in this case takes a new enum defined -just for internal loader/layer interfacing use. The valid values for "sType" -could grow in the future, but right now only has the one value -"LAYER_NEGOTIATE_INTERFACE_STRUCT". - -This function (`vkNegotiateLoaderLayerInterfaceVersion`) should be exported by -the layer so that using "GetProcAddress" on Windows or "dlsym" on Linux or MacOS, should -return a valid function pointer to it. Once the loader has grabbed a valid -address to the layers function, the loader will create a variable of type -`VkNegotiateLayerInterface` and initialize it in the following ways: - 1. Set the structure "sType" to "LAYER_NEGOTIATE_INTERFACE_STRUCT" - 2. Set pNext to NULL. - - This is for future growth - 3. Set "loaderLayerInterfaceVersion" to the current version the loader desires -to set the interface to. - - The minimum value sent by the loader will be 2 since it is the first -version supporting this function. - -The loader will then individually call each layer’s -`vkNegotiateLoaderLayerInterfaceVersion` function with the filled out -“VkNegotiateLayerInterface”. The layer will either accept the loader's version -set in "loaderLayerInterfaceVersion", or modify it to the closest value version -of the interface that the layer can support. The value should not be higher -than the version requested by the loader. If the layer can't support at a -minimum the version requested, then the layer should return an error like -"VK_ERROR_INITIALIZATION_FAILED". If a layer can support some version, then -the layer should do the following: - 1. Adjust the version to the layer's desired version. - 2. The layer should fill in the function pointer values to its internal -functions: - - "pfnGetInstanceProcAddr" should be set to the layer’s internal -`GetInstanceProcAddr` function. - - "pfnGetDeviceProcAddr" should be set to the layer’s internal -`GetDeviceProcAddr` function. - - "pfnGetPhysicalDeviceProcAddr" should be set to the layer’s internal -`GetPhysicalDeviceProcAddr` function. - - If the layer supports no physical device extensions, it may set the -value to NULL. - - More on this function later - 3. The layer should return "VK_SUCCESS" - -This function **SHOULD NOT CALL DOWN** the layer chain to the next layer. -The loader will work with each layer individually. - -If the layer supports the new interface and reports version 2 or greater, then -the loader will use the “fpGetInstanceProcAddr” and “fpGetDeviceProcAddr” -functions from the “VkNegotiateLayerInterface” structure. Prior to these -changes, the loader would query each of those functions using "GetProcAddress" -on Windows or "dlsym" on Linux or MacOS. - - -#### Layer Call Chains and Distributed Dispatch - -There are two key architectural features that drive the loader to layer library -interface: - 1. Separate and distinct instance and device call chains - 2. Distributed dispatch. - -You can read an overview of dispatch tables and call chains above in the -[Dispatch Tables and Call Chains](#dispatch-tables-and-call-chains) section. - -What's important to note here is that a layer can intercept Vulkan -instance functions, device functions or both. For a layer to intercept instance -functions, it must participate in the instance call chain. For a layer to -intercept device functions, it must participate in the device call chain. - -Remember, a layer does not need to intercept all instance or device functions, -instead, it can choose to intercept only a subset of those functions. - -Normally, when a layer intercepts a given Vulkan function, it will call down the -instance or device call chain as needed. The loader and all layer libraries that -participate in a call chain cooperate to ensure the correct sequencing of calls -from one entity to the next. This group effort for call chain sequencing is -hereinafter referred to as **distributed dispatch**. - -In distributed dispatch each layer is responsible for properly calling the next -entity in the call chain. This means that a dispatch mechanism is required for -all Vulkan functions that a layer intercepts. If a Vulkan function is not -intercepted by a layer, or if a layer chooses to terminate the function by not -calling down the chain, then no dispatch is needed for that particular function. - -For example, if the enabled layers intercepted only certain instance functions, -the call chain would look as follows: -![Instance Function Chain](./images/function_instance_chain.png) - -Likewise, if the enabled layers intercepted only a few of the device functions, -the call chain could look this way: -![Device Function Chain](./images/function_device_chain.png) - -The loader is responsible for dispatching all core and instance extension Vulkan -functions to the first entity in the call chain. - - -#### Layer Unknown Physical Device Extensions - -Originally, if the loader was called with `vkGetInstanceProcAddr`, it would -result in the following behavior: - 1. The loader would check if core function: - - If it was, it would return the function pointer - 2. The loader would check if known extension function: - - If it was, it would return the function pointer - 3. If the loader knew nothing about it, it would call down using -`GetInstanceProcAddr` - - If it returned non-NULL, treat it as an unknown logical device command. - - This meant setting up a generic trampoline function that takes in a -VkDevice as the first parameter and adjusting the dispatch table to call the -ICD/Layers function after getting the dispatch table from the VkDevice. - 4. If all the above failed, the loader would return NULL to the application. - -This caused problems when a layer attempted to expose new physical device -extensions the loader knew nothing about, but an application did. Because the -loader knew nothing about it, the loader would get to step 3 in the above -process and would treat the function as an unknown logical device command. The -problem is, this would create a generic VkDevice trampoline function which, on -the first call, would attempt to dereference the VkPhysicalDevice as a VkDevice. -This would lead to a crash or corruption. - -In order to identify the extension entry-points specific to physical device -extensions, the following function can be added to a layer: - -```cpp -PFN_vkVoidFunction vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, - const char* pName); -``` - -This function behaves similar to `vkGetInstanceProcAddr` and -`vkGetDeviceProcAddr` except it should only return values for physical device -extension entry-points. In this way, it compares "pName" to every physical -device function supported in the layer. - -The following rules apply: - * If it is the name of a physical device function supported by the layer, the -pointer to the layer's corresponding function should be returned. - * If it is the name of a valid function which is **not** a physical device -function (i.e. an Instance, Device, or other function implemented by the layer), -then the value of NULL should be returned. - * We don’t call down since we know the command is not a physical device -extension). - * If the layer has no idea what this function is, it should call down the layer -chain to the next `vk_layerGetPhysicalDeviceProcAddr` call. - * This can be retrieved in one of two ways: - * During `vkCreateInstance`, it is passed to a layer in the -chain information passed to a layer in the `VkLayerInstanceCreateInfo` -structure. - * Use `get_chain_info()` to get the pointer to the -`VkLayerInstanceCreateInfo` structure. Let's call it chain_info. - * The address is then under -chain_info->u.pLayerInfo->pfnNextGetPhysicalDeviceProcAddr - * See -[Example Code for CreateInstance](#example-code-for-createinstance) - * Using the next layer’s `GetInstanceProcAddr` function to query for -`vk_layerGetPhysicalDeviceProcAddr`. - -This support is optional and should not be considered a requirement. This is -only required if a layer intends to support some functionality not directly -supported by loaders released in the public. If a layer does implement this -support, it should return the address of its `vk_layerGetPhysicalDeviceProcAddr` -function in the "pfnGetPhysicalDeviceProcAddr" member of the -`VkNegotiateLayerInterface` structure during -[Layer Version Negotiation](#layer-version-negotiation). Additionally, the -layer should also make sure `vkGetInstanceProcAddr` returns a valid function -pointer to a query of `vk_layerGetPhysicalDeviceProcAddr`. - -The new behavior of the loader's `vkGetInstanceProcAddr` with support for the -`vk_layerGetPhysicalDeviceProcAddr` function is as follows: - 1. Check if core function: - - If it is, return the function pointer - 2. Check if known instance or device extension function: - - If it is, return the function pointer - 3. Call the layer/ICD `GetPhysicalDeviceProcAddr` - - If it returns non-NULL, return a trampoline to a generic physical device -function, and setup a generic terminator which will pass it to the proper ICD. - 4. Call down using `GetInstanceProcAddr` - - If it returns non-NULL, treat it as an unknown logical device command. -This means setting up a generic trampoline function that takes in a VkDevice as -the first parameter and adjusting the dispatch table to call the ICD/Layers -function after getting the dispatch table from the VkDevice. Then, return the -pointer to corresponding trampoline function. - 5. Return NULL - -You can see now, that, if the command gets promoted to core later, it will no -longer be setup using `vk_layerGetPhysicalDeviceProcAddr`. Additionally, if the -loader adds direct support for the extension, it will no longer get to step 3, -because step 2 will return a valid function pointer. However, the layer should -continue to support the command query via `vk_layerGetPhysicalDeviceProcAddr`, -until at least a Vulkan version bump, because an older loader may still be -attempting to use the commands. - - -#### Layer Intercept Requirements - - * Layers intercept a Vulkan function by defining a C/C++ function with -signature **identical** to the Vulkan API for that function. - * A layer **must intercept at least** `vkGetInstanceProcAddr` and -`vkCreateInstance` to participate in the instance call chain. - * A layer **may also intercept** `vkGetDeviceProcAddr` and `vkCreateDevice` -to participate in the device call chain. - * For any Vulkan function a layer intercepts which has a non-void return value, -**an appropriate value must be returned** by the layer intercept function. - * Most functions a layer intercepts **should call down the chain** to the -corresponding Vulkan function in the next entity. - * The common behavior for a layer is to intercept a call, perform some -behavior, then pass it down to the next entity. - * If you don't pass the information down, undefined behavior may occur. - * This is because the function will not be received by layers further down -the chain, or any ICDs. - * One function that **must never call down the chain** is: - * `vkNegotiateLoaderLayerInterfaceVersion` - * Three common functions that **may not call down the chain** are: - * `vkGetInstanceProcAddr` - * `vkGetDeviceProcAddr` - * `vk_layerGetPhysicalDeviceProcAddr` - * These functions only call down the chain for Vulkan functions that they -do not intercept. - * Layer intercept functions **may insert extra calls** to Vulkan functions in -addition to the intercept. - * For example, a layer intercepting `vkQueueSubmit` may want to add a call to -`vkQueueWaitIdle` after calling down the chain for `vkQueueSubmit`. - * This would result in two calls down the chain: First a call down the -`vkQueueSubmit` chain, followed by a call down the `vkQueueWaitIdle` chain. - * Any additional calls inserted by a layer must be on the same chain - * If the function is a device function, only other device functions should -be added. - * Likewise, if the function is an instance function, only other instance -functions should be added. - - -#### Distributed Dispatching Requirements - -- For each entry-point a layer intercepts, it must keep track of the entry -point residing in the next entity in the chain it will call down into. - * In other words, the layer must have a list of pointers to functions of the -appropriate type to call into the next entity. - * This can be implemented in various ways but -for clarity, will be referred to as a dispatch table. -- A layer can use the `VkLayerDispatchTable` structure as a device dispatch -table (see include/vulkan/vk_layer.h). -- A layer can use the `VkLayerInstanceDispatchTable` structure as a instance -dispatch table (see include/vulkan/vk_layer.h). -- A Layer's `vkGetInstanceProcAddr` function uses the next entity's -`vkGetInstanceProcAddr` to call down the chain for unknown (i.e. -non-intercepted) functions. -- A Layer's `vkGetDeviceProcAddr` function uses the next entity's -`vkGetDeviceProcAddr` to call down the chain for unknown (i.e. non-intercepted) -functions. -- A Layer's `vk_layerGetPhysicalDeviceProcAddr` function uses the next entity's -`vk_layerGetPhysicalDeviceProcAddr` to call down the chain for unknown (i.e. -non-intercepted) functions. - - -#### Layer Conventions and Rules - -A layer, when inserted into an otherwise compliant Vulkan implementation, must -still result in a compliant Vulkan implementation. The intention is for layers -to have a well-defined baseline behavior. Therefore, it must follow some -conventions and rules defined below. - -A layer is always chained with other layers. It must not make invalid calls -to, or rely on undefined behaviors of, its lower layers. When it changes the -behavior of a function, it must make sure its upper layers do not make invalid -calls to or rely on undefined behaviors of its lower layers because of the -changed behavior. For example, when a layer intercepts an object creation -function to wrap the objects created by its lower layers, it must make sure its -lower layers never see the wrapping objects, directly from itself or -indirectly from its upper layers. - -When a layer requires host memory, it may ignore the provided allocators. It -should use memory allocators if the layer is intended to run in a production -environment. For example, this usually applies to implicit layers that are -always enabled. That will allow applications to include the layer's memory -usage. - -Additional rules include: - - `vkEnumerateInstanceLayerProperties` **must** enumerate and **only** -enumerate the layer itself. - - `vkEnumerateInstanceExtensionProperties` **must** handle the case where -`pLayerName` is itself. - - It **must** return `VK_ERROR_LAYER_NOT_PRESENT` otherwise, including when -`pLayerName` is `NULL`. - - `vkEnumerateDeviceLayerProperties` **is deprecated and may be omitted**. - - Using this will result in undefined behavior. - - `vkEnumerateDeviceExtensionProperties` **must** handle the case where -`pLayerName` is itself. - - In other cases, it should normally chain to other layers. - - `vkCreateInstance` **must not** generate an error for unrecognized layer -names and extension names. - - It may assume the layer names and extension names have been validated. - - `vkGetInstanceProcAddr` intercepts a Vulkan function by returning a local -entry-point - - Otherwise it returns the value obtained by calling down the instance call -chain. - - `vkGetDeviceProcAddr` intercepts a Vulkan function by returning a local -entry-point - - Otherwise it returns the value obtained by calling down the device call -chain. - - These additional functions must be intercepted if the layer implements -device-level call chaining: - - `vkGetDeviceProcAddr` - - `vkCreateDevice`(only required for any device-level chaining) - - **NOTE:** older layer libraries may expect that `vkGetInstanceProcAddr` -ignore `instance` when `pName` is `vkCreateDevice`. - - The specification **requires** `NULL` to be returned from -`vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` for disabled functions. - - A layer may return `NULL` itself or rely on the following layers to do so. - - -#### Layer Dispatch Initialization - -- A layer initializes its instance dispatch table within its `vkCreateInstance` -function. -- A layer initializes its device dispatch table within its `vkCreateDevice` -function. -- The loader passes a linked list of initialization structures to layers via -the "pNext" field in the `VkInstanceCreateInfo` and `VkDeviceCreateInfo` -structures for `vkCreateInstance` and `VkCreateDevice` respectively. -- The head node in this linked list is of type `VkLayerInstanceCreateInfo` for -instance and VkLayerDeviceCreateInfo for device. See file -`include/vulkan/vk_layer.h` for details. -- A VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO is used by the loader for the -"sType" field in `VkLayerInstanceCreateInfo`. -- A VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO is used by the loader for the -"sType" field in `VkLayerDeviceCreateInfo`. -- The "function" field indicates how the union field "u" should be interpreted -within `VkLayer*CreateInfo`. The loader will set the "function" field to -VK_LAYER_LINK_INFO. This indicates "u" field should be `VkLayerInstanceLink` or -`VkLayerDeviceLink`. -- The `VkLayerInstanceLink` and `VkLayerDeviceLink` structures are the list -nodes. -- The `VkLayerInstanceLink` contains the next entity's `vkGetInstanceProcAddr` -used by a layer. -- The `VkLayerDeviceLink` contains the next entity's `vkGetInstanceProcAddr` and -`vkGetDeviceProcAddr` used by a layer. -- Given the above structures set up by the loader, layer must initialize their -dispatch table as follows: - - Find the `VkLayerInstanceCreateInfo`/`VkLayerDeviceCreateInfo` structure in -the `VkInstanceCreateInfo`/`VkDeviceCreateInfo` structure. - - Get the next entity's vkGet*ProcAddr from the "pLayerInfo" field. - - For CreateInstance get the next entity's `vkCreateInstance` by calling the -"pfnNextGetInstanceProcAddr": - pfnNextGetInstanceProcAddr(NULL, "vkCreateInstance"). - - For CreateDevice get the next entity's `vkCreateDevice` by calling the -"pfnNextGetInstanceProcAddr": - pfnNextGetInstanceProcAddr(NULL, "vkCreateDevice"). - - Advanced the linked list to the next node: pLayerInfo = pLayerInfo->pNext. - - Call down the chain either `vkCreateDevice` or `vkCreateInstance` - - Initialize your layer dispatch table by calling the next entity's -Get*ProcAddr function once for each Vulkan function needed in your dispatch -table - -#### Example Code for CreateInstance - -```cpp -VkResult vkCreateInstance( - const VkInstanceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) -{ - VkLayerInstanceCreateInfo *chain_info = - get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = - chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkCreateInstance fpCreateInstance = - (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); - if (fpCreateInstance == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element of the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - // Continue call down the chain - VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); - if (result != VK_SUCCESS) - return result; - - // Init layer's dispatch table using GetInstanceProcAddr of - // next layer in the chain. - instance_dispatch_table = new VkLayerInstanceDispatchTable; - layer_init_instance_dispatch_table( - *pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr); - - // Other layer initialization - ... - - return VK_SUCCESS; -} -``` - -#### Example Code for CreateDevice - -```cpp -VkResult -vkCreateDevice( - VkPhysicalDevice gpu, - const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDevice *pDevice) -{ - VkLayerDeviceCreateInfo *chain_info = - get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = - chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = - chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = - (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice"); - if (fpCreateDevice == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); - if (result != VK_SUCCESS) { - return result; - } - - // initialize layer's dispatch table - device_dispatch_table = new VkLayerDispatchTable; - layer_init_device_dispatch_table( - *pDevice, device_dispatch_table, fpGetDeviceProcAddr); - - // Other layer initialization - ... - - return VK_SUCCESS; -} -``` - - -#### Meta-layers - -Meta-layers are a special kind of layer which is only available through the -desktop loader. While normal layers are associated with one particular library, -a meta-layer is actually a collection layer which contains an ordered list of -other layers (called component layers). - -The most common example of a meta-layer is the -`VK_LAYER_LUNARG_standard_validation` layer which groups all the most common -individual validation layers into a single layer for ease-of-use. - -The benefits of a meta-layer are: - 1. You can activate more than one layer using a single layer name by simply -grouping multiple layers in a meta-layer. - 2. You can define the order the loader will activate individual layers within -the meta-layer. - 3. You can easily share your special layer configuration with others. - 4. The loader will automatically collate all instance and device extensions in -a meta-layer's component layers, and report them as the meta-layer's properties -to the application when queried. - -Restrictions to defining and using a meta-layer are: - 1. A Meta-layer Manifest file **must** be a properly formatted that contains one -or more component layers. - 3. All component layers **must be** present on a system for the meta-layer to -be used. - 4. All component layers **must be** at the same Vulkan API major and minor -version for the meta-layer to be used. - -The ordering of a meta-layer's component layers in the instance or device -call-chain is simple: - * The first layer listed will be the layer closest to the application. - * The last layer listed will be the layer closest to the drivers. - -Inside the meta-layer Manifest file, each component layer is listed by its -layer name. This is the "name" tag's value associated with each component layer's -Manifest file under the "layer" or "layers" tag. This is also the name that -would normally be used when activating a layer during `vkCreateInstance`. - -Any duplicate layer names in either the component layer list, or globally among -all enabled layers, will simply be ignored. Only the first instance of any -layer name will be used. - -For example, if you have a layer enabled using the environment variable -`VK_INSTANCE_LAYERS` and have that same layer listed in a meta-layer, then the -environment variable enabled layer will be used and the component layer will -be dropped. Likewise, if a person were to enable a meta-layer and then -separately enable one of the component layers afterwards, the second -instantiation of the layer name would be ignored. - -The -Manifest file formatting necessary to define a meta-layer can be found in the -[Layer Manifest File Format](#layer-manifest-file-format) section. - -#### Pre-Instance Functions - -Vulkan includes a small number of functions which are called without any dispatchable object. -Most layers do not intercept these functions, as layers are enabled when an instance is created. -However, under certain conditions it is possible for a layer to intercept these functions. - -In order to intercept the pre-instance functions, several conditions must be met: -* The layer must be implicit -* The layer manifest version must be 1.1.2 or later -* The layer must export the entry point symbols for each intercepted function -* The layer manifest must specify the name of each intercepted function in a `pre_instance_functions` JSON object - -The functions that may be intercepted in this way are: -* `vkEnumerateInstanceExtensionProperties` -* `vkEnumerateInstanceLayerProperties` - -Pre-instance functions work differently from all other layer intercept functions. -Other intercept functions have a function prototype identical to that of the function they are intercepting. -They then rely on data that was passed to the layer at instance or device creation so that layers can call down the chain. -Because there is no need to create an instance before calling the pre-instance functions, these functions must use a separate mechanism for constructing the call chain. -This mechanism consists of an extra parameter that will be passed to the layer intercept function when it is called. -This parameter will be a pointer to a struct, defined as follows: - -``` -typedef struct Vk...Chain -{ - struct { - VkChainType type; - uint32_t version; - uint32_t size; - } header; - PFN_vkVoidFunction pfnNextLayer; - const struct Vk...Chain* pNextLink; -} Vk...Chain; -``` - -These structs are defined in the `vk_layer.h` file so that it is not necessary to redefine the chain structs in any external code. -The name of each struct is be similar to the name of the function it corresponds to, but the leading "V" is capitalized, and the word "Chain" is added to the end. -For example, the struct for `vkEnumerateInstanceExtensionProperties` is called `VkEnumerateInstanceExtensionPropertiesChain`. -Furthermore, the `pfnNextLayer` struct member is not actually a void function pointer — its type will be the actual type of each function in the call chain. - -Each layer intercept function must have a prototype that is the same as the prototype of the function being intercepted, except that the first parameter must be that function's chain struct (passed as a const pointer). -For example, a function that wishes to intercept `vkEnumerateInstanceExtensionProperties` would have the prototype: - -``` -VkResult InterceptFunctionName(const VkEnumerateInstanceExtensionProperties* pChain, - const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -``` - -The name of the function is arbitrary; it can be anything provided that it is given in the layer manifest file (see [Layer Manifest File Format](#layer-manifest-file-format)). -The implementation of each intercept functions is responsible for calling the next item in the call chain, using the chain parameter. -This is done by calling the `pfnNextLayer` member of the chain struct, passing `pNextLink` as the first argument, and passing the remaining function arguments after that. -For example, a simple implementation for `vkEnumerateInstanceExtensionProperties` that does nothing but call down the chain would look like: - -``` -VkResult InterceptFunctionName(const VkEnumerateInstanceExtensionProperties* pChain, - const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) -{ - return pChain->pfnNextLayer(pChain->pNextLink, pLayerName, pPropertyCount, pProperties); -} -``` - -When using a C++ compiler, each chain type also defines a function named `CallDown` which can be used to automatically handle the first argument. -Implementing the above function using this method would look like: - -``` -VkResult InterceptFunctionName(const VkEnumerateInstanceExtensionProperties* pChain, - const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) -{ - return pChain->CallDown(pLayerName, pPropertyCount, pProperties); -} -``` - -Unlike with other functions in layers, the layer may not save any global data between these function calls. -Because Vulkan does not store any state until an instance has been created, all layer libraries are released at the end of each pre-instance call. -This means that implicit layers can use pre-instance intercepts to modify data that is returned by the functions, but they cannot be used to record that data. - -#### Special Considerations - - -##### Associating Private Data with Vulkan Objects Within a Layer - -A layer may want to associate it's own private data with one or more Vulkan -objects. Two common methods to do this are hash maps and object wrapping. - - -###### Wrapping - -The loader supports layers wrapping any Vulkan object, including dispatchable -objects. For functions that return object handles, each layer does not touch -the value passed down the call chain. This is because lower items may need to -use the original value. However, when the value is returned from a -lower-level layer (possibly the ICD), the layer saves the handle and returns -its own handle to the layer above it (possibly the application). When a layer -receives a Vulkan function using something that it previously returned a handle -for, the layer is required to unwrap the handle and pass along the saved handle -to the layer below it. This means that the layer **must intercept every Vulkan -function which uses the object in question**, and wrap or unwrap the object, as -appropriate. This includes adding support for all extensions with functions -using any object the layer wraps. - -Layers above the object wrapping layer will see the wrapped object. Layers -which wrap dispatchable objects must ensure that the first field in the wrapping -structure is a pointer to a dispatch table as defined in `vk_layer.h`. -Specifically, an instance wrapped dispatchable object could be as follows: -``` -struct my_wrapped_instance_obj_ { - VkLayerInstanceDispatchTable *disp; - // whatever data layer wants to add to this object -}; -``` -A device wrapped dispatchable object could be as follows: -``` -struct my_wrapped_instance_obj_ { - VkLayerDispatchTable *disp; - // whatever data layer wants to add to this object -}; -``` - -Layers that wrap dispatchable objects must follow the guidelines for creating -new dispatchable objects (below). - -Cautions About Wrapping - -Layers are generally discouraged from wrapping objects, because of the -potential for incompatibilities with new extensions. For example, let's say -that a layer wraps `VkImage` objects, and properly wraps and unwraps `VkImage` -object handles for all core functions. If a new extension is created which has -functions that take `VkImage` objects as parameters, and if the layer does not -support those new functions, an application that uses both the layer and the new -extension will have undefined behavior when those new functions are called (e.g. -the application may crash). This is because the lower-level layers and ICD -won't receive the handle that they generated. Instead, they will receive a -handle that is only known by the layer that is wrapping the object. - -Because of the potential for incompatibilities with unsupported extensions, -layers that wrap objects must check which extensions are being used by the -application, and take appropriate action if the layer is used with unsupported -extensions (e.g. disable layer functionality, stop wrapping objects, issue a -message to the user). - -The reason that the validation layers wrap objects, is to track the proper use -and destruction of each object. They issue a validation error if used with -unsupported extensions, alerting the user to the potential for undefined -behavior. - - -###### Hash Maps - -Alternatively, a layer may want to use a hash map to associate data with a -given object. The key to the map could be the object. Alternatively, for -dispatchable objects at a given level (eg device or instance) the layer may -want data associated with the `VkDevice` or `VkInstance` objects. Since -there are multiple dispatchable objects for a given `VkInstance` or `VkDevice`, -the `VkDevice` or `VkInstance` object is not a great map key. Instead the layer -should use the dispatch table pointer within the `VkDevice` or `VkInstance` -since that will be unique for a given `VkInstance` or `VkDevice`. - - -##### Creating New Dispatchable Objects - -Layers which create dispatchable objects must take special care. Remember that -loader *trampoline* code normally fills in the dispatch table pointer in the -newly created object. Thus, the layer must fill in the dispatch table pointer if -the loader *trampoline* will not do so. Common cases where a layer (or ICD) may -create a dispatchable object without loader *trampoline* code is as follows: -- layers that wrap dispatchable objects -- layers which add extensions that create dispatchable objects -- layers which insert extra Vulkan functions in the stream of functions they -intercept from the application -- ICDs which add extensions that create dispatchable objects - -The desktop loader provides a callback that can be used for initializing -a dispatchable object. The callback is passed as an extension structure via the -pNext field in the create info structure when creating an instance -(`VkInstanceCreateInfo`) or device (`VkDeviceCreateInfo`). The callback -prototype is defined as follows for instance and device callbacks respectively -(see `vk_layer.h`): - -```cpp -VKAPI_ATTR VkResult VKAPI_CALL vkSetInstanceLoaderData(VkInstance instance, - void *object); -VKAPI_ATTR VkResult VKAPI_CALL vkSetDeviceLoaderData(VkDevice device, - void *object); -``` - -To obtain these callbacks the layer must search through the list of structures -pointed to by the "pNext" field in the `VkInstanceCreateInfo` and -`VkDeviceCreateInfo` parameters to find any callback structures inserted by the -loader. The salient details are as follows: -- For `VkInstanceCreateInfo` the callback structure pointed to by "pNext" is -`VkLayerInstanceCreateInfo` as defined in `include/vulkan/vk_layer.h`. -- A "sType" field in of VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO within -`VkInstanceCreateInfo` parameter indicates a loader structure. -- Within `VkLayerInstanceCreateInfo`, the "function" field indicates how the -union field "u" should be interpreted. -- A "function" equal to VK_LOADER_DATA_CALLBACK indicates the "u" field will -contain the callback in "pfnSetInstanceLoaderData". -- For `VkDeviceCreateInfo` the callback structure pointed to by "pNext" is -`VkLayerDeviceCreateInfo` as defined in `include/vulkan/vk_layer.h`. -- A "sType" field in of VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO within -`VkDeviceCreateInfo` parameter indicates a loader structure. -- Within `VkLayerDeviceCreateInfo`, the "function" field indicates how the union -field "u" should be interpreted. -- A "function" equal to VK_LOADER_DATA_CALLBACK indicates the "u" field will -contain the callback in "pfnSetDeviceLoaderData". - -Alternatively, if an older loader is being used that doesn't provide these -callbacks, the layer may manually initialize the newly created dispatchable -object. To fill in the dispatch table pointer in newly created dispatchable -object, the layer should copy the dispatch pointer, which is always the first -entry in the structure, from an existing parent object of the same level -(instance versus device). - -For example, if there is a newly created `VkCommandBuffer` object, then the -dispatch pointer from the `VkDevice` object, which is the parent of the -`VkCommandBuffer` object, should be copied into the newly created object. - - -#### Layer Manifest File Format - -On Windows, Linux and MacOS (desktop), the loader uses manifest files to discover -layer libraries and layers. The desktop loader doesn't directly query the -layer library except during chaining. This is to reduce the likelihood of -loading a malicious layer into memory. Instead, details are read from the -Manifest file, which are then provided for applications to determine what -layers should actually be loaded. - -The following section discusses the details of the Layer Manifest JSON file -format. The JSON file itself does not have any requirements for naming. The -only requirement is that the extension suffix of the file ends with ".json". - -Here is an example layer JSON Manifest file with a single layer: - -``` -{ - "file_format_version" : "1.0.0", - "layer": { - "name": "VK_LAYER_LUNARG_overlay", - "type": "INSTANCE", - "library_path": "vkOverlayLayer.dll" - "api_version" : "1.0.5", - "implementation_version" : "2", - "description" : "LunarG HUD layer", - "functions": { - "vkNegotiateLoaderLayerInterfaceVersion": - "OverlayLayer_NegotiateLoaderLayerInterfaceVersion" - }, - "instance_extensions": [ - { - "name": "VK_EXT_debug_report", - "spec_version": "1" - }, - { - "name": "VK_VENDOR_ext_x", - "spec_version": "3" - } - ], - "device_extensions": [ - { - "name": "VK_EXT_debug_marker", - "spec_version": "1", - "entrypoints": ["vkCmdDbgMarkerBegin", "vkCmdDbgMarkerEnd"] - } - ], - "enable_environment": { - "ENABLE_LAYER_OVERLAY_1": "1" - }, - "disable_environment": { - "DISABLE_LAYER_OVERLAY_1": "" - } - } -} -``` - -Here's a snippet with the changes required to support multiple layers per -manifest file: -``` -{ - "file_format_version" : "1.0.1", - "layers": [ - { - "name": "VK_LAYER_layer_name1", - "type": "INSTANCE", - ... - }, - { - "name": "VK_LAYER_layer_name2", - "type": "INSTANCE", - ... - } - ] -} -``` - -Here's an example of a meta-layer manifest file: -``` -{ - "file_format_version" : "1.1.1", - "layer": { - "name": "VK_LAYER_LUNARG_standard_validation", - "type": "GLOBAL", - "api_version" : "1.0.40", - "implementation_version" : "1", - "description" : "LunarG Standard Validation Meta-layer", - "component_layers": [ - "VK_LAYER_GOOGLE_threading", - "VK_LAYER_LUNARG_parameter_validation", - "VK_LAYER_LUNARG_object_tracker", - "VK_LAYER_LUNARG_core_validation", - "VK_LAYER_GOOGLE_unique_objects" - ] - } -} -``` -| JSON Node | Description and Notes | Introspection Query | -|:----------------:|--------------------|:----------------: -| "file\_format\_version" | Manifest format major.minor.patch version number. | N/A | -| | Supported versions are: 1.0.0, 1.0.1, 1.1.0, 1.1.1, and 1.1.2. | | -| "layer" | The identifier used to group a single layer's information together. | vkEnumerateInstanceLayerProperties | -| "layers" | The identifier used to group multiple layers' information together. This requires a minimum Manifest file format version of 1.0.1.| vkEnumerateInstanceLayerProperties | -| "name" | The string used to uniquely identify this layer to applications. | vkEnumerateInstanceLayerProperties | -| "type" | This field indicates the type of layer. The values can be: GLOBAL, or INSTANCE | vkEnumerate*LayerProperties | -| | **NOTES:** Prior to deprecation, the "type" node was used to indicate which layer chain(s) to activate the layer upon: instance, device, or both. Distinct instance and device layers are deprecated; there are now just layers. Allowable values for type (both before and after deprecation) are "INSTANCE", "GLOBAL" and, "DEVICE." "DEVICE" layers are skipped over by the loader as if they were not found. | | -| "library\_path" | The "library\_path" specifies either a filename, a relative pathname, or a full pathname to a layer shared library file. If "library\_path" specifies a relative pathname, it is relative to the path of the JSON manifest file (e.g. for cases when an application provides a layer that is in the same folder hierarchy as the rest of the application files). If "library\_path" specifies a filename, the library must live in the system's shared object search path. There are no rules about the name of the layer shared library files other than it should end with the appropriate suffix (".DLL" on Windows, ".so" on Linux, and ".dylib" on MacOS). **This field must not be present if "component_layers" is defined** | N/A | -| "api\_version" | The major.minor.patch version number of the Vulkan API that the shared library file for the library was built against. For example: 1.0.33. | vkEnumerateInstanceLayerProperties | -| "implementation_version" | The version of the layer implemented. If the layer itself has any major changes, this number should change so the loader and/or application can identify it properly. | vkEnumerateInstanceLayerProperties | -| "description" | A high-level description of the layer and it's intended use. | vkEnumerateInstanceLayerProperties | -| "functions" | **OPTIONAL:** This section can be used to identify a different function name for the loader to use in place of standard layer interface functions. The "functions" node is required if the layer is using an alternative name for `vkNegotiateLoaderLayerInterfaceVersion`. | vkGet*ProcAddr | -| "instance\_extensions" | **OPTIONAL:** Contains the list of instance extension names supported by this layer. One "instance\_extensions" node with an array of one or more elements is required if any instance extensions are supported by a layer, otherwise the node is optional. Each element of the array must have the nodes "name" and "spec_version" which correspond to `VkExtensionProperties` "extensionName" and "specVersion" respectively. | vkEnumerateInstanceExtensionProperties | -| "device\_extensions" | **OPTIONAL:** Contains the list of device extension names supported by this layer. One "device_\extensions" node with an array of one or more elements is required if any device extensions are supported by a layer, otherwise the node is optional. Each element of the array must have the nodes "name" and "spec_version" which correspond to `VkExtensionProperties` "extensionName" and "specVersion" respectively. Additionally, each element of the array of device extensions must have the node "entrypoints" if the device extension adds Vulkan API functions, otherwise this node is not required. The "entrypoint" node is an array of the names of all entrypoints added by the supported extension. | vkEnumerateDeviceExtensionProperties | -| "enable\_environment" | **Implicit Layers Only** - **OPTIONAL:** Indicates an environment variable used to enable the Implicit Layer (w/ value of 1). This environment variable (which should vary with each "version" of the layer) must be set to the given value or else the implicit layer is not loaded. This is for application environments (e.g. Steam) which want to enable a layer(s) only for applications that they launch, and allows for applications run outside of an application environment to not get that implicit layer(s).| N/A | -| "disable\_environment" | **Implicit Layers Only** - **REQUIRED:**Indicates an environment variable used to disable the Implicit Layer (w/ value of 1). In rare cases of an application not working with an implicit layer, the application can set this environment variable (before calling Vulkan functions) in order to "blacklist" the layer. This environment variable (which should vary with each "version" of the layer) must be set (not particularly to any value). If both the "enable_environment" and "disable_environment" variables are set, the implicit layer is disabled. | N/A | -| "component_layers" | **Meta-layers Only** - Indicates the component layer names that are part of a meta-layer. The names listed must be the "name" identified in each of the component layer's Mainfest file "name" tag (this is the same as the name of the layer that is passed to the `vkCreateInstance` command). All component layers must be present on the system and found by the loader in order for this meta-layer to be available and activated. **This field must not be present if "library\_path" is defined** | N/A | -| "pre_instance_functions" | **Implicit Layers Only** - **OPTIONAL:** Indicates which functions the layer wishes to intercept, that do not require that an instance has been created. This should be an object where each function to be intercepted is defined as a string entry where the key is the Vulkan function name and the value is the name of the intercept function in the layer's dynamic library. Available in layer manifest versions 1.1.2 and up. See [Pre-Instance Functions](#pre-instance-functions) for more information. | vkEnumerateInstance*Properties | - -##### Layer Manifest File Version History - -The current highest supported Layer Manifest file format supported is 1.1.2. -Information about each version is detailed in the following sub-sections: - -###### Layer Manifest File Version 1.1.2 - -Version 1.1.2 introduced the ability of layers to intercept function calls that do not have an instance. - -###### Layer Manifest File Version 1.1.1 - -The ability to define custom metalayers was added. -To support metalayers, the "component_layers" section was added, and the requirement for a "library_path" section to be present was removed when the "component_layers" section is present. - -###### Layer Manifest File Version 1.1.0 - -Layer Manifest File Version 1.1.0 is tied to changes exposed by the Loader/Layer -interface version 2. - 1. Renaming "vkGetInstanceProcAddr" in the "functions" section is - deprecated since the loader no longer needs to query the layer about - "vkGetInstanceProcAddr" directly. It is now returned during the layer - negotiation, so this field will be ignored. - 2. Renaming "vkGetDeviceProcAddr" in the "functions" section is - deprecated since the loader no longer needs to query the layer about - "vkGetDeviceProcAddr" directly. It too is now returned during the layer - negotiation, so this field will be ignored. - 3. Renaming the "vkNegotiateLoaderLayerInterfaceVersion" function is - being added to the "functions" section, since this is now the only - function the loader needs to query using OS-specific calls. - - NOTE: This is an optional field and, as the two previous fields, only -needed if the layer requires changing the name of the function for some reason. - -You do not need to update your layer manifest file if you don't change the -names of any of the listed functions. - -###### Layer Manifest File Version 1.0.1 - -The ability to define multiple layers using the "layers" array was added. This -JSON array field can be used when defining a single layer or multiple layers. -The "layer" field is still present and valid for a single layer definition. - -###### Layer Manifest File Version 1.0.0 - -The initial version of the layer manifest file specified the basic format and -fields of a layer JSON file. The fields of the 1.0.0 file format include: - * "file\_format\_version" - * "layer" - * "name" - * "type" - * "library\_path" - * "api\_version" - * "implementation\_version" - * "description" - * "functions" - * "instance\_extensions" - * "device\_extensions" - * "enable\_environment" - * "disable\_environment" - -It was also during this time that the value of "DEVICE" was deprecated from -the "type" field. - - -#### Layer Library Versions - -The current Layer Library interface is at version 2. The following sections -detail the differences between the various versions. - -##### Layer Library API Version 2 - -Introduced the concept of -[loader and layer interface](#layer-version-negotiation) using the new -`vkNegotiateLoaderLayerInterfaceVersion` function. Additionally, it introduced -the concept of -[Layer Unknown Physical Device Extensions](#layer-unknown-physical-device- -extensions) -and the associated `vk_layerGetPhysicalDeviceProcAddr` function. Finally, it -changed the manifest file definition to 1.1.0. - -##### Layer Library API Version 1 - -A layer library supporting interface version 1 had the following behavior: - 1. `GetInstanceProcAddr` and `GetDeviceProcAddr` were directly exported - 2. The layer manifest file was able to override the names of the -`GetInstanceProcAddr` and `GetDeviceProcAddr`functions. - -##### Layer Library API Version 0 - -A layer library supporting interface version 0 must define and export these -introspection functions, unrelated to any Vulkan function despite the names, -signatures, and other similarities: - -- `vkEnumerateInstanceLayerProperties` enumerates all layers in a layer -library. - - This function never fails. - - When a layer library contains only one layer, this function may be an alias - to the layer's `vkEnumerateInstanceLayerProperties`. -- `vkEnumerateInstanceExtensionProperties` enumerates instance extensions of - layers in a layer library. - - "pLayerName" is always a valid layer name. - - This function never fails. - - When a layer library contains only one layer, this function may be an alias - to the layer's `vkEnumerateInstanceExtensionProperties`. -- `vkEnumerateDeviceLayerProperties` enumerates a subset (can be full, - proper, or empty subset) of layers in a layer library. - - "physicalDevice" is always `VK_NULL_HANDLE`. - - This function never fails. - - If a layer is not enumerated by this function, it will not participate in - device function interception. -- `vkEnumerateDeviceExtensionProperties` enumerates device extensions of - layers in a layer library. - - "physicalDevice" is always `VK_NULL_HANDLE`. - - "pLayerName" is always a valid layer name. - - This function never fails. - -It must also define and export these functions once for each layer in the -library: - -- `GetInstanceProcAddr(instance, pName)` behaves identically to a -layer's vkGetInstanceProcAddr except it is exported. - - When a layer library contains only one layer, this function may - alternatively be named `vkGetInstanceProcAddr`. - -- `GetDeviceProcAddr` behaves identically to a layer's -vkGetDeviceProcAddr except it is exported. - - When a layer library contains only one layer, this function may - alternatively be named `vkGetDeviceProcAddr`. - -All layers contained within a library must support `vk_layer.h`. They do not -need to implement functions that they do not intercept. They are recommended -not to export any functions. - - -
-
- -## Vulkan Installable Client Driver Interface With the Loader - -This section discusses the various requirements for the loader and a Vulkan -ICD to properly hand-shake. - - * [ICD Discovery](#icd-discovery) - * [Overriding the Default ICD Usage](#overriding-the-default-icd-usage) - * [ICD Manifest File Usage](#icd-manifest-file-usage) - * [ICD Discovery on Windows](#icd-discovery-on-windows) - * [ICD Discovery on Linux](#icd-discovery-on-linux) - * [ICD Discovery on MacOS](#icd-discovery-on-macos) - * [Using Pre-Production ICDs on Windows, Linux and MacOS](#using-pre-production-icds-on-windows-and-linux) - * [ICD Discovery on Android](#icd-discovery-on-android) - * [ICD Manifest File Format](#icd-manifest-file-format) - * [ICD Manifest File Versions](#icd-manifest-file-versions) - * [ICD Manifest File Version 1.0.0](#icd-manifest-file-version-1.0.0) - * [ICD Vulkan Entry-Point Discovery](#icd-vulkan-entry-point-discovery) - * [ICD API Version](#icd-api-version) - * [ICD Unknown Physical Device Extensions](#icd-unknown-physical-device-extensions) - * [ICD Dispatchable Object Creation](#icd-dispatchable-object-creation) - * [Handling KHR Surface Objects in WSI Extensions](#handling-khr-surface-objects-in-wsi-extensions) - * [Loader and ICD Interface Negotiation](#loader-and-icd-interface-negotiation) - * [Windows, Linux, and MacOS ICD Negotiation](#windows-and-linux-icd-negotiation) - * [Version Negotiation Between Loader and ICDs](#version-negotiation-between-loader-and-icds) - * [Interfacing With Legacy ICDs or Loader](#interfacing-with-legacy-icds-or-loader) - * [Loader Version 5 Interface Requirements](#loader-version-5-interface-requirements) - * [Loader Version 4 Interface Requirements](#loader-version-4-interface-requirements) - * [Loader Version 3 Interface Requirements](#loader-version-3-interface-requirements) - * [Loader Version 2 Interface Requirements](#loader-version-2-interface-requirements) - * [Loader Versions 0 and 1 Interface Requirements](#loader-versions-0-and-1-interface-requirements) - * [Android ICD Negotiation](#android-icd-negotiation) - - -### ICD Discovery - -Vulkan allows multiple drivers each with one or more devices (represented by a -Vulkan `VkPhysicalDevice` object) to be used collectively. The loader is -responsible for discovering available Vulkan ICDs on the system. Given a list -of available ICDs, the loader can enumerate all the physical devices available -for an application and return this information to the application. The process -in which the loader discovers the available Installable Client Drivers (ICDs) -on a system is platform dependent. Windows, Linux, Android, and MacOS ICD discovery -details are listed below. - -#### Overriding the Default ICD Usage - -There may be times that a developer wishes to force the loader to use a specific ICD. -This could be for many reasons including : using a beta driver, or forcing the loader -to skip a problematic ICD. In order to support this, the loader can be forced to -look at specific ICDs with the `VK_ICD_FILENAMES` environment variable. In order -to use the setting, simply set it to a properly delimited list of ICD Manifest -files that you wish to use. In this case, please provide the global path to these -files to reduce issues. - -For example: - -##### On Windows - -``` -set VK_ICD_FILENAMES=/windows/system32/nv-vk64.json -``` - -This is an example which is using the `VK_ICD_FILENAMES` override on Windows to point -to the Nvidia Vulkan driver's ICD Manifest file. - -##### On Linux - -``` -export VK_ICD_FILENAMES=/home/user/dev/mesa/share/vulkan/icd.d/intel_icd.x86_64.json -``` - -This is an example which is using the `VK_ICD_FILENAMES` override on Linux to point -to the Intel Mesa driver's ICD Manifest file. - -##### On MacOS - -``` -export VK_ICD_FILENAMES=/home/user/MoltenVK/Package/Latest/MoltenVK/macOS/MoltenVK_icd.json -``` - -This is an example which is using the `VK_ICD_FILENAMES` override on MacOS to point -to an installation and build of the MoltenVK GitHub repository that contains the MoltenVK ICD. - -#### ICD Manifest File Usage - -As with layers, on Windows, Linux and MacOS systems, JSON formatted manifest files are -used to store ICD information. In order to find system-installed drivers, the -Vulkan loader will read the JSON files to identify the names and attributes of -each driver. One thing you will notice is that ICD Manifest files are much -simpler than the corresponding layer Manifest files. - -See the [Current ICD Manifest File Format](#icd-manifest-file-format) section -for more details. - - -#### ICD Discovery on Windows - -In order to find installed ICDs, the loader scans through registry keys specific to Display -Adapters and all Software Components associated with these adapters for the -locations of JSON manifest files. These keys are located in device keys -created during driver installation and contain configuration information -for base settings, including OpenGL and Direct3D ICD location. - -The Device Adapter and Software Component key paths should be obtained through the PnP -Configuration Manager API. The `000X` key will be a numbered key, where each -device is assigned a different number. - -``` - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Adapter GUID}\000X\VulkanDriverName - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{SoftwareComponent GUID}\000X\VulkanDriverName -``` - -In addition, on 64-bit systems there may be another set of registry values, listed -below. These values record the locations of 32-bit layers on 64-bit operating systems, -in the same way as the Windows-on-Windows functionality. - -``` - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{Adapter GUID}\000X\VulkanDriverNameWow - HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{SoftwareComponent GUID}\000X\VulkanDriverNameWow -``` - -If any of the above values exist and is of type `REG_SZ`, the loader will open the JSON -manifest file specified by the key value. Each value must be a full absolute -path to a JSON manifest file. The values may also be of type `REG_MULTI_SZ`, in -which case the value will be interpreted as a list of paths to JSON manifest files. - -Additionally, the Vulkan loader will scan the values in the following Windows registry key: - -``` - HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\Vulkan\Drivers -``` - -For 32-bit applications on 64-bit Windows, the loader scan's the 32-bit -registry location: - -``` - HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Khronos\Vulkan\Drivers -``` - -Every ICD in these locations should be given as a DWORD, with value 0, where -the name of the value is the full path to a JSON manifest file. The Vulkan loader -will attempt to open each manifest file to obtain the information about an ICD's -shared library (".dll") file. - -For example, let us assume the registry contains the following data: - -``` -[HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\Vulkan\Drivers\] - -"C:\vendor a\vk_vendora.json"=dword:00000000 -"C:\windows\system32\vendorb_vk.json"=dword:00000001 -"C:\windows\system32\vendorc_icd.json"=dword:00000000 -``` - -In this case, the loader will step through each entry, and check the value. If -the value is 0, then the loader will attempt to load the file. In this case, -the loader will open the first and last listings, but not the middle. This -is because the value of 1 for vendorb_vk.json disables the driver. - -The Vulkan loader will open each enabled manifest file found to obtain the name -or pathname of an ICD shared library (".DLL") file. - -ICDs should use the registry locations from the PnP Configuration Manager wherever -practical. That location clearly ties the ICD to a given device. The -`SOFTWARE\Khronos\Vulkan\Drivers` location is the older method for locating ICDs, -and is retained for backwards compatibility. - -See the [ICD Manifest File Format](#icd-manifest-file-format) section for more -details. - - -#### ICD Discovery on Linux - -In order to find installed ICDs, the Vulkan loader will scan the files -in the following Linux directories: - -``` - /usr/local/etc/vulkan/icd.d - /usr/local/share/vulkan/icd.d - /etc/vulkan/icd.d - /usr/share/vulkan/icd.d - $HOME/.local/share/vulkan/icd.d -``` - -The "/usr/local/*" directories can be configured to be other directories at -build time. - -The typical usage of the directories is indicated in the table below. - -| Location | Details | -|-------------------|------------------------| -| $HOME/.local/share/vulkan/icd.d | $HOME is the current home directory of the application's user id; this path will be ignored for suid programs | -| "/usr/local/etc/vulkan/icd.d" | Directory for locally built ICDs | -| "/usr/local/share/vulkan/icd.d" | Directory for locally built ICDs | -| "/etc/vulkan/icd.d" | Location of ICDs installed from non-Linux-distribution-provided packages | -| "/usr/share/vulkan/icd.d" | Location of ICDs installed from Linux-distribution-provided packages | - -The Vulkan loader will open each manifest file found to obtain the name or -pathname of an ICD shared library (".so") file. - -See the [ICD Manifest File Format](#icd-manifest-file-format) section for more -details. - -#### ICD Discovery on MacOS - -In order to find installed ICDs, the Vulkan loader will scan the files -in the following directories: - -``` - /Contents/Resources/vulkan/icd.d - /etc/vulkan/icd.d - /usr/local/share/vulkan/icd.d - /usr/share/vulkan/icd.d - $HOME/.local/share/vulkan/icd.d -``` - -The "/usr/local/*" directories can be configured to be other directories at -build time. - -The typical usage of the directories is indicated in the table below. - -| Location | Details | -|-------------------|------------------------| -| <bundle>/Contents/Resources/vulkan/icd.d | Directory for ICDs that are bundled with the application (searched first) | -| "/etc/vulkan/icd.d" | Location of ICDs installed manually | -| "/usr/local/share/vulkan/icd.d" | Directory for locally built ICDs | -| "/usr/share/vulkan/icd.d" | Location of ICDs installed from packages | -| $HOME/.local/share/vulkan/icd.d | $HOME is the current home directory of the application's user id; this path will be ignored for suid programs | - -The Vulkan loader will open each manifest file found to obtain the name or -pathname of an ICD shared library (".dylib") file. - -See the [ICD Manifest File Format](#icd-manifest-file-format) section for more -details. - -##### Additional Settings For ICD Debugging - -If you are seeing issues which may be related to the ICD. A possible option to debug is to enable the -`LD_BIND_NOW` environment variable. This forces every dynamic library's symbols to be fully resolved on load. If -there is a problem with an ICD missing symbols on your system, this will expose it and cause the Vulkan loader -to fail on loading the ICD. It is recommended that you enable `LD_BIND_NOW` along with `VK_LOADER_DEBUG=warn` -to expose any issues. - -#### Using Pre-Production ICDs on Windows, Linux and MacOS - -Independent Hardware Vendor (IHV) pre-production ICDs. In some cases, a -pre-production ICD may be in an installable package. In other cases, a -pre-production ICD may simply be a shared library in the developer's build tree. -In this latter case, we want to allow developers to point to such an ICD without -modifying the system-installed ICD(s) on their system. - -This need is met with the use of the "VK\_ICD\_FILENAMES" environment variable, -which will override the mechanism used for finding system-installed ICDs. In -other words, only the ICDs listed in "VK\_ICD\_FILENAMES" will be used. - -The "VK\_ICD\_FILENAMES" environment variable is a list of ICD -manifest files, containing the full path to the ICD JSON Manifest file. This -list is colon-separated on Linux and MacOS, and semi-colon separated on Windows. - -Typically, "VK\_ICD\_FILENAMES" will only contain a full pathname to one info -file for a developer-built ICD. A separator (colon or semi-colon) is only used -if more than one ICD is listed. - -**NOTE:** On Linux and MacOS, this environment variable will be ignored for suid programs. - - -#### ICD Discovery on Android - -The Android loader lives in the system library folder. The location cannot be -changed. The loader will load the driver/ICD via hw\_get\_module with the ID -of "vulkan". **Due to security policies in Android, none of this can be modified -under normal use.** - - -### ICD Manifest File Format - -The following section discusses the details of the ICD Manifest JSON file -format. The JSON file itself does not have any requirements for naming. The -only requirement is that the extension suffix of the file ends with ".json". - -Here is an example ICD JSON Manifest file: - -``` -{ - "file_format_version": "1.0.0", - "ICD": { - "library_path": "path to ICD library", - "api_version": "1.0.5" - } -} -``` - -| Field Name | Field Value | -|----------------|--------------------| -| "file\_format\_version" | The JSON format major.minor.patch version number of this file. Currently supported version is 1.0.0. | -| "ICD" | The identifier used to group all ICD information together. | -| "library_path" | The "library\_path" specifies either a filename, a relative pathname, or a full pathname to a layer shared library file. If "library\_path" specifies a relative pathname, it is relative to the path of the JSON manifest file. If "library\_path" specifies a filename, the library must live in the system's shared object search path. There are no rules about the name of the ICD shared library files other than it should end with the appropriate suffix (".DLL" on Windows, ".so" on Linux and "*.dylib" on MacOS). | N/A | -| "api_version" | The major.minor.patch version number of the Vulkan API that the shared library files for the ICD was built against. For example: 1.0.33. | - -**NOTE:** If the same ICD shared library supports multiple, incompatible -versions of text manifest file format versions, it must have separate -JSON files for each (all of which may point to the same shared library). - -##### ICD Manifest File Versions - -There has only been one version of the ICD manifest files supported. This is -version 1.0.0. - -###### ICD Manifest File Version 1.0.0 - -The initial version of the ICD Manifest file specified the basic format and -fields of a layer JSON file. The fields of the 1.0.0 file format include: - * "file\_format\_version" - * "ICD" - * "library\_path" - * "api\_version" - - -### ICD Vulkan Entry-Point Discovery - -The Vulkan symbols exported by an ICD must not clash with the loader's exported -Vulkan symbols. This could be for several reasons. Because of this, all ICDs -must export the following function that is used for discovery of ICD Vulkan -entry-points. This entry-point is not a part of the Vulkan API itself, only a -private interface between the loader and ICDs for version 1 and higher -interfaces. - -```cpp -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr( - VkInstance instance, - const char* pName); -``` - -This function has very similar semantics to `vkGetInstanceProcAddr`. -`vk_icdGetInstanceProcAddr` returns valid function pointers for all the global- -level and instance-level Vulkan functions, and also for `vkGetDeviceProcAddr`. -Global-level functions are those which contain no dispatchable object as the -first parameter, such as `vkCreateInstance` and -`vkEnumerateInstanceExtensionProperties`. The ICD must support querying global- -level entry-points by calling `vk_icdGetInstanceProcAddr` with a NULL -`VkInstance` parameter. Instance-level functions are those that have either -`VkInstance`, or `VkPhysicalDevice` as the first parameter dispatchable object. -Both core entry-points and any instance extension entry-points the ICD supports -should be available via `vk_icdGetInstanceProcAddr`. Future Vulkan instance -extensions may define and use new instance-level dispatchable objects other -than `VkInstance` and `VkPhysicalDevice`, in which case extension entry-points -using these newly defined dispatchable objects must be queryable via -`vk_icdGetInstanceProcAddr`. - -All other Vulkan entry-points must either: - * NOT be exported directly from the ICD library - * or NOT use the official Vulkan function names if they are exported - -This requirement is for ICD libraries that include other -functionality (such as OpenGL) and thus could be loaded by the -application prior to when the Vulkan loader library is loaded by the -application. - -Beware of interposing by dynamic OS library loaders if the official Vulkan -names are used. On Linux, if official names are used, the ICD library must be -linked with -Bsymbolic. - - -### ICD API Version -When an application calls `vkCreateInstance`, it can optionally include a -`VkApplicationInfo` struct, which includes an `apiVersion` field. A Vulkan 1.0 -ICD was required to return `VK_ERROR_INCOMPATIBLE_DRIVER` if it did not -support the API version that the user passed. Beginning with Vulkan 1.1, ICDs -are not allowed to return this error for any value of `apiVersion`. This -creates a problem when working with multiple ICDs, where one is a 1.0 ICD and -another is newer. - -A loader that is newer than 1.0 will always give the version it supports when -the application calls `vkEnumerateInstanceVersion`, regardless of the API -version supported by the ICDs on the system. This means that when the -application calls `vkCreateInstance`, the loader will be forced to pass a copy -of the `VkApplicationInfo` struct where `apiVersion` is 1.0 to any 1.0 drivers -in order to prevent an error. To determine if this must be done, the loader -will perform the following steps: - -1. Load the ICD's dynamic library -2. Call the ICD's `vkGetInstanceProcAddr` command to get a pointer to -`vkEnumerateInstanceVersion` -3. If the pointer to `vkEnumerateInstanceVersion` is not `NULL`, it will be -called to get the ICD's supported API version - -The ICD will be treated as a 1.0 ICD if any of the following conditions are met: - -- The function pointer to `vkEnumerateInstanceVersion` is `NULL` -- The version returned by `vkEnumerateInstanceVersion` is less than 1.1 -- `vkEnumerateInstanceVersion` returns anything other than `VK_SUCCESS` - -If the ICD only supports Vulkan 1.0, the loader will ensure that any -`VkApplicationInfo` struct that is passed to the ICD will have an `apiVersion` -field set to Vulkan 1.0. Otherwise, the loader will pass the struct to the ICD -without any changes. - - -### ICD Unknown Physical Device Extensions - -Originally, if the loader was called with `vkGetInstanceProcAddr`, it would -result in the following behavior: - 1. The loader would check if core function: - - If it was, it would return the function pointer - 2. The loader would check if known extension function: - - If it was, it would return the function pointer - 3. If the loader knew nothing about it, it would call down using -`GetInstanceProcAddr` - - If it returned non-NULL, treat it as an unknown logical device command. - - This meant setting up a generic trampoline function that takes in a -VkDevice as the first parameter and adjusting the dispatch table to call the -ICD/Layers function after getting the dispatch table from the VkDevice. - 4. If all the above failed, the loader would return NULL to the application. - -This caused problems when an ICD attempted to expose new physical device -extensions the loader knew nothing about, but an application did. Because the -loader knew nothing about it, the loader would get to step 3 in the above -process and would treat the function as an unknown logical device command. The -problem is, this would create a generic VkDevice trampoline function which, on -the first call, would attempt to dereference the VkPhysicalDevice as a VkDevice. -This would lead to a crash or corruption. - -In order to identify the extension entry-points specific to physical device -extensions, the following function can be added to an ICD: - -```cpp -PFN_vkVoidFunction vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, - const char* pName); -``` - -This function behaves similar to `vkGetInstanceProcAddr` and -`vkGetDeviceProcAddr` except it should only return values for physical device -extension entry-points. In this way, it compares "pName" to every physical -device function supported in the ICD. - -The following rules apply: -* If it is the name of a physical device function supported by the ICD, the -pointer to the ICD's corresponding function should be returned. -* If it is the name of a valid function which is **not** a physical device -function (i.e. an Instance, Device, or other function implemented by the ICD), -then the value of NULL should be returned. -* If the ICD has no idea what this function is, it should return NULL. - -This support is optional and should not be considered a requirement. This is -only required if an ICD intends to support some functionality not directly -supported by a significant population of loaders in the public. If an ICD -does implement this support, it should return the address of its -`vk_icdGetPhysicalDeviceProcAddr` function through the `vkGetInstanceProcAddr` -function. - -The new behavior of the loader's vkGetInstanceProcAddr with support for the -`vk_icdGetPhysicalDeviceProcAddr` function is as follows: - 1. Check if core function: - - If it is, return the function pointer - 2. Check if known instance or device extension function: - - If it is, return the function pointer - 3. Call the layer/ICD `GetPhysicalDeviceProcAddr` - - If it returns non-NULL, return a trampoline to a generic physical device -function, and setup a generic terminator which will pass it to the proper ICD. - 4. Call down using `GetInstanceProcAddr` - - If it returns non-NULL, treat it as an unknown logical device command. -This means setting up a generic trampoline function that takes in a VkDevice as -the first parameter and adjusting the dispatch table to call the ICD/Layers -function after getting the dispatch table from the VkDevice. Then, return the -pointer to corresponding trampoline function. - 5. Return NULL - -You can see now, that, if the command gets promoted to core later, it will no -longer be setup using `vk_icdGetPhysicalDeviceProcAddr`. Additionally, if the -loader adds direct support for the extension, it will no longer get to step 3, -because step 2 will return a valid function pointer. However, the ICD should -continue to support the command query via `vk_icdGetPhysicalDeviceProcAddr`, -until at least a Vulkan version bump, because an older loader may still be -attempting to use the commands. - - -### ICD Dispatchable Object Creation - -As previously covered, the loader requires dispatch tables to be accessible -within Vulkan dispatchable objects, such as: `VkInstance`, `VkPhysicalDevice`, -`VkDevice`, `VkQueue`, and `VkCommandBuffer`. The specific requirements on all -dispatchable objects created by ICDs are as follows: - -- All dispatchable objects created by an ICD can be cast to void \*\* -- The loader will replace the first entry with a pointer to the dispatch table - which is owned by the loader. This implies three things for ICD drivers - 1. The ICD must return a pointer for the opaque dispatchable object handle - 2. This pointer points to a regular C structure with the first entry being a - pointer. - * **NOTE:** For any C\++ ICD's that implement VK objects directly as C\++ -classes. - * The C\++ compiler may put a vtable at offset zero if your class is non- -POD due to the use of a virtual function. - * In this case use a regular C structure (see below). - 3. The loader checks for a magic value (ICD\_LOADER\_MAGIC) in all the created - dispatchable objects, as follows (see `include/vulkan/vk_icd.h`): - -```cpp -#include "vk_icd.h" - -union _VK_LOADER_DATA { - uintptr loadermagic; - void *loaderData; -} VK_LOADER_DATA; - -vkObj alloc_icd_obj() -{ - vkObj *newObj = alloc_obj(); - ... - // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC - - set_loader_magic_value(newObj); - ... - return newObj; -} -``` - - -### Handling KHR Surface Objects in WSI Extensions - -Normally, ICDs handle object creation and destruction for various Vulkan -objects. The WSI surface extensions for Linux, Windows, and MacOS -("VK\_KHR\_win32\_surface", "VK\_KHR\_xcb\_surface", "VK\_KHR\_xlib\_surface", -"VK\_KHR\_mir\_surface", "VK\_KHR\_wayland\_surface", "VK\_MVK\_macos\_surface" -and "VK\_KHR\_surface") -are handled differently. For these extensions, the `VkSurfaceKHR` object -creation and destruction may be handled by either the loader, or an ICD. - -If the loader handles the management of the `VkSurfaceKHR` objects: - 1. The loader will handle the calls to `vkCreateXXXSurfaceKHR` and -`vkDestroySurfaceKHR` - functions without involving the ICDs. - * Where XXX stands for the Windowing System name: - * Mir - * Wayland - * Xcb - * Xlib - * Windows - * Android - * MacOS (`vkCreateMacOSSurfaceMVK`) - 2. The loader creates a `VkIcdSurfaceXXX` object for the corresponding -`vkCreateXXXSurfaceKHR` call. - * The `VkIcdSurfaceXXX` structures are defined in `include/vulkan/vk_icd.h`. - 3. ICDs can cast any `VkSurfaceKHR` object to a pointer to the appropriate - `VkIcdSurfaceXXX` structure. - 4. The first field of all the `VkIcdSurfaceXXX` structures is a -`VkIcdSurfaceBase` enumerant that indicates whether the - surface object is Win32, Xcb, Xlib, Mir, or Wayland. - -The ICD may choose to handle `VkSurfaceKHR` object creation instead. If an ICD -desires to handle creating and destroying it must do the following: - 1. Support version 3 or newer of the loader/ICD interface. - 2. Export and handle all functions that take in a `VkSurfaceKHR` object, -including: - * `vkCreateXXXSurfaceKHR` - * `vkGetPhysicalDeviceSurfaceSupportKHR` - * `vkGetPhysicalDeviceSurfaceCapabilitiesKHR` - * `vkGetPhysicalDeviceSurfaceFormatsKHR` - * `vkGetPhysicalDeviceSurfacePresentModesKHR` - * `vkCreateSwapchainKHR` - * `vkDestroySurfaceKHR` - -Because the `VkSurfaceKHR` object is an instance-level object, one object can be -associated with multiple ICDs. Therefore, when the loader receives the -`vkCreateXXXSurfaceKHR` call, it still creates an internal `VkSurfaceIcdXXX` -object. This object acts as a container for each ICD's version of the -`VkSurfaceKHR` object. If an ICD does not support the creation of its own -`VkSurfaceKHR` object, the loader's container stores a NULL for that ICD. On -the other hand, if the ICD does support `VkSurfaceKHR` creation, the loader will -make the appropriate `vkCreateXXXSurfaceKHR` call to the ICD, and store the -returned pointer in it's container object. The loader then returns the -`VkSurfaceIcdXXX` as a `VkSurfaceKHR` object back up the call chain. Finally, -when the loader receives the `vkDestroySurfaceKHR` call, it subsequently calls -`vkDestroySurfaceKHR` for each ICD who's internal `VkSurfaceKHR` object is not -NULL. Then the loader destroys the container object before returning. - - -### Loader and ICD Interface Negotiation - -Generally, for functions issued by an application, the loader can be -viewed as a pass through. That is, the loader generally doesn't modify the -functions or their parameters, but simply calls the ICDs entry-point for that -function. There are specific additional interface requirements an ICD needs to -comply with that are not part of any requirements from the Vulkan specification. -These additional requirements are versioned to allow flexibility in the future. - - -#### Windows, Linux and MacOS ICD Negotiation - - -##### Version Negotiation Between Loader and ICDs - -All ICDs (supporting interface version 2 or higher) must export the following -function that is used for determination of the interface version that will be -used. This entry-point is not a part of the Vulkan API itself, only a private -interface between the loader and ICDs. - -```cpp - VKAPI_ATTR VkResult VKAPI_CALL - vk_icdNegotiateLoaderICDInterfaceVersion( - uint32_t* pSupportedVersion); -``` - -This function allows the loader and ICD to agree on an interface version to use. -The "pSupportedVersion" parameter is both an input and output parameter. -"pSupportedVersion" is filled in by the loader with the desired latest interface -version supported by the loader (typically the latest). The ICD receives this -and returns back the version it desires in the same field. Because it is -setting up the interface version between the loader and ICD, this should be -the first call made by a loader to the ICD (even prior to any calls to -`vk_icdGetInstanceProcAddr`). - -If the ICD receiving the call no longer supports the interface version provided -by the loader (due to deprecation), then it should report -VK_ERROR_INCOMPATIBLE_DRIVER error. Otherwise it sets the value pointed by -"pSupportedVersion" to the latest interface version supported by both the ICD -and the loader and returns VK_SUCCESS. - -The ICD should report VK_SUCCESS in case the loader provided interface version -is newer than that supported by the ICD, as it's the loader's responsibility to -determine whether it can support the older interface version supported by the -ICD. The ICD should also report VK_SUCCESS in the case its interface version -is greater than the loader's, but return the loader's version. Thus, upon -return of VK_SUCCESS the "pSupportedVersion" will contain the desired interface -version to be used by the ICD. - -If the loader receives an interface version from the ICD that the loader no -longer supports (due to deprecation), or it receives a -VK_ERROR_INCOMPATIBLE_DRIVER error instead of VK_SUCCESS, then the loader will -treat the ICD as incompatible and will not load it for use. In this case, the -application will not see the ICDs `vkPhysicalDevice` during enumeration. - -###### Interfacing With Legacy ICDs or Loader - -If a loader sees that an ICD does not export the -`vk_icdNegotiateLoaderICDInterfaceVersion` function, then the loader assumes the -corresponding ICD only supports either interface version 0 or 1. - -From the other side of the interface, if an ICD sees a call to -`vk_icdGetInstanceProcAddr` before a call to -`vk_icdNegotiateLoaderICDInterfaceVersion`, then it knows that loader making the calls -is a legacy loader supporting version 0 or 1. If the loader calls -`vk_icdGetInstanceProcAddr` first, it supports at least version 1. Otherwise, -the loader only supports version 0. - - -##### Loader Version 5 Interface Requirements - -Version 5 of the loader/ICD interface has no changes to the actual interface. -If the loader requests interface version 5 or greater, it is simply -an indication to ICDs that the loader is now evaluating if the API Version info -passed into vkCreateInstance is a valid version for the loader. If it is not, -the loader will catch this during vkCreateInstance and fail with a -VK_ERROR_INCOMPATIBLE_DRIVER error. - -On the other hand, if version 5 or newer is not requested by the loader, then it -indicates to the ICD that the loader is ignorant of the API version being -requested. Because of this, it falls on the ICD to validate that the API -Version is not greater than major = 1 and minor = 0. If it is, then the ICD -should automatically fail with a VK_ERROR_INCOMPATIBLE_DRIVER error since the -loader is a 1.0 loader, and is unaware of the version. - -Here is a table of the expected behaviors: - -| Loader Supports I/f Version | ICD Supports I/f Version | Result | -| :---: |:---:|------------------------| -| <= 4 | <= 4 | ICD must fail with `VK_ERROR_INCOMPATIBLE_DRIVER` for all vkCreateInstance calls with apiVersion set to > Vulkan 1.0 because both the loader and ICD support interface version <= 4. Otherwise, the ICD should behave as normal. | -| <= 4 | >= 5 | 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. | -| >= 5 | <= 4 | Loader will fail with `VK_ERROR_INCOMPATIBLE_DRIVER` if it can't handle the apiVersion. ICD may pass for all apiVersions, but since it's interface is <= 4, it is best if it assumes it needs to do the work of rejecting anything > Vulkan 1.0 and fail with `VK_ERROR_INCOMPATIBLE_DRIVER`. Otherwise, the ICD should behave as normal. | -| >= 5 | >= 5 | Loader will fail with `VK_ERROR_INCOMPATIBLE_DRIVER` if it can't handle the apiVersion, and ICDs should fail with `VK_ERROR_INCOMPATIBLE_DRIVER` **only if** they can not support the specified apiVersion. Otherwise, the ICD should behave as normal. | - -##### Loader Version 4 Interface Requirements - -The major change to version 4 of the loader/ICD interface is the support of -[Unknown Physical Device Extensions](#icd-unknown-physical-device- -extensions] using the `vk_icdGetPhysicalDeviceProcAddr` function. This -function is purely optional. However, if an ICD supports a Physical Device -extension, it must provide a `vk_icdGetPhysicalDeviceProcAddr` function. -Otherwise, the loader will continue to treat any unknown functions as VkDevice -functions and cause invalid behavior. - - -##### Loader Version 3 Interface Requirements - -The primary change that occurred in version 3 of the loader/ICD interface was to -allow an ICD to handle creation/destruction of their own KHR_surfaces. Up until -this point, the loader created a surface object that was used by all ICDs. -However, some ICDs may want to provide their own surface handles. If an ICD -chooses to enable this support, it must export support for version 3 of the -loader/ICD interface, as well as any Vulkan function that uses a KHR_surface -handle, such as: -- `vkCreateXXXSurfaceKHR` (where XXX is the platform specific identifier [i.e. -`vkCreateWin32SurfaceKHR` for Windows]) -- `vkDestroySurfaceKHR` -- `vkCreateSwapchainKHR` -- `vkGetPhysicalDeviceSurfaceSupportKHR` -- `vkGetPhysicalDeviceSurfaceCapabilitiesKHR` -- `vkGetPhysicalDeviceSurfaceFormatsKHR` -- `vkGetPhysicalDeviceSurfacePresentModesKHR` - -An ICD can still choose to not take advantage of this functionality by simply -not exposing the above the `vkCreateXXXSurfaceKHR` and `vkDestroySurfaceKHR` -functions. - - -##### Loader Version 2 Interface Requirements - -Version 2 interface has requirements in three areas: - 1. ICD Vulkan entry-point discovery, - 2. `KHR_surface` related requirements in the WSI extensions, - 3. Vulkan dispatchable object creation requirements. - -##### Loader Versions 0 and 1 Interface Requirements - -Version 0 and 1 interfaces do not support version negotiation via -`vk_icdNegotiateLoaderICDInterfaceVersion`. ICDs can distinguish version 0 and -version 1 interfaces as follows: if the loader calls `vk_icdGetInstanceProcAddr` -first it supports version 1; otherwise the loader only supports version 0. - -Version 0 interface does not support `vk_icdGetInstanceProcAddr`. Version 0 -interface requirements for obtaining ICD Vulkan entry-points are as follows: - -- The function `vkGetInstanceProcAddr` **must be exported** in the ICD library -and returns valid function pointers for all the Vulkan API entry-points. -- `vkCreateInstance` **must be exported** by the ICD library. -- `vkEnumerateInstanceExtensionProperties` **must be exported** by the ICD -library. - -Additional Notes: - -- The loader will filter out extensions requested in `vkCreateInstance` and -`vkCreateDevice` before calling into the ICD; Filtering will be of extensions -advertised by entities (e.g. layers) different from the ICD in question. -- The loader will not call the ICD for `vkEnumerate\*LayerProperties`() as layer -properties are obtained from the layer libraries and layer JSON files. -- If an ICD library author wants to implement a layer, it can do so by having -the appropriate layer JSON manifest file refer to the ICD library file. -- The loader will not call the ICD for - `vkEnumerate\*ExtensionProperties` if "pLayerName" is not equal to `NULL`. -- ICDs creating new dispatchable objects via device extensions need to -initialize the created dispatchable object. The loader has generic *trampoline* -code for unknown device extensions. This generic *trampoline* code doesn't -initialize the dispatch table within the newly created object. See the -[Creating New Dispatchable Objects](#creating-new-dispatchable-objects) section -for more information on how to initialize created dispatchable objects for -extensions non known by the loader. - - -#### Android ICD Negotiation - -The Android loader uses the same protocol for initializing the dispatch -table as described above. The only difference is that the Android -loader queries layer and extension information directly from the -respective libraries and does not use the json manifest files used -by the Windows, Linux and MacOS loaders. - -## Table of Debug Environment Variables - -The following are all the Debug Environment Variables available for use with the -Loader. These are referenced throughout the text, but collected here for ease -of discovery. - -| Environment Variable | Behavior | Example Format | -|:---:|---------------------|----------------------| -| VK_ICD_FILENAMES | Force the loader to use the specific ICD JSON files. The value should contain a list of delimited full path listings to ICD JSON Manifest files. **NOTE:** If you fail to use the global path to a JSON file, you may encounter issues. | `export VK_ICD_FILENAMES=\intel.json:\amd.json`

`set VK_ICD_FILENAMES=\nvidia.json;\mesa.json` | -| VK_INSTANCE_LAYERS | Force the loader to add the given layers to the list of Enabled layers normally passed into `vkCreateInstance`. These layers are added first, and the loader will remove any duplicate layers that appear in both this list as well as that passed into `ppEnabledLayerNames`. | `export VK_INSTANCE_LAYERS=:`

`set VK_INSTANCE_LAYERS=;` | -| VK_LAYER_PATH | Override the loader's standard Layer library search folders and use the provided delimited folders to search for layer Manifest files. | `export VK_LAYER_PATH=:`

`set VK_LAYER_PATH=;` | -| VK_LOADER_DISABLE_INST_EXT_FILTER | Disable the filtering out of instance extensions that the loader doesn't know about. This will allow applications to enable instance extensions exposed by ICDs but that the loader has no support for. **NOTE:** This may cause the loader or application to crash. | `export VK_LOADER_DISABLE_INST_EXT_FILTER=1`

`set VK_LOADER_DISABLE_INST_EXT_FILTER=1` | -| VK_LOADER_DEBUG | Enable loader debug messages. Options are:
- error (only errors)
- warn (warnings and errors)
- info (info, warning, and errors)
- debug (debug + all before)
-all (report out all messages) | `export VK_LOADER_DEBUG=all`

`set VK_LOADER_DEBUG=warn` | - -## Glossary of Terms - -| Field Name | Field Value | -|:---:|--------------------| -| Android Loader | The loader designed to work primarily for the Android OS. This is generated from a different code-base than the desktop loader. But, in all important aspects, should be functionally equivalent. | -| Desktop Loader | The loader designed to work on Windows, Linux and MacOS. This is generated from a different [code-base](#https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers) than the Android loader. But in all important aspects, should be functionally equivalent. | -| Core Function | A function that is already part of the Vulkan core specification and not an extension. For example, vkCreateDevice(). | -| Device Call Chain | The call chain of functions followed for device functions. This call chain for a device function is usually as follows: first the application calls into a loader trampoline, then the loader trampoline calls enabled layers, the final layer calls into the ICD specific to the device. See the [Dispatch Tables and Call Chains](#dispatch-tables-and-call-chains) section for more information | -| Device Function | A Device function is any Vulkan function which takes a `VkDevice`, `VkQueue`, `VkCommandBuffer`, or any child of these, as its first parameter. Some Vulkan Device functions are: `vkQueueSubmit`, `vkBeginCommandBuffer`, `vkCreateEvent`. See the [Instance Versus Device](#instance-versus-device) section for more information. | -| Discovery | The process of the loader searching for ICD and Layer files to setup the internal list of Vulkan objects available. On Windows/Linux/MacOS, the discovery process typically focuses on searching for Manifest files. While on Android, the process focuses on searching for library files. | -| Dispatch Table | An array of function pointers (including core and possibly extension functions) used to step to the next entity in a call chain. The entity could be the loader, a layer or an ICD. See [Dispatch Tables and Call Chains](#dispatch-tables-and-call-chains) for more information. | -| Extension | A concept of Vulkan used to expand the core Vulkan functionality. Extensions may be IHV-specific, platform-specific, or more broadly available. You should always query if an extension exists, and enable it during `vkCreateInstance` (if it is an instance extension) or during `vkCreateDevice` (if it is a device extension). | -| ICD | Acronym for Installable Client Driver. These are drivers that are provided by IHVs to interact with the hardware they provide. See [Installable Client Drivers](#installable-client-drivers) section for more information. -| IHV | Acronym for an Independent Hardware Vendor. Typically the company that built the underlying hardware technology you are trying to use. A typical examples for a Graphics IHV are: AMD, ARM, Imagination, Intel, Nvidia, Qualcomm, etc. | -| Instance Call Chain | The call chain of functions followed for instance functions. This call chain for an instance function is usually as follows: first the application calls into a loader trampoline, then the loader trampoline calls enabled layers, the final layer calls a loader terminator, and the loader terminator calls all available ICDs. See the [Dispatch Tables and Call Chains](#dispatch-tables-and-call-chains) section for more information | -| Instance Function | An Instance function is any Vulkan function which takes as its first parameter either a `VkInstance` or a `VkPhysicalDevice` or nothing at all. Some Vulkan Instance functions are: `vkEnumerateInstanceExtensionProperties`, `vkEnumeratePhysicalDevices`, `vkCreateInstance`, `vkDestroyInstance`. See the [Instance Versus Device](#instance-versus-device) section for more information. | -| Layer | Layers are optional components that augment the Vulkan system. They can intercept, evaluate, and modify existing Vulkan functions on their way from the application down to the hardware. See the [Layers](#layers) section for more information. | -| Loader | The middle-ware program which acts as the mediator between Vulkan applications, Vulkan layers and Vulkan drivers. See [The Loader](#the loader) section for more information. | -| Manifest Files | Data files in JSON format used by the desktop loader. These files contain specific information for either a [Layer](#layer-manifest-file-format) or an [ICD](#icd-manifest-file-format). -| Terminator Function | The last function in the instance call chain above the ICDs and owned by the loader. This function is required in the instance call chain because all instance functionality must be communicated to all ICDs capable of receiving the call. See [Dispatch Tables and Call Chains](#dispatch-tables-and-call-chains) for more information. | -| Trampoline Function | The first function in an instance or device call chain owned by the loader which handles the setup and proper call chain walk using the appropriate dispatch table. On device functions (in the device call chain) this function can actually be skipped. See [Dispatch Tables and Call Chains](#dispatch-tables-and-call-chains) for more information. | -| WSI Extension | Acronym for Windowing System Integration. A Vulkan extension targeting a particular Windowing and designed to interface between the Windowing system and Vulkan. See [WSI Extensions](#wsi-extensions) for more information. | diff --git a/loader/README.md b/loader/README.md deleted file mode 100644 index 577796bf..00000000 --- a/loader/README.md +++ /dev/null @@ -1,8 +0,0 @@ -# Loader Specification and Interfaces -See LoaderAndLayerInterface.md. - -# Building -Builds for Linux and Windows are supported via CMake. See top level BUILD.md file. - - - diff --git a/loader/asm_offset.c b/loader/asm_offset.c deleted file mode 100644 index 97832afa..00000000 --- a/loader/asm_offset.c +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (c) 2017-2018 The Khronos Group Inc. - * Copyright (c) 2017-2018 Valve Corporation - * Copyright (c) 2017-2018 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Lenny Komow - */ - -// This code generates an assembly file which provides offsets to get struct members from assembly code. - -#include -#include "loader.h" - -#if !defined(_MSC_VER) || (_MSC_VER >= 1900) -#define SIZE_T_FMT "%-8zu" -#else -#define SIZE_T_FMT "%-8lu" -#endif - -struct ValueInfo -{ - const char *name; - size_t value; - const char *comment; -}; - -int main(int argc, char **argv) { - const char *assembler = NULL; - for (int i = 0; i < argc; ++i) { - if (!strcmp(argv[i], "MASM")) { - assembler = "MASM"; - } else if (!strcmp(argv[i], "GAS")) { - assembler = "GAS"; - } - } - if (assembler == NULL) { - return 1; - } - - struct ValueInfo values[] = { - { .name = "VK_DEBUG_REPORT_ERROR_BIT_EXT", .value = (size_t) VK_DEBUG_REPORT_ERROR_BIT_EXT, - .comment = "The numerical value of the enum value 'VK_DEBUG_REPORT_ERROR_BIT_EXT'" }, - { .name = "PTR_SIZE", .value = sizeof(void*), - .comment = "The size of a pointer" }, - { .name = "HASH_SIZE", .value = sizeof(struct loader_dispatch_hash_entry), - .comment = "The size of a 'loader_dispatch_hash_entry' struct" }, - { .name = "HASH_OFFSET_INSTANCE", .value = offsetof(struct loader_instance, phys_dev_ext_disp_hash), - .comment = "The offset of 'phys_dev_ext_disp_hash' within a 'loader_instance' struct" }, - { .name = "PHYS_DEV_OFFSET_INST_DISPATCH", .value = offsetof(struct loader_instance_dispatch_table, phys_dev_ext), - .comment = "The offset of 'phys_dev_ext' within in 'loader_instance_dispatch_table' struct" }, - { .name = "PHYS_DEV_OFFSET_PHYS_DEV_TRAMP", .value = offsetof(struct loader_physical_device_tramp, phys_dev), - .comment = "The offset of 'phys_dev' within a 'loader_physical_device_tramp' struct" }, - { .name = "ICD_TERM_OFFSET_PHYS_DEV_TERM", .value = offsetof(struct loader_physical_device_term, this_icd_term), - .comment = "The offset of 'this_icd_term' within a 'loader_physical_device_term' struct" }, - { .name = "PHYS_DEV_OFFSET_PHYS_DEV_TERM", .value = offsetof(struct loader_physical_device_term, phys_dev), - .comment = "The offset of 'phys_dev' within a 'loader_physical_device_term' struct" }, - { .name = "INSTANCE_OFFSET_ICD_TERM", .value = offsetof(struct loader_icd_term, this_instance), - .comment = "The offset of 'this_instance' within a 'loader_icd_term' struct" }, - { .name = "DISPATCH_OFFSET_ICD_TERM", .value = offsetof(struct loader_icd_term, phys_dev_ext), - .comment = "The offset of 'phys_dev_ext' within a 'loader_icd_term' struct" }, - { .name = "FUNC_NAME_OFFSET_HASH", .value = offsetof(struct loader_dispatch_hash_entry, func_name), - .comment = "The offset of 'func_name' within a 'loader_dispatch_hash_entry' struct" }, - { .name = "EXT_OFFSET_DEVICE_DISPATCH", .value = offsetof(struct loader_dev_dispatch_table, ext_dispatch), - .comment = "The offset of 'ext_dispatch' within a 'loader_dev_dispatch_table' struct" }, - }; - - FILE *file = fopen("gen_defines.asm", "w"); - fprintf(file, "\n"); - if (!strcmp(assembler, "MASM")) { - for (size_t i = 0; i < sizeof(values)/sizeof(values[0]); ++i) { - fprintf(file, "%-32s equ " SIZE_T_FMT "; %s\n", values[i].name, values[i].value, values[i].comment); - } - } else if (!strcmp(assembler, "GAS")) { -#ifdef __x86_64__ - fprintf(file, ".set X86_64, 1\n"); -#endif // __x86_64__ - for (size_t i = 0; i < sizeof(values)/sizeof(values[0]); ++i) { - fprintf(file, ".set %-32s, " SIZE_T_FMT "# %s\n", values[i].name, values[i].value, values[i].comment); - } - } - return fclose(file); -} diff --git a/loader/cJSON.c b/loader/cJSON.c deleted file mode 100644 index 8da6d83c..00000000 --- a/loader/cJSON.c +++ /dev/null @@ -1,1215 +0,0 @@ -/* - Copyright (c) 2009 Dave Gamble - Copyright (c) 2015-2016 The Khronos Group Inc. - Copyright (c) 2015-2016 Valve Corporation - Copyright (c) 2015-2016 LunarG, Inc. - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ - -/* cJSON */ -/* JSON parser in C. */ - -#include -#include -#include -#include -#include -#include -#include -#include "cJSON.h" - -static const char *ep; - -const char *cJSON_GetErrorPtr(void) { return ep; } - -static void *(*cJSON_malloc)(size_t sz) = malloc; -static void (*cJSON_free)(void *ptr) = free; - -static char *cJSON_strdup(const char *str) { - size_t len; - char *copy; - - len = strlen(str) + 1; - if (!(copy = (char *)cJSON_malloc(len))) return 0; - memcpy(copy, str, len); - return copy; -} - -void cJSON_InitHooks(cJSON_Hooks *hooks) { - if (!hooks) { /* Reset hooks */ - cJSON_malloc = malloc; - cJSON_free = free; - return; - } - - cJSON_malloc = (hooks->malloc_fn) ? hooks->malloc_fn : malloc; - cJSON_free = (hooks->free_fn) ? hooks->free_fn : free; -} - -/* Internal constructor. */ -static cJSON *cJSON_New_Item(void) { - cJSON *node = (cJSON *)cJSON_malloc(sizeof(cJSON)); - if (node) memset(node, 0, sizeof(cJSON)); - return node; -} - -/* Delete a cJSON structure. */ -void cJSON_Delete(cJSON *c) { - cJSON *next; - while (c) { - next = c->next; - if (!(c->type & cJSON_IsReference) && c->child) cJSON_Delete(c->child); - if (!(c->type & cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring); - if (!(c->type & cJSON_StringIsConst) && c->string) cJSON_free(c->string); - cJSON_free(c); - c = next; - } -} - -void cJSON_Free(void *p) { cJSON_free(p); } - -/* Parse the input text to generate a number, and populate the result into item. - */ -static const char *parse_number(cJSON *item, const char *num) { - double n = 0, sign = 1, scale = 0; - int subscale = 0, signsubscale = 1; - - if (*num == '-') sign = -1, num++; /* Has sign? */ - if (*num == '0') num++; /* is zero */ - if (*num >= '1' && *num <= '9') do - n = (n * 10.0) + (*num++ - '0'); - while (*num >= '0' && *num <= '9'); /* Number? */ - if (*num == '.' && num[1] >= '0' && num[1] <= '9') { - num++; - do - n = (n * 10.0) + (*num++ - '0'), scale--; - while (*num >= '0' && *num <= '9'); - } /* Fractional part? */ - if (*num == 'e' || *num == 'E') /* Exponent? */ - { - num++; - if (*num == '+') - num++; - else if (*num == '-') - signsubscale = -1, num++; /* With sign? */ - while (*num >= '0' && *num <= '9') subscale = (subscale * 10) + (*num++ - '0'); /* Number? */ - } - - n = sign * n * pow(10.0, (scale + subscale * signsubscale)); /* number = +/- - number.fraction * - 10^+/- exponent */ - - item->valuedouble = n; - item->valueint = (int)n; - item->type = cJSON_Number; - return num; -} - -static size_t pow2gt(size_t x) { - --x; - x |= x >> 1; - x |= x >> 2; - x |= x >> 4; - x |= x >> 8; - x |= x >> 16; - return x + 1; -} - -typedef struct { - char *buffer; - size_t length; - size_t offset; -} printbuffer; - -static char *ensure(printbuffer *p, size_t needed) { - char *newbuffer; - size_t newsize; - if (!p || !p->buffer) return 0; - needed += p->offset; - if (needed <= p->length) return p->buffer + p->offset; - - newsize = pow2gt(needed); - newbuffer = (char *)cJSON_malloc(newsize); - if (!newbuffer) { - cJSON_free(p->buffer); - p->length = 0, p->buffer = 0; - return 0; - } - if (newbuffer) memcpy(newbuffer, p->buffer, p->length); - cJSON_free(p->buffer); - p->length = newsize; - p->buffer = newbuffer; - return newbuffer + p->offset; -} - -static size_t update(printbuffer *p) { - char *str; - if (!p || !p->buffer) return 0; - str = p->buffer + p->offset; - return p->offset + strlen(str); -} - -/* Render the number nicely from the given item into a string. */ -static char *print_number(cJSON *item, printbuffer *p) { - char *str = 0; - double d = item->valuedouble; - if (d == 0) { - if (p) - str = ensure(p, 2); - else - str = (char *)cJSON_malloc(2); /* special case for 0. */ - if (str) strcpy(str, "0"); - } else if (fabs(((double)item->valueint) - d) <= DBL_EPSILON && d <= INT_MAX && d >= INT_MIN) { - if (p) - str = ensure(p, 21); - else - str = (char *)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */ - if (str) sprintf(str, "%d", item->valueint); - } else { - if (p) - str = ensure(p, 64); - else - str = (char *)cJSON_malloc(64); /* This is a nice tradeoff. */ - if (str) { - if (fabs(floor(d) - d) <= DBL_EPSILON && fabs(d) < 1.0e60) - sprintf(str, "%.0f", d); - else if (fabs(d) < 1.0e-6 || fabs(d) > 1.0e9) - sprintf(str, "%e", d); - else - sprintf(str, "%f", d); - } - } - return str; -} - -static unsigned parse_hex4(const char *str) { - unsigned h = 0; - if (*str >= '0' && *str <= '9') - h += (*str) - '0'; - else if (*str >= 'A' && *str <= 'F') - h += 10 + (*str) - 'A'; - else if (*str >= 'a' && *str <= 'f') - h += 10 + (*str) - 'a'; - else - return 0; - h = h << 4; - str++; - if (*str >= '0' && *str <= '9') - h += (*str) - '0'; - else if (*str >= 'A' && *str <= 'F') - h += 10 + (*str) - 'A'; - else if (*str >= 'a' && *str <= 'f') - h += 10 + (*str) - 'a'; - else - return 0; - h = h << 4; - str++; - if (*str >= '0' && *str <= '9') - h += (*str) - '0'; - else if (*str >= 'A' && *str <= 'F') - h += 10 + (*str) - 'A'; - else if (*str >= 'a' && *str <= 'f') - h += 10 + (*str) - 'a'; - else - return 0; - h = h << 4; - str++; - if (*str >= '0' && *str <= '9') - h += (*str) - '0'; - else if (*str >= 'A' && *str <= 'F') - h += 10 + (*str) - 'A'; - else if (*str >= 'a' && *str <= 'f') - h += 10 + (*str) - 'a'; - else - return 0; - return h; -} - -/* Parse the input text into an unescaped cstring, and populate item. */ -static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC}; -static const char *parse_string(cJSON *item, const char *str) { - const char *ptr = str + 1; - char *ptr2; - char *out; - int len = 0; - unsigned uc, uc2; - if (*str != '\"') { - ep = str; - return 0; - } /* not a string! */ - - while (*ptr != '\"' && *ptr && ++len) - if (*ptr++ == '\\') ptr++; /* Skip escaped quotes. */ - - out = (char *)cJSON_malloc(len + 1); /* This is how long we need for the string, roughly. */ - if (!out) return 0; - - ptr = str + 1; - ptr2 = out; - while (*ptr != '\"' && *ptr) { - if (*ptr != '\\') - *ptr2++ = *ptr++; - else { - ptr++; - switch (*ptr) { - case 'b': - *ptr2++ = '\b'; - break; - case 'f': - *ptr2++ = '\f'; - break; - case 'n': - *ptr2++ = '\n'; - break; - case 'r': - *ptr2++ = '\r'; - break; - case 't': - *ptr2++ = '\t'; - break; - case 'u': /* transcode utf16 to utf8. */ - uc = parse_hex4(ptr + 1); - ptr += 4; /* get the unicode char. */ - - if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0) break; /* check for invalid. */ - - if (uc >= 0xD800 && uc <= 0xDBFF) /* UTF16 surrogate pairs. */ - { - if (ptr[1] != '\\' || ptr[2] != 'u') break; /* missing second-half of surrogate. */ - uc2 = parse_hex4(ptr + 3); - ptr += 6; - if (uc2 < 0xDC00 || uc2 > 0xDFFF) break; /* invalid second-half of surrogate. */ - uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF)); - } - - len = 4; - if (uc < 0x80) - len = 1; - else if (uc < 0x800) - len = 2; - else if (uc < 0x10000) - len = 3; - ptr2 += len; - - switch (len) { - case 4: - *--ptr2 = ((uc | 0x80) & 0xBF); - uc >>= 6; - // fall through - case 3: - *--ptr2 = ((uc | 0x80) & 0xBF); - uc >>= 6; - // fall through - case 2: - *--ptr2 = ((uc | 0x80) & 0xBF); - uc >>= 6; - // fall through - case 1: - *--ptr2 = ((unsigned char)uc | firstByteMark[len]); - } - ptr2 += len; - break; - default: - *ptr2++ = *ptr; - break; - } - ptr++; - } - } - *ptr2 = 0; - if (*ptr == '\"') ptr++; - item->valuestring = out; - item->type = cJSON_String; - return ptr; -} - -/* Render the cstring provided to an escaped version that can be printed. */ -static char *print_string_ptr(const char *str, printbuffer *p) { - const char *ptr; - char *ptr2; - char *out; - size_t len = 0, flag = 0; - unsigned char token; - - for (ptr = str; *ptr; ptr++) flag |= ((*ptr > 0 && *ptr < 32) || (*ptr == '\"') || (*ptr == '\\')) ? 1 : 0; - if (!flag) { - len = ptr - str; - if (p) - out = ensure(p, len + 3); - else - out = (char *)cJSON_malloc(len + 3); - if (!out) return 0; - ptr2 = out; - *ptr2++ = '\"'; - strcpy(ptr2, str); - ptr2[len] = '\"'; - ptr2[len + 1] = 0; - return out; - } - - if (!str) { - if (p) - out = ensure(p, 3); - else - out = (char *)cJSON_malloc(3); - if (!out) return 0; - strcpy(out, "\"\""); - return out; - } - ptr = str; - while ((token = *ptr) && ++len) { - if (strchr("\"\\\b\f\n\r\t", token)) - len++; - else if (token < 32) - len += 5; - ptr++; - } - - if (p) - out = ensure(p, len + 3); - else - out = (char *)cJSON_malloc(len + 3); - if (!out) return 0; - - ptr2 = out; - ptr = str; - *ptr2++ = '\"'; - while (*ptr) { - if ((unsigned char)*ptr > 31 && *ptr != '\"' && *ptr != '\\') - *ptr2++ = *ptr++; - else { - switch (token = *ptr++) { - case '\\': - *ptr2++ = '\\'; - break; - case '\"': - *ptr2++ = '\"'; - break; - case '\b': - *ptr2++ = '\b'; - break; - case '\f': - *ptr2++ = '\f'; - break; - case '\n': - *ptr2++ = '\n'; - break; - case '\r': - *ptr2++ = '\r'; - break; - case '\t': - *ptr2++ = '\t'; - break; - default: - sprintf(ptr2, "u%04x", token); - ptr2 += 5; - break; /* escape and print */ - } - } - } - *ptr2++ = '\"'; - *ptr2++ = 0; - return out; -} -/* Invote print_string_ptr (which is useful) on an item. */ -static char *print_string(cJSON *item, printbuffer *p) { return print_string_ptr(item->valuestring, p); } - -/* Predeclare these prototypes. */ -static const char *parse_value(cJSON *item, const char *value); -static char *print_value(cJSON *item, int depth, int fmt, printbuffer *p); -static const char *parse_array(cJSON *item, const char *value); -static char *print_array(cJSON *item, int depth, int fmt, printbuffer *p); -static const char *parse_object(cJSON *item, const char *value); -static char *print_object(cJSON *item, int depth, int fmt, printbuffer *p); - -/* Utility to jump whitespace and cr/lf */ -static const char *skip(const char *in) { - while (in && *in && (unsigned char)*in <= 32) in++; - return in; -} - -/* Parse an object - create a new root, and populate. */ -cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated) { - const char *end = 0; - cJSON *c = cJSON_New_Item(); - ep = 0; - if (!c) return 0; /* memory fail */ - - end = parse_value(c, skip(value)); - if (!end) { - cJSON_Delete(c); - return 0; - } /* parse failure. ep is set. */ - - /* if we require null-terminated JSON without appended garbage, skip and - * then check for a null terminator */ - if (require_null_terminated) { - end = skip(end); - if (*end) { - cJSON_Delete(c); - ep = end; - return 0; - } - } - if (return_parse_end) *return_parse_end = end; - return c; -} -/* Default options for cJSON_Parse */ -cJSON *cJSON_Parse(const char *value) { return cJSON_ParseWithOpts(value, 0, 0); } - -/* Render a cJSON item/entity/structure to text. */ -char *cJSON_Print(cJSON *item) { return print_value(item, 0, 1, 0); } -char *cJSON_PrintUnformatted(cJSON *item) { return print_value(item, 0, 0, 0); } - -char *cJSON_PrintBuffered(cJSON *item, int prebuffer, int fmt) { - printbuffer p; - p.buffer = (char *)cJSON_malloc(prebuffer); - p.length = prebuffer; - p.offset = 0; - return print_value(item, 0, fmt, &p); -} - -/* Parser core - when encountering text, process appropriately. */ -static const char *parse_value(cJSON *item, const char *value) { - if (!value) return 0; /* Fail on null. */ - if (!strncmp(value, "null", 4)) { - item->type = cJSON_NULL; - return value + 4; - } - if (!strncmp(value, "false", 5)) { - item->type = cJSON_False; - return value + 5; - } - if (!strncmp(value, "true", 4)) { - item->type = cJSON_True; - item->valueint = 1; - return value + 4; - } - if (*value == '\"') { - return parse_string(item, value); - } - if (*value == '-' || (*value >= '0' && *value <= '9')) { - return parse_number(item, value); - } - if (*value == '[') { - return parse_array(item, value); - } - if (*value == '{') { - return parse_object(item, value); - } - - ep = value; - return 0; /* failure. */ -} - -/* Render a value to text. */ -static char *print_value(cJSON *item, int depth, int fmt, printbuffer *p) { - char *out = 0; - if (!item) return 0; - if (p) { - switch ((item->type) & 255) { - case cJSON_NULL: { - out = ensure(p, 5); - if (out) strcpy(out, "null"); - break; - } - case cJSON_False: { - out = ensure(p, 6); - if (out) strcpy(out, "false"); - break; - } - case cJSON_True: { - out = ensure(p, 5); - if (out) strcpy(out, "true"); - break; - } - case cJSON_Number: - out = print_number(item, p); - break; - case cJSON_String: - out = print_string(item, p); - break; - case cJSON_Array: - out = print_array(item, depth, fmt, p); - break; - case cJSON_Object: - out = print_object(item, depth, fmt, p); - break; - } - } else { - switch ((item->type) & 255) { - case cJSON_NULL: - out = cJSON_strdup("null"); - break; - case cJSON_False: - out = cJSON_strdup("false"); - break; - case cJSON_True: - out = cJSON_strdup("true"); - break; - case cJSON_Number: - out = print_number(item, 0); - break; - case cJSON_String: - out = print_string(item, 0); - break; - case cJSON_Array: - out = print_array(item, depth, fmt, 0); - break; - case cJSON_Object: - out = print_object(item, depth, fmt, 0); - break; - } - } - return out; -} - -/* Build an array from input text. */ -static const char *parse_array(cJSON *item, const char *value) { - cJSON *child; - if (*value != '[') { - ep = value; - return 0; - } /* not an array! */ - - item->type = cJSON_Array; - value = skip(value + 1); - if (*value == ']') return value + 1; /* empty array. */ - - item->child = child = cJSON_New_Item(); - if (!item->child) return 0; /* memory fail */ - value = skip(parse_value(child, skip(value))); /* skip any spacing, get the value. */ - if (!value) return 0; - - while (*value == ',') { - cJSON *new_item; - if (!(new_item = cJSON_New_Item())) return 0; /* memory fail */ - child->next = new_item; - new_item->prev = child; - child = new_item; - value = skip(parse_value(child, skip(value + 1))); - if (!value) return 0; /* memory fail */ - } - - if (*value == ']') return value + 1; /* end of array */ - ep = value; - return 0; /* malformed. */ -} - -/* Render an array to text */ -static char *print_array(cJSON *item, int depth, int fmt, printbuffer *p) { - char **entries; - char *out = 0, *ptr, *ret; - size_t len = 5; - cJSON *child = item->child; - int numentries = 0, fail = 0, j = 0; - size_t tmplen = 0, i = 0; - - /* How many entries in the array? */ - while (child) numentries++, child = child->next; - /* Explicitly handle numentries==0 */ - if (!numentries) { - if (p) - out = ensure(p, 3); - else - out = (char *)cJSON_malloc(3); - if (out) strcpy(out, "[]"); - return out; - } - - if (p) { - /* Compose the output array. */ - i = p->offset; - ptr = ensure(p, 1); - if (!ptr) return 0; - *ptr = '['; - p->offset++; - child = item->child; - while (child && !fail) { - print_value(child, depth + 1, fmt, p); - p->offset = update(p); - if (child->next) { - len = fmt ? 2 : 1; - ptr = ensure(p, len + 1); - if (!ptr) return 0; - *ptr++ = ','; - if (fmt) *ptr++ = ' '; - *ptr = 0; - p->offset += len; - } - child = child->next; - } - ptr = ensure(p, 2); - if (!ptr) return 0; - *ptr++ = ']'; - *ptr = 0; - out = (p->buffer) + i; - } else { - /* Allocate an array to hold the values for each */ - entries = (char **)cJSON_malloc(numentries * sizeof(char *)); - if (!entries) return 0; - memset(entries, 0, numentries * sizeof(char *)); - /* Retrieve all the results: */ - child = item->child; - while (child && !fail) { - ret = print_value(child, depth + 1, fmt, 0); - entries[i++] = ret; - if (ret) - len += strlen(ret) + 2 + (fmt ? 1 : 0); - else - fail = 1; - child = child->next; - } - - /* If we didn't fail, try to malloc the output string */ - if (!fail) out = (char *)cJSON_malloc(len); - /* If that fails, we fail. */ - if (!out) fail = 1; - - /* Handle failure. */ - if (fail) { - for (j = 0; j < numentries; j++) - if (entries[j]) cJSON_free(entries[j]); - cJSON_free(entries); - return 0; - } - - /* Compose the output array. */ - *out = '['; - ptr = out + 1; - *ptr = 0; - for (j = 0; j < numentries; j++) { - tmplen = strlen(entries[j]); - memcpy(ptr, entries[j], tmplen); - ptr += tmplen; - if (j != numentries - 1) { - *ptr++ = ','; - if (fmt) *ptr++ = ' '; - *ptr = 0; - } - cJSON_free(entries[j]); - } - cJSON_free(entries); - *ptr++ = ']'; - *ptr++ = 0; - } - return out; -} - -/* Build an object from the text. */ -static const char *parse_object(cJSON *item, const char *value) { - cJSON *child; - if (*value != '{') { - ep = value; - return 0; - } /* not an object! */ - - item->type = cJSON_Object; - value = skip(value + 1); - if (*value == '}') return value + 1; /* empty array. */ - - item->child = child = cJSON_New_Item(); - if (!item->child) return 0; - value = skip(parse_string(child, skip(value))); - if (!value) return 0; - child->string = child->valuestring; - child->valuestring = 0; - if (*value != ':') { - ep = value; - return 0; - } /* fail! */ - value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */ - if (!value) return 0; - - while (*value == ',') { - cJSON *new_item; - if (!(new_item = cJSON_New_Item())) return 0; /* memory fail */ - child->next = new_item; - new_item->prev = child; - child = new_item; - value = skip(parse_string(child, skip(value + 1))); - if (!value) return 0; - child->string = child->valuestring; - child->valuestring = 0; - if (*value != ':') { - ep = value; - return 0; - } /* fail! */ - value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */ - if (!value) return 0; - } - - if (*value == '}') return value + 1; /* end of array */ - ep = value; - return 0; /* malformed. */ -} - -/* Render an object to text. */ -static char *print_object(cJSON *item, int depth, int fmt, printbuffer *p) { - char **entries = 0, **names = 0; - char *out = 0, *ptr, *ret, *str; - int j; - cJSON *child = item->child; - int numentries = 0, fail = 0, k; - size_t tmplen = 0, i = 0, len = 7; - /* Count the number of entries. */ - while (child) numentries++, child = child->next; - /* Explicitly handle empty object case */ - if (!numentries) { - if (p) - out = ensure(p, fmt ? depth + 4 : 3); - else - out = (char *)cJSON_malloc(fmt ? depth + 4 : 3); - if (!out) return 0; - ptr = out; - *ptr++ = '{'; - if (fmt) { - *ptr++ = '\n'; - for (j = 0; j < depth - 1; j++) *ptr++ = '\t'; - } - *ptr++ = '}'; - *ptr++ = 0; - return out; - } - if (p) { - /* Compose the output: */ - i = p->offset; - len = fmt ? 2 : 1; - ptr = ensure(p, len + 1); - if (!ptr) return 0; - *ptr++ = '{'; - if (fmt) *ptr++ = '\n'; - *ptr = 0; - p->offset += len; - child = item->child; - depth++; - while (child) { - if (fmt) { - ptr = ensure(p, depth); - if (!ptr) return 0; - for (j = 0; j < depth; j++) *ptr++ = '\t'; - p->offset += depth; - } - print_string_ptr(child->string, p); - p->offset = update(p); - - len = fmt ? 2 : 1; - ptr = ensure(p, len); - if (!ptr) return 0; - *ptr++ = ':'; - if (fmt) *ptr++ = '\t'; - p->offset += len; - - print_value(child, depth, fmt, p); - p->offset = update(p); - - len = (fmt ? 1 : 0) + (child->next ? 1 : 0); - ptr = ensure(p, len + 1); - if (!ptr) return 0; - if (child->next) *ptr++ = ','; - if (fmt) *ptr++ = '\n'; - *ptr = 0; - p->offset += len; - child = child->next; - } - ptr = ensure(p, fmt ? (depth + 1) : 2); - if (!ptr) return 0; - if (fmt) - for (j = 0; j < depth - 1; j++) *ptr++ = '\t'; - *ptr++ = '}'; - *ptr = 0; - out = (p->buffer) + i; - } else { - /* Allocate space for the names and the objects */ - entries = (char **)cJSON_malloc(numentries * sizeof(char *)); - if (!entries) return 0; - names = (char **)cJSON_malloc(numentries * sizeof(char *)); - if (!names) { - cJSON_free(entries); - return 0; - } - memset(entries, 0, sizeof(char *) * numentries); - memset(names, 0, sizeof(char *) * numentries); - - /* Collect all the results into our arrays: */ - child = item->child; - depth++; - if (fmt) len += depth; - while (child) { - names[i] = str = print_string_ptr(child->string, 0); - entries[i++] = ret = print_value(child, depth, fmt, 0); - if (str && ret) - len += strlen(ret) + strlen(str) + 2 + (fmt ? 2 + depth : 0); - else - fail = 1; - child = child->next; - } - - /* Try to allocate the output string */ - if (!fail) out = (char *)cJSON_malloc(len); - if (!out) fail = 1; - - /* Handle failure */ - if (fail) { - for (j = 0; j < numentries; j++) { - if (names[i]) cJSON_free(names[j]); - if (entries[j]) cJSON_free(entries[j]); - } - cJSON_free(names); - cJSON_free(entries); - return 0; - } - - /* Compose the output: */ - *out = '{'; - ptr = out + 1; - if (fmt) *ptr++ = '\n'; - *ptr = 0; - for (j = 0; j < numentries; j++) { - if (fmt) - for (k = 0; k < depth; k++) *ptr++ = '\t'; - tmplen = strlen(names[j]); - memcpy(ptr, names[j], tmplen); - ptr += tmplen; - *ptr++ = ':'; - if (fmt) *ptr++ = '\t'; - strcpy(ptr, entries[j]); - ptr += strlen(entries[j]); - if (j != numentries - 1) *ptr++ = ','; - if (fmt) *ptr++ = '\n'; - *ptr = 0; - cJSON_free(names[j]); - cJSON_free(entries[j]); - } - - cJSON_free(names); - cJSON_free(entries); - if (fmt) - for (j = 0; j < depth - 1; j++) *ptr++ = '\t'; - *ptr++ = '}'; - *ptr++ = 0; - } - return out; -} - -/* Get Array size/item / object item. */ -int cJSON_GetArraySize(cJSON *array) { - cJSON *c = array->child; - int i = 0; - while (c) i++, c = c->next; - return i; -} -cJSON *cJSON_GetArrayItem(cJSON *array, int item) { - cJSON *c = array->child; - while (c && item > 0) item--, c = c->next; - return c; -} -cJSON *cJSON_GetObjectItem(cJSON *object, const char *string) { - cJSON *c = object->child; - while (c && strcmp(c->string, string)) c = c->next; - return c; -} - -/* Utility for array list handling. */ -static void suffix_object(cJSON *prev, cJSON *item) { - prev->next = item; - item->prev = prev; -} -/* Utility for handling references. */ -static cJSON *create_reference(cJSON *item) { - cJSON *ref = cJSON_New_Item(); - if (!ref) return 0; - memcpy(ref, item, sizeof(cJSON)); - ref->string = 0; - ref->type |= cJSON_IsReference; - ref->next = ref->prev = 0; - return ref; -} - -/* Add item to array/object. */ -void cJSON_AddItemToArray(cJSON *array, cJSON *item) { - cJSON *c = array->child; - if (!item) return; - if (!c) { - array->child = item; - } else { - while (c && c->next) c = c->next; - suffix_object(c, item); - } -} -void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) { - if (!item) return; - if (item->string) cJSON_free(item->string); - item->string = cJSON_strdup(string); - cJSON_AddItemToArray(object, item); -} -void cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) { - if (!item) return; - if (!(item->type & cJSON_StringIsConst) && item->string) cJSON_free(item->string); - item->string = (char *)string; - item->type |= cJSON_StringIsConst; - cJSON_AddItemToArray(object, item); -} -void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) { cJSON_AddItemToArray(array, create_reference(item)); } -void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) { - cJSON_AddItemToObject(object, string, create_reference(item)); -} - -cJSON *cJSON_DetachItemFromArray(cJSON *array, int which) { - cJSON *c = array->child; - while (c && which > 0) c = c->next, which--; - if (!c) return 0; - if (c->prev) c->prev->next = c->next; - if (c->next) c->next->prev = c->prev; - if (c == array->child) array->child = c->next; - c->prev = c->next = 0; - return c; -} -void cJSON_DeleteItemFromArray(cJSON *array, int which) { cJSON_Delete(cJSON_DetachItemFromArray(array, which)); } -cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string) { - int i = 0; - cJSON *c = object->child; - while (c && strcmp(c->string, string)) i++, c = c->next; - if (c) return cJSON_DetachItemFromArray(object, i); - return 0; -} -void cJSON_DeleteItemFromObject(cJSON *object, const char *string) { cJSON_Delete(cJSON_DetachItemFromObject(object, string)); } - -/* Replace array/object items with new ones. */ -void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) { - cJSON *c = array->child; - while (c && which > 0) c = c->next, which--; - if (!c) { - cJSON_AddItemToArray(array, newitem); - return; - } - newitem->next = c; - newitem->prev = c->prev; - c->prev = newitem; - if (c == array->child) - array->child = newitem; - else - newitem->prev->next = newitem; -} -void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) { - cJSON *c = array->child; - while (c && which > 0) c = c->next, which--; - if (!c) return; - newitem->next = c->next; - newitem->prev = c->prev; - if (newitem->next) newitem->next->prev = newitem; - if (c == array->child) - array->child = newitem; - else - newitem->prev->next = newitem; - c->next = c->prev = 0; - cJSON_Delete(c); -} -void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) { - int i = 0; - cJSON *c = object->child; - while (c && strcmp(c->string, string)) i++, c = c->next; - if (c) { - newitem->string = cJSON_strdup(string); - cJSON_ReplaceItemInArray(object, i, newitem); - } -} - -/* Create basic types: */ -cJSON *cJSON_CreateNull(void) { - cJSON *item = cJSON_New_Item(); - if (item) item->type = cJSON_NULL; - return item; -} -cJSON *cJSON_CreateTrue(void) { - cJSON *item = cJSON_New_Item(); - if (item) item->type = cJSON_True; - return item; -} -cJSON *cJSON_CreateFalse(void) { - cJSON *item = cJSON_New_Item(); - if (item) item->type = cJSON_False; - return item; -} -cJSON *cJSON_CreateBool(int b) { - cJSON *item = cJSON_New_Item(); - if (item) item->type = b ? cJSON_True : cJSON_False; - return item; -} -cJSON *cJSON_CreateNumber(double num) { - cJSON *item = cJSON_New_Item(); - if (item) { - item->type = cJSON_Number; - item->valuedouble = num; - item->valueint = (int)num; - } - return item; -} -cJSON *cJSON_CreateString(const char *string) { - cJSON *item = cJSON_New_Item(); - if (item) { - item->type = cJSON_String; - item->valuestring = cJSON_strdup(string); - } - return item; -} -cJSON *cJSON_CreateArray(void) { - cJSON *item = cJSON_New_Item(); - if (item) item->type = cJSON_Array; - return item; -} -cJSON *cJSON_CreateObject(void) { - cJSON *item = cJSON_New_Item(); - if (item) item->type = cJSON_Object; - return item; -} - -/* Create Arrays: */ -cJSON *cJSON_CreateIntArray(const int *numbers, int count) { - int i; - cJSON *n = 0, *p = 0, *a = cJSON_CreateArray(); - for (i = 0; a && i < count; i++) { - n = cJSON_CreateNumber(numbers[i]); - if (!i) - a->child = n; - else - suffix_object(p, n); - p = n; - } - return a; -} -cJSON *cJSON_CreateFloatArray(const float *numbers, int count) { - int i; - cJSON *n = 0, *p = 0, *a = cJSON_CreateArray(); - for (i = 0; a && i < count; i++) { - n = cJSON_CreateNumber(numbers[i]); - if (!i) - a->child = n; - else - suffix_object(p, n); - p = n; - } - return a; -} -cJSON *cJSON_CreateDoubleArray(const double *numbers, int count) { - int i; - cJSON *n = 0, *p = 0, *a = cJSON_CreateArray(); - for (i = 0; a && i < count; i++) { - n = cJSON_CreateNumber(numbers[i]); - if (!i) - a->child = n; - else - suffix_object(p, n); - p = n; - } - return a; -} -cJSON *cJSON_CreateStringArray(const char **strings, int count) { - int i; - cJSON *n = 0, *p = 0, *a = cJSON_CreateArray(); - for (i = 0; a && i < count; i++) { - n = cJSON_CreateString(strings[i]); - if (!i) - a->child = n; - else - suffix_object(p, n); - p = n; - } - return a; -} - -/* Duplication */ -cJSON *cJSON_Duplicate(cJSON *item, int recurse) { - cJSON *newitem, *cptr, *nptr = 0, *newchild; - /* Bail on bad ptr */ - if (!item) return 0; - /* Create new item */ - newitem = cJSON_New_Item(); - if (!newitem) return 0; - /* Copy over all vars */ - newitem->type = item->type & (~cJSON_IsReference), newitem->valueint = item->valueint, newitem->valuedouble = item->valuedouble; - if (item->valuestring) { - newitem->valuestring = cJSON_strdup(item->valuestring); - if (!newitem->valuestring) { - cJSON_Delete(newitem); - return 0; - } - } - if (item->string) { - newitem->string = cJSON_strdup(item->string); - if (!newitem->string) { - cJSON_Delete(newitem); - return 0; - } - } - /* If non-recursive, then we're done! */ - if (!recurse) return newitem; - /* Walk the ->next chain for the child. */ - cptr = item->child; - while (cptr) { - newchild = cJSON_Duplicate(cptr, 1); /* Duplicate (with recurse) each item in the ->next chain */ - if (!newchild) { - cJSON_Delete(newitem); - return 0; - } - if (nptr) { - nptr->next = newchild, newchild->prev = nptr; - nptr = newchild; - } /* If newitem->child already set, then crosswire ->prev and ->next and - move on */ - else { - newitem->child = newchild; - nptr = newchild; - } /* Set newitem->child and move to it */ - cptr = cptr->next; - } - return newitem; -} - -void cJSON_Minify(char *json) { - char *into = json; - while (*json) { - if (*json == ' ') - json++; - else if (*json == '\t') - json++; /* Whitespace characters. */ - else if (*json == '\r') - json++; - else if (*json == '\n') - json++; - else if (*json == '/' && json[1] == '/') - while (*json && *json != '\n') json++; /* double-slash comments, to end of line. */ - else if (*json == '/' && json[1] == '*') { - while (*json && !(*json == '*' && json[1] == '/')) json++; - json += 2; - } /* multiline comments. */ - else if (*json == '\"') { - *into++ = *json++; - while (*json && *json != '\"') { - if (*json == '\\') *into++ = *json++; - *into++ = *json++; - } - *into++ = *json++; - } /* string literals, which are \" sensitive. */ - else - *into++ = *json++; /* All other characters. */ - } - *into = 0; /* and null-terminate. */ -} diff --git a/loader/cJSON.h b/loader/cJSON.h deleted file mode 100644 index f0059abd..00000000 --- a/loader/cJSON.h +++ /dev/null @@ -1,174 +0,0 @@ -/* - Copyright (c) 2009 Dave Gamble - Copyright (c) 2015-2016 The Khronos Group Inc. - Copyright (c) 2015-2016 Valve Corporation - Copyright (c) 2015-2016 LunarG, Inc. - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ - -#ifndef cJSON__h -#define cJSON__h - -#ifdef __cplusplus -extern "C" { -#endif - -/* cJSON Types: */ -#define cJSON_False 0 -#define cJSON_True 1 -#define cJSON_NULL 2 -#define cJSON_Number 3 -#define cJSON_String 4 -#define cJSON_Array 5 -#define cJSON_Object 6 - -#define cJSON_IsReference 256 -#define cJSON_StringIsConst 512 - -/* The cJSON structure: */ -typedef struct cJSON { - struct cJSON *next, *prev; /* next/prev allow you to walk array/object - chains. Alternatively, use - GetArraySize/GetArrayItem/GetObjectItem */ - struct cJSON *child; /* An array or object item will have a child pointer - pointing to a chain of the items in the - array/object. */ - - int type; /* The type of the item, as above. */ - - char *valuestring; /* The item's string, if type==cJSON_String */ - int valueint; /* The item's number, if type==cJSON_Number */ - double valuedouble; /* The item's number, if type==cJSON_Number */ - - char *string; /* The item's name string, if this item is the child of, or is - in the list of subitems of an object. */ -} cJSON; - -typedef struct cJSON_Hooks { - void *(*malloc_fn)(size_t sz); - void (*free_fn)(void *ptr); -} cJSON_Hooks; - -/* Supply malloc, realloc and free functions to cJSON */ -extern void cJSON_InitHooks(cJSON_Hooks *hooks); - -/* Supply a block of JSON, and this returns a cJSON object you can interrogate. - * Call cJSON_Delete when finished. */ -extern cJSON *cJSON_Parse(const char *value); -/* Render a cJSON entity to text for transfer/storage. Free the char* when - * finished. */ -extern char *cJSON_Print(cJSON *item); -/* Render a cJSON entity to text for transfer/storage without any formatting. - * Free the char* when finished. */ -extern char *cJSON_PrintUnformatted(cJSON *item); -/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess - * at the final size. guessing well reduces reallocation. fmt=0 gives - * unformatted, =1 gives formatted */ -extern char *cJSON_PrintBuffered(cJSON *item, int prebuffer, int fmt); -/* Delete a cJSON entity and all subentities. */ -extern void cJSON_Delete(cJSON *c); -/* Delete an item allocated inside the JSON parser*/ -extern void cJSON_Free(void *p); - -/* Returns the number of items in an array (or object). */ -extern int cJSON_GetArraySize(cJSON *array); -/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. - */ -extern cJSON *cJSON_GetArrayItem(cJSON *array, int item); -/* Get item "string" from object. Case insensitive. */ -extern cJSON *cJSON_GetObjectItem(cJSON *object, const char *string); - -/* For analysing failed parses. This returns a pointer to the parse error. - * You'll probably need to look a few chars back to make sense of it. Defined - * when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ -extern const char *cJSON_GetErrorPtr(void); - -/* These calls create a cJSON item of the appropriate type. */ -extern cJSON *cJSON_CreateNull(void); -extern cJSON *cJSON_CreateTrue(void); -extern cJSON *cJSON_CreateFalse(void); -extern cJSON *cJSON_CreateBool(int b); -extern cJSON *cJSON_CreateNumber(double num); -extern cJSON *cJSON_CreateString(const char *string); -extern cJSON *cJSON_CreateArray(void); -extern cJSON *cJSON_CreateObject(void); - -/* These utilities create an Array of count items. */ -extern cJSON *cJSON_CreateIntArray(const int *numbers, int count); -extern cJSON *cJSON_CreateFloatArray(const float *numbers, int count); -extern cJSON *cJSON_CreateDoubleArray(const double *numbers, int count); -extern cJSON *cJSON_CreateStringArray(const char **strings, int count); - -/* Append item to the specified array/object. */ -extern void cJSON_AddItemToArray(cJSON *array, cJSON *item); -extern void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); -extern void cJSON_AddItemToObjectCS(cJSON *object, const char *string, - cJSON *item); /* Use this when string is definitely const (i.e. a literal, - or as good as), and will definitely survive the cJSON - object */ -/* Append reference to item to the specified array/object. Use this when you - * want to add an existing cJSON to a new cJSON, but don't want to corrupt your - * existing cJSON. */ -extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); -extern void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); - -/* Remove/Detatch items from Arrays/Objects. */ -extern cJSON *cJSON_DetachItemFromArray(cJSON *array, int which); -extern void cJSON_DeleteItemFromArray(cJSON *array, int which); -extern cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string); -extern void cJSON_DeleteItemFromObject(cJSON *object, const char *string); - -/* Update array items. */ -extern void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ -extern void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); -extern void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem); - -/* Duplicate a cJSON item */ -extern cJSON *cJSON_Duplicate(cJSON *item, int recurse); -/* Duplicate will create a new, identical cJSON item to the one you pass, in new -memory that will -need to be released. With recurse!=0, it will duplicate any children connected -to the item. -The item->next and ->prev pointers are always zero on return from Duplicate. */ - -/* ParseWithOpts allows you to require (and check) that the JSON is null - * terminated, and to retrieve the pointer to the final byte parsed. */ -extern cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated); - -extern void cJSON_Minify(char *json); - -/* Macros for creating things quickly. */ -#define cJSON_AddNullToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateNull()) -#define cJSON_AddTrueToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue()) -#define cJSON_AddFalseToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse()) -#define cJSON_AddBoolToObject(object, name, b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b)) -#define cJSON_AddNumberToObject(object, name, n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n)) -#define cJSON_AddStringToObject(object, name, s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s)) - -/* When assigning an integer value, it needs to be propagated to valuedouble - * too. */ -#define cJSON_SetIntValue(object, val) ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val)) -#define cJSON_SetNumberValue(object, val) ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val)) - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/loader/debug_utils.c b/loader/debug_utils.c deleted file mode 100644 index 988dd3cb..00000000 --- a/loader/debug_utils.c +++ /dev/null @@ -1,1001 +0,0 @@ -/* - * Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * Copyright (C) 2015-2016 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: Courtney Goeltzenleuchter - * Author: Jon Ashburn - * Author: Mark Young - * - */ - -#define _GNU_SOURCE -#include -#include -#include -#include -#ifndef WIN32 -#include -#else -#endif -#include "vk_loader_platform.h" -#include "debug_utils.h" -#include "vulkan/vk_layer.h" -#include "vk_object_types.h" - -// VK_EXT_debug_report related items - -VkResult util_CreateDebugUtilsMessenger(struct loader_instance *inst, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT messenger) { - VkLayerDbgFunctionNode *pNewDbgFuncNode = NULL; - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode), - sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } else { -#endif - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode), - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } - if (!pNewDbgFuncNode) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode)); - - pNewDbgFuncNode->is_messenger = true; - pNewDbgFuncNode->messenger.messenger = messenger; - pNewDbgFuncNode->messenger.pfnUserCallback = pCreateInfo->pfnUserCallback; - pNewDbgFuncNode->messenger.messageSeverity = pCreateInfo->messageSeverity; - pNewDbgFuncNode->messenger.messageType = pCreateInfo->messageType; - pNewDbgFuncNode->pUserData = pCreateInfo->pUserData; - pNewDbgFuncNode->pNext = inst->DbgFunctionHead; - inst->DbgFunctionHead = pNewDbgFuncNode; - - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL -debug_utils_CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) { - struct loader_instance *inst = loader_get_instance(instance); - loader_platform_thread_lock_mutex(&loader_lock); - VkResult result = inst->disp->layer_inst_disp.CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); - loader_platform_thread_unlock_mutex(&loader_lock); - return result; -} - -VkBool32 util_SubmitDebugUtilsMessageEXT(const struct loader_instance *inst, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) { - VkBool32 bail = false; - - if (NULL != pCallbackData && NULL != pCallbackData->pObjects && 0 < pCallbackData->objectCount) { - VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead; - VkDebugReportObjectTypeEXT object_type; - VkDebugReportFlagsEXT object_flags = 0; - uint64_t object_handle; - - debug_utils_AnnotFlagsToReportFlags(messageSeverity, messageTypes, &object_flags); - debug_utils_AnnotObjectToDebugReportObject(pCallbackData->pObjects, &object_type, &object_handle); - - while (pTrav) { - if (pTrav->is_messenger && (pTrav->messenger.messageSeverity & messageSeverity) && - (pTrav->messenger.messageType & messageTypes)) { - if (pTrav->messenger.pfnUserCallback(messageSeverity, messageTypes, pCallbackData, pTrav->pUserData)) { - bail = true; - } - } - if (!pTrav->is_messenger && pTrav->report.msgFlags & object_flags) { - if (pTrav->report.pfnMsgCallback(object_flags, object_type, object_handle, 0, pCallbackData->messageIdNumber, - pCallbackData->pMessageIdName, pCallbackData->pMessage, pTrav->pUserData)) { - bail = true; - } - } - - pTrav = pTrav->pNext; - } - } - - return bail; -} - -void util_DestroyDebugUtilsMessenger(struct loader_instance *inst, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead; - VkLayerDbgFunctionNode *pPrev = pTrav; - - while (pTrav) { - if (pTrav->is_messenger && pTrav->messenger.messenger == messenger) { - pPrev->pNext = pTrav->pNext; - if (inst->DbgFunctionHead == pTrav) inst->DbgFunctionHead = pTrav->pNext; -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pAllocator->pfnFree(pAllocator->pUserData, pTrav); - } else { -#endif - loader_instance_heap_free(inst, pTrav); - } - break; - } - pPrev = pTrav; - pTrav = pTrav->pNext; - } -} - -// This utility (used by vkInstanceCreateInfo(), looks at a pNext chain. It -// counts any VkDebugUtilsMessengerCreateInfoEXT structs that it finds. It -// then allocates array that can hold that many structs, as well as that many -// VkDebugUtilsMessengerEXT handles. It then copies each -// VkDebugUtilsMessengerCreateInfoEXT, and initializes each handle. -VkResult util_CopyDebugUtilsMessengerCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, - uint32_t *num_messengers, VkDebugUtilsMessengerCreateInfoEXT **infos, - VkDebugUtilsMessengerEXT **messengers) { - uint32_t n = *num_messengers = 0; - VkDebugUtilsMessengerCreateInfoEXT *pInfos = NULL; - VkDebugUtilsMessengerEXT *pMessengers = NULL; - - const void *pNext = pChain; - while (pNext) { - // 1st, count the number VkDebugUtilsMessengerCreateInfoEXT: - if (((VkDebugUtilsMessengerCreateInfoEXT *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT) { - n++; - } - pNext = (void *)((VkDebugUtilsMessengerCreateInfoEXT *)pNext)->pNext; - } - if (n == 0) { - return VK_SUCCESS; - } - -// 2nd, allocate memory for each VkDebugUtilsMessengerCreateInfoEXT: -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pInfos = *infos = ((VkDebugUtilsMessengerCreateInfoEXT *)pAllocator->pfnAllocation( - pAllocator->pUserData, n * sizeof(VkDebugUtilsMessengerCreateInfoEXT), sizeof(void *), - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)); - } else { -#endif - pInfos = *infos = ((VkDebugUtilsMessengerCreateInfoEXT *)malloc(n * sizeof(VkDebugUtilsMessengerCreateInfoEXT))); - } - if (!pInfos) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } -// 3rd, allocate memory for a unique handle for each callback: -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pMessengers = *messengers = ((VkDebugUtilsMessengerEXT *)pAllocator->pfnAllocation( - pAllocator->pUserData, n * sizeof(VkDebugUtilsMessengerEXT), sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)); - if (NULL == pMessengers) { - pAllocator->pfnFree(pAllocator->pUserData, pInfos); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - } else { -#endif - pMessengers = *messengers = ((VkDebugUtilsMessengerEXT *)malloc(n * sizeof(VkDebugUtilsMessengerEXT))); - if (NULL == pMessengers) { - free(pInfos); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - } - // 4th, copy each VkDebugUtilsMessengerCreateInfoEXT for use by - // vkDestroyInstance, and assign a unique handle to each messenger (just - // use the address of the copied VkDebugUtilsMessengerCreateInfoEXT): - pNext = pChain; - while (pNext) { - if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT) { - memcpy(pInfos, pNext, sizeof(VkDebugUtilsMessengerCreateInfoEXT)); - *pMessengers++ = (VkDebugUtilsMessengerEXT)(uintptr_t)pInfos++; - } - pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext; - } - - *num_messengers = n; - return VK_SUCCESS; -} - -void util_FreeDebugUtilsMessengerCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerCreateInfoEXT *infos, - VkDebugUtilsMessengerEXT *messengers) { -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pAllocator->pfnFree(pAllocator->pUserData, infos); - pAllocator->pfnFree(pAllocator->pUserData, messengers); - } else { -#endif - free(infos); - free(messengers); - } -} - -VkResult util_CreateDebugUtilsMessengers(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, - uint32_t num_messengers, VkDebugUtilsMessengerCreateInfoEXT *infos, - VkDebugUtilsMessengerEXT *messengers) { - VkResult rtn = VK_SUCCESS; - for (uint32_t i = 0; i < num_messengers; i++) { - rtn = util_CreateDebugUtilsMessenger(inst, &infos[i], pAllocator, messengers[i]); - if (rtn != VK_SUCCESS) { - for (uint32_t j = 0; j < i; j++) { - util_DestroyDebugUtilsMessenger(inst, messengers[j], pAllocator); - } - return rtn; - } - } - return rtn; -} - -void util_DestroyDebugUtilsMessengers(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, - uint32_t num_messengers, VkDebugUtilsMessengerEXT *messengers) { - for (uint32_t i = 0; i < num_messengers; i++) { - util_DestroyDebugUtilsMessenger(inst, messengers[i], pAllocator); - } -} - -static VKAPI_ATTR void VKAPI_CALL debug_utils_SubmitDebugUtilsMessageEXT( - VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) { - struct loader_instance *inst = loader_get_instance(instance); - - inst->disp->layer_inst_disp.SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); -} - -static VKAPI_ATTR void VKAPI_CALL debug_utils_DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - struct loader_instance *inst = loader_get_instance(instance); - loader_platform_thread_lock_mutex(&loader_lock); - - inst->disp->layer_inst_disp.DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); - - util_DestroyDebugUtilsMessenger(inst, messenger, pAllocator); - - loader_platform_thread_unlock_mutex(&loader_lock); -} - -// This is the instance chain terminator function for CreateDebugUtilsMessenger -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger) { - VkDebugUtilsMessengerEXT *icd_info = NULL; - const struct loader_icd_term *icd_term; - struct loader_instance *inst = (struct loader_instance *)instance; - VkResult res = VK_SUCCESS; - uint32_t storage_idx; - VkLayerDbgFunctionNode *pNewDbgFuncNode = NULL; - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - icd_info = ((VkDebugUtilsMessengerEXT *)pAllocator->pfnAllocation(pAllocator->pUserData, - inst->total_icd_count * sizeof(VkDebugUtilsMessengerEXT), - sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)); - if (icd_info) { - memset(icd_info, 0, inst->total_icd_count * sizeof(VkDebugUtilsMessengerEXT)); - } - } else { -#endif - icd_info = calloc(sizeof(VkDebugUtilsMessengerEXT), inst->total_icd_count); - } - if (!icd_info) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - storage_idx = 0; - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (!icd_term->dispatch.CreateDebugUtilsMessengerEXT) { - continue; - } - - res = icd_term->dispatch.CreateDebugUtilsMessengerEXT(icd_term->instance, pCreateInfo, pAllocator, &icd_info[storage_idx]); - - if (res != VK_SUCCESS) { - goto out; - } - storage_idx++; - } - -// Setup the debug report callback in the terminator since a layer may want -// to grab the information itself (RenderDoc) and then return back to the -// user callback a sub-set of the messages. -#if (DEBUG_DISABLE_APP_ALLOCATORS == 0) - if (pAllocator != NULL) { - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode), - sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } else { -#else - { -#endif - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode), - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } - if (!pNewDbgFuncNode) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode)); - - pNewDbgFuncNode->is_messenger = true; - pNewDbgFuncNode->messenger.pfnUserCallback = pCreateInfo->pfnUserCallback; - pNewDbgFuncNode->messenger.messageSeverity = pCreateInfo->messageSeverity; - pNewDbgFuncNode->messenger.messageType = pCreateInfo->messageType; - pNewDbgFuncNode->pUserData = pCreateInfo->pUserData; - pNewDbgFuncNode->pNext = inst->DbgFunctionHead; - inst->DbgFunctionHead = pNewDbgFuncNode; - - *(VkDebugUtilsMessengerEXT **)pMessenger = icd_info; - pNewDbgFuncNode->messenger.messenger = *pMessenger; - -out: - - // Roll back on errors - if (VK_SUCCESS != res) { - storage_idx = 0; - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (NULL == icd_term->dispatch.DestroyDebugUtilsMessengerEXT) { - continue; - } - - if (icd_info && icd_info[storage_idx]) { - icd_term->dispatch.DestroyDebugUtilsMessengerEXT(icd_term->instance, icd_info[storage_idx], pAllocator); - } - storage_idx++; - } - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - if (NULL != pNewDbgFuncNode) { - pAllocator->pfnFree(pAllocator->pUserData, pNewDbgFuncNode); - } - if (NULL != icd_info) { - pAllocator->pfnFree(pAllocator->pUserData, icd_info); - } - } else { -#endif - if (NULL != pNewDbgFuncNode) { - free(pNewDbgFuncNode); - } - if (NULL != icd_info) { - free(icd_info); - } - } - } - - return res; -} - -// This is the instance chain terminator function for DestroyDebugUtilsMessenger -VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator) { - uint32_t storage_idx; - VkDebugUtilsMessengerEXT *icd_info; - const struct loader_icd_term *icd_term; - - struct loader_instance *inst = (struct loader_instance *)instance; - icd_info = *(VkDebugUtilsMessengerEXT **)&messenger; - storage_idx = 0; - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (NULL == icd_term->dispatch.DestroyDebugUtilsMessengerEXT) { - continue; - } - - if (icd_info[storage_idx]) { - icd_term->dispatch.DestroyDebugUtilsMessengerEXT(icd_term->instance, icd_info[storage_idx], pAllocator); - } - storage_idx++; - } - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pAllocator->pfnFree(pAllocator->pUserData, icd_info); - } else { -#endif - free(icd_info); - } -} - -// This is the instance chain terminator function for SubmitDebugUtilsMessageEXT -VKAPI_ATTR void VKAPI_CALL terminator_SubmitDebugUtilsMessageEXT(VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) { - const struct loader_icd_term *icd_term; - - struct loader_instance *inst = (struct loader_instance *)instance; - - loader_platform_thread_lock_mutex(&loader_lock); - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (icd_term->dispatch.SubmitDebugUtilsMessageEXT != NULL) { - icd_term->dispatch.SubmitDebugUtilsMessageEXT(icd_term->instance, messageSeverity, messageTypes, pCallbackData); - } - } - - // Now that all ICDs have seen the message, call the necessary callbacks. Ignoring "bail" return value - // as there is nothing to bail from at this point. - - util_SubmitDebugUtilsMessageEXT(inst, messageSeverity, messageTypes, pCallbackData); - - loader_platform_thread_unlock_mutex(&loader_lock); -} - -// VK_EXT_debug_report related items - -VkResult util_CreateDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT callback) { - VkLayerDbgFunctionNode *pNewDbgFuncNode = NULL; - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode), - sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } else { -#endif - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode), - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } - if (!pNewDbgFuncNode) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode)); - - pNewDbgFuncNode->is_messenger = false; - pNewDbgFuncNode->report.msgCallback = callback; - pNewDbgFuncNode->report.pfnMsgCallback = pCreateInfo->pfnCallback; - pNewDbgFuncNode->report.msgFlags = pCreateInfo->flags; - pNewDbgFuncNode->pUserData = pCreateInfo->pUserData; - pNewDbgFuncNode->pNext = inst->DbgFunctionHead; - inst->DbgFunctionHead = pNewDbgFuncNode; - - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL -debug_utils_CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) { - struct loader_instance *inst = loader_get_instance(instance); - loader_platform_thread_lock_mutex(&loader_lock); - VkResult result = inst->disp->layer_inst_disp.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); - loader_platform_thread_unlock_mutex(&loader_lock); - return result; -} - -// Utility function to handle reporting -VkBool32 util_DebugReportMessage(const struct loader_instance *inst, VkFlags msgFlags, VkDebugReportObjectTypeEXT objectType, - uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { - VkBool32 bail = false; - VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead; - VkDebugUtilsMessageSeverityFlagBitsEXT severity; - VkDebugUtilsMessageTypeFlagsEXT types; - VkDebugUtilsMessengerCallbackDataEXT callback_data; - VkDebugUtilsObjectNameInfoEXT object_name; - - debug_utils_ReportFlagsToAnnotFlags(msgFlags, false, &severity, &types); - debug_utils_ReportObjectToAnnotObject(objectType, srcObject, &object_name); - - callback_data.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; - callback_data.pNext = NULL; - callback_data.flags = 0; - callback_data.pMessageIdName = pLayerPrefix; - callback_data.messageIdNumber = msgCode; - callback_data.pMessage = pMsg; - callback_data.cmdBufLabelCount = 0; - callback_data.pCmdBufLabels = NULL; - callback_data.queueLabelCount = 0; - callback_data.pQueueLabels = NULL; - callback_data.objectCount = 1; - callback_data.pObjects = &object_name; - - while (pTrav) { - if (!pTrav->is_messenger && pTrav->report.msgFlags & msgFlags) { - if (pTrav->report.pfnMsgCallback(msgFlags, objectType, srcObject, location, msgCode, pLayerPrefix, pMsg, - pTrav->pUserData)) { - bail = true; - } - } - if (pTrav->is_messenger && (pTrav->messenger.messageSeverity & severity) && (pTrav->messenger.messageType & types)) { - if (pTrav->messenger.pfnUserCallback(severity, types, &callback_data, pTrav->pUserData)) { - bail = true; - } - } - - pTrav = pTrav->pNext; - } - - return bail; -} - -void util_DestroyDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks *pAllocator) { - VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead; - VkLayerDbgFunctionNode *pPrev = pTrav; - - while (pTrav) { - if (!pTrav->is_messenger && pTrav->report.msgCallback == callback) { - pPrev->pNext = pTrav->pNext; - if (inst->DbgFunctionHead == pTrav) inst->DbgFunctionHead = pTrav->pNext; -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pAllocator->pfnFree(pAllocator->pUserData, pTrav); - } else { -#endif - loader_instance_heap_free(inst, pTrav); - } - break; - } - pPrev = pTrav; - pTrav = pTrav->pNext; - } -} - -// This utility (used by vkInstanceCreateInfo(), looks at a pNext chain. It -// counts any VkDebugReportCallbackCreateInfoEXT structs that it finds. It -// then allocates array that can hold that many structs, as well as that many -// VkDebugReportCallbackEXT handles. It then copies each -// VkDebugReportCallbackCreateInfoEXT, and initializes each handle. -VkResult util_CopyDebugReportCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, uint32_t *num_callbacks, - VkDebugReportCallbackCreateInfoEXT **infos, VkDebugReportCallbackEXT **callbacks) { - uint32_t n = *num_callbacks = 0; - VkDebugReportCallbackCreateInfoEXT *pInfos = NULL; - VkDebugReportCallbackEXT *pCallbacks = NULL; - - const void *pNext = pChain; - while (pNext) { - // 1st, count the number VkDebugReportCallbackCreateInfoEXT: - if (((VkDebugReportCallbackCreateInfoEXT *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) { - n++; - } - pNext = (void *)((VkDebugReportCallbackCreateInfoEXT *)pNext)->pNext; - } - if (n == 0) { - return VK_SUCCESS; - } - -// 2nd, allocate memory for each VkDebugReportCallbackCreateInfoEXT: -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)pAllocator->pfnAllocation( - pAllocator->pUserData, n * sizeof(VkDebugReportCallbackCreateInfoEXT), sizeof(void *), - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)); - } else { -#endif - pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)malloc(n * sizeof(VkDebugReportCallbackCreateInfoEXT))); - } - if (!pInfos) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } -// 3rd, allocate memory for a unique handle for each callback: -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation( - pAllocator->pUserData, n * sizeof(VkDebugReportCallbackEXT), sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)); - if (!pCallbacks) { - pAllocator->pfnFree(pAllocator->pUserData, pInfos); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - } else { -#endif - pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)malloc(n * sizeof(VkDebugReportCallbackEXT))); - if (!pCallbacks) { - free(pInfos); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - } - // 4th, copy each VkDebugReportCallbackCreateInfoEXT for use by - // vkDestroyInstance, and assign a unique handle to each callback (just - // use the address of the copied VkDebugReportCallbackCreateInfoEXT): - pNext = pChain; - while (pNext) { - if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) { - memcpy(pInfos, pNext, sizeof(VkDebugReportCallbackCreateInfoEXT)); - *pCallbacks++ = (VkDebugReportCallbackEXT)(uintptr_t)pInfos++; - } - pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext; - } - - *num_callbacks = n; - return VK_SUCCESS; -} - -void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackCreateInfoEXT *infos, - VkDebugReportCallbackEXT *callbacks) { -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pAllocator->pfnFree(pAllocator->pUserData, infos); - pAllocator->pfnFree(pAllocator->pUserData, callbacks); - } else { -#endif - free(infos); - free(callbacks); - } -} - -VkResult util_CreateDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, - uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos, - VkDebugReportCallbackEXT *callbacks) { - VkResult rtn = VK_SUCCESS; - for (uint32_t i = 0; i < num_callbacks; i++) { - rtn = util_CreateDebugReportCallback(inst, &infos[i], pAllocator, callbacks[i]); - if (rtn != VK_SUCCESS) { - for (uint32_t j = 0; j < i; j++) { - util_DestroyDebugReportCallback(inst, callbacks[j], pAllocator); - } - return rtn; - } - } - return rtn; -} - -void util_DestroyDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, uint32_t num_callbacks, - VkDebugReportCallbackEXT *callbacks) { - for (uint32_t i = 0; i < num_callbacks; i++) { - util_DestroyDebugReportCallback(inst, callbacks[i], pAllocator); - } -} - -static VKAPI_ATTR void VKAPI_CALL debug_utils_DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks *pAllocator) { - struct loader_instance *inst = loader_get_instance(instance); - loader_platform_thread_lock_mutex(&loader_lock); - - inst->disp->layer_inst_disp.DestroyDebugReportCallbackEXT(instance, callback, pAllocator); - - util_DestroyDebugReportCallback(inst, callback, pAllocator); - - loader_platform_thread_unlock_mutex(&loader_lock); -} - -static VKAPI_ATTR void VKAPI_CALL debug_utils_DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objType, uint64_t object, - size_t location, int32_t msgCode, const char *pLayerPrefix, - const char *pMsg) { - struct loader_instance *inst = loader_get_instance(instance); - - inst->disp->layer_inst_disp.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); -} - -// This is the instance chain terminator function -// for CreateDebugReportCallback -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pCallback) { - VkDebugReportCallbackEXT *icd_info = NULL; - const struct loader_icd_term *icd_term; - struct loader_instance *inst = (struct loader_instance *)instance; - VkResult res = VK_SUCCESS; - uint32_t storage_idx; - VkLayerDbgFunctionNode *pNewDbgFuncNode = NULL; - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - icd_info = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(pAllocator->pUserData, - inst->total_icd_count * sizeof(VkDebugReportCallbackEXT), - sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)); - if (icd_info) { - memset(icd_info, 0, inst->total_icd_count * sizeof(VkDebugReportCallbackEXT)); - } - } else { -#endif - icd_info = calloc(sizeof(VkDebugReportCallbackEXT), inst->total_icd_count); - } - if (!icd_info) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - storage_idx = 0; - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (!icd_term->dispatch.CreateDebugReportCallbackEXT) { - continue; - } - - res = icd_term->dispatch.CreateDebugReportCallbackEXT(icd_term->instance, pCreateInfo, pAllocator, &icd_info[storage_idx]); - - if (res != VK_SUCCESS) { - goto out; - } - storage_idx++; - } - -// Setup the debug report callback in the terminator since a layer may want -// to grab the information itself (RenderDoc) and then return back to the -// user callback a sub-set of the messages. -#if (DEBUG_DISABLE_APP_ALLOCATORS == 0) - if (pAllocator != NULL) { - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode), - sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } else { -#else - { -#endif - pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode), - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - } - if (!pNewDbgFuncNode) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode)); - - pNewDbgFuncNode->is_messenger = false; - pNewDbgFuncNode->report.pfnMsgCallback = pCreateInfo->pfnCallback; - pNewDbgFuncNode->report.msgFlags = pCreateInfo->flags; - pNewDbgFuncNode->pUserData = pCreateInfo->pUserData; - pNewDbgFuncNode->pNext = inst->DbgFunctionHead; - inst->DbgFunctionHead = pNewDbgFuncNode; - - *(VkDebugReportCallbackEXT **)pCallback = icd_info; - pNewDbgFuncNode->report.msgCallback = *pCallback; - -out: - - // Roll back on errors - if (VK_SUCCESS != res) { - storage_idx = 0; - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (NULL == icd_term->dispatch.DestroyDebugReportCallbackEXT) { - continue; - } - - if (icd_info && icd_info[storage_idx]) { - icd_term->dispatch.DestroyDebugReportCallbackEXT(icd_term->instance, icd_info[storage_idx], pAllocator); - } - storage_idx++; - } - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - if (NULL != pNewDbgFuncNode) { - pAllocator->pfnFree(pAllocator->pUserData, pNewDbgFuncNode); - } - if (NULL != icd_info) { - pAllocator->pfnFree(pAllocator->pUserData, icd_info); - } - } else { -#endif - if (NULL != pNewDbgFuncNode) { - free(pNewDbgFuncNode); - } - if (NULL != icd_info) { - free(icd_info); - } - } - } - - return res; -} - -// This is the instance chain terminator function for DestroyDebugReportCallback -VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks *pAllocator) { - uint32_t storage_idx; - VkDebugReportCallbackEXT *icd_info; - const struct loader_icd_term *icd_term; - - struct loader_instance *inst = (struct loader_instance *)instance; - icd_info = *(VkDebugReportCallbackEXT **)&callback; - storage_idx = 0; - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (NULL == icd_term->dispatch.DestroyDebugReportCallbackEXT) { - continue; - } - - if (icd_info[storage_idx]) { - icd_term->dispatch.DestroyDebugReportCallbackEXT(icd_term->instance, icd_info[storage_idx], pAllocator); - } - storage_idx++; - } - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator != NULL) { - pAllocator->pfnFree(pAllocator->pUserData, icd_info); - } else { -#endif - free(icd_info); - } -} - -// This is the instance chain terminator function for DebugReportMessage -VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, - int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { - const struct loader_icd_term *icd_term; - - struct loader_instance *inst = (struct loader_instance *)instance; - - loader_platform_thread_lock_mutex(&loader_lock); - for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - if (icd_term->dispatch.DebugReportMessageEXT != NULL) { - icd_term->dispatch.DebugReportMessageEXT(icd_term->instance, flags, objType, object, location, msgCode, pLayerPrefix, - pMsg); - } - } - - // Now that all ICDs have seen the message, call the necessary callbacks. Ignoring "bail" return value - // as there is nothing to bail from at this point. - - util_DebugReportMessage(inst, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); - - loader_platform_thread_unlock_mutex(&loader_lock); -} - -// General utilities - -static const VkExtensionProperties debug_utils_extension_info[] = { - {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}, - {VK_EXT_DEBUG_UTILS_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_SPEC_VERSION}, -}; - -void debug_utils_AddInstanceExtensions(const struct loader_instance *inst, struct loader_extension_list *ext_list) { - loader_add_to_ext_list(inst, ext_list, sizeof(debug_utils_extension_info) / sizeof(VkExtensionProperties), - debug_utils_extension_info); -} - -void debug_utils_CreateInstance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) { - ptr_instance->enabled_known_extensions.ext_debug_report = 0; - ptr_instance->enabled_known_extensions.ext_debug_utils = 0; - - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) { - ptr_instance->enabled_known_extensions.ext_debug_report = 1; - } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) { - ptr_instance->enabled_known_extensions.ext_debug_utils = 1; - } - } -} - -bool debug_utils_InstanceGpa(struct loader_instance *ptr_instance, const char *name, void **addr) { - bool ret_type = false; - - *addr = NULL; - - if (!strcmp("vkCreateDebugReportCallbackEXT", name)) { - *addr = ptr_instance->enabled_known_extensions.ext_debug_report == 1 ? (void *)debug_utils_CreateDebugReportCallbackEXT : NULL; - ret_type = true; - } else if (!strcmp("vkDestroyDebugReportCallbackEXT", name)) { - *addr = ptr_instance->enabled_known_extensions.ext_debug_report == 1 ? (void *)debug_utils_DestroyDebugReportCallbackEXT : NULL; - ret_type = true; - } else if (!strcmp("vkDebugReportMessageEXT", name)) { - *addr = ptr_instance->enabled_known_extensions.ext_debug_report == 1 ? (void *)debug_utils_DebugReportMessageEXT : NULL; - return true; - } - if (!strcmp("vkCreateDebugUtilsMessengerEXT", name)) { - *addr = ptr_instance->enabled_known_extensions.ext_debug_utils == 1 ? (void *)debug_utils_CreateDebugUtilsMessengerEXT : NULL; - ret_type = true; - } else if (!strcmp("vkDestroyDebugUtilsMessengerEXT", name)) { - *addr = ptr_instance->enabled_known_extensions.ext_debug_utils == 1 ? (void *)debug_utils_DestroyDebugUtilsMessengerEXT : NULL; - ret_type = true; - } else if (!strcmp("vkSubmitDebugUtilsMessageEXT", name)) { - *addr = ptr_instance->enabled_known_extensions.ext_debug_utils == 1 ? (void *)debug_utils_SubmitDebugUtilsMessageEXT : NULL; - ret_type = true; - } - - return ret_type; -} - -bool debug_utils_ReportFlagsToAnnotFlags(VkDebugReportFlagsEXT dr_flags, bool default_flag_is_spec, - VkDebugUtilsMessageSeverityFlagBitsEXT *da_severity, - VkDebugUtilsMessageTypeFlagsEXT *da_type) { - bool type_set = false; - if (NULL == da_severity || NULL == da_type) { - return false; - } - *da_type = 0; - *da_severity = 0; - - if ((dr_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) != 0) { - *da_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT; - type_set = true; - } else if ((dr_flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT)) != 0) { - *da_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - } else if ((dr_flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) != 0) { - *da_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; - } else if ((dr_flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) != 0) { - *da_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT; - type_set = true; - } - - if ((dr_flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) != 0) { - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; - } else if (!type_set) { - if (default_flag_is_spec) { - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT; - } else { - *da_type |= VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT; - } - } - - return true; -} - -bool debug_utils_AnnotFlagsToReportFlags(VkDebugUtilsMessageSeverityFlagBitsEXT da_severity, - VkDebugUtilsMessageTypeFlagsEXT da_type, VkDebugReportFlagsEXT *dr_flags) { - if (NULL == dr_flags) { - return false; - } - - *dr_flags = 0; - - if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_ERROR_BIT_EXT; - } else if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) != 0) { - if ((da_type & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; - } else { - *dr_flags |= VK_DEBUG_REPORT_WARNING_BIT_EXT; - } - } else if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT; - } else if ((da_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) != 0) { - *dr_flags |= VK_DEBUG_REPORT_DEBUG_BIT_EXT; - } - - return true; -} - -bool debug_utils_ReportObjectToAnnotObject(VkDebugReportObjectTypeEXT dr_object_type, uint64_t object_handle, - VkDebugUtilsObjectNameInfoEXT *da_object_name_info) { - if (NULL == da_object_name_info) { - return false; - } - da_object_name_info->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; - da_object_name_info->pNext = NULL; - da_object_name_info->objectHandle = (uint64_t)(uintptr_t)object_handle; - da_object_name_info->pObjectName = NULL; - da_object_name_info->objectType = convertDebugReportObjectToCoreObject(dr_object_type); - return true; -} - -bool debug_utils_AnnotObjectToDebugReportObject(const VkDebugUtilsObjectNameInfoEXT *da_object_name_info, - VkDebugReportObjectTypeEXT *dr_object_type, uint64_t *dr_object_handle) { - if (NULL == da_object_name_info || NULL == dr_object_type || NULL == dr_object_handle) { - return false; - } - *dr_object_type = convertCoreObjectToDebugReportObject(da_object_name_info->objectType); - *dr_object_handle = da_object_name_info->objectHandle; - return true; -} diff --git a/loader/debug_utils.h b/loader/debug_utils.h deleted file mode 100644 index c33a6fce..00000000 --- a/loader/debug_utils.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * Copyright (C) 2015-2016 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: Courtney Goeltzenleuchter - * Author: Jon Ashburn - * Author: Mark Young - * - */ - -#include "vk_loader_platform.h" -#include "loader.h" - -// General utilities - -void debug_utils_AddInstanceExtensions(const struct loader_instance *inst, struct loader_extension_list *ext_list); -void debug_utils_CreateInstance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo); -bool debug_utils_InstanceGpa(struct loader_instance *ptr_instance, const char *name, void **addr); -bool debug_utils_ReportFlagsToAnnotFlags(VkDebugReportFlagsEXT dr_flags, bool default_flag_is_spec, - VkDebugUtilsMessageSeverityFlagBitsEXT *da_severity, - VkDebugUtilsMessageTypeFlagsEXT *da_type); -bool debug_utils_AnnotFlagsToReportFlags(VkDebugUtilsMessageSeverityFlagBitsEXT da_severity, - VkDebugUtilsMessageTypeFlagsEXT da_type, VkDebugReportFlagsEXT *dr_flags); -bool debug_utils_ReportObjectToAnnotObject(VkDebugReportObjectTypeEXT dr_object_type, uint64_t object_handle, - VkDebugUtilsObjectNameInfoEXT *da_object_name_info); -bool debug_utils_AnnotObjectToDebugReportObject(const VkDebugUtilsObjectNameInfoEXT *da_object_name_info, - VkDebugReportObjectTypeEXT *dr_object_type, uint64_t *dr_object_handle); - -// VK_EXT_debug_utils related items - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pMessenger); -VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator); -VKAPI_ATTR void VKAPI_CALL terminator_SubmitDebugUtilsMessageEXT(VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData); -VkResult util_CreateDebugUtilsMessenger(struct loader_instance *inst, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT messenger); -VkResult util_CreateDebugUtilsMessengers(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, - uint32_t num_messengers, VkDebugUtilsMessengerCreateInfoEXT *infos, - VkDebugUtilsMessengerEXT *messengers); -VkBool32 util_SubmitDebugUtilsMessageEXT(const struct loader_instance *inst, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData); -VkResult util_CopyDebugUtilsMessengerCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, - uint32_t *num_messengers, VkDebugUtilsMessengerCreateInfoEXT **infos, - VkDebugUtilsMessengerEXT **messengers); -void util_DestroyDebugUtilsMessenger(struct loader_instance *inst, VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks *pAllocator); -void util_DestroyDebugUtilsMessengers(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, - uint32_t num_messengers, VkDebugUtilsMessengerEXT *messengers); -void util_FreeDebugUtilsMessengerCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerCreateInfoEXT *infos, - VkDebugUtilsMessengerEXT *messengers); - -// VK_EXT_debug_report related items - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallbackEXT(VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pCallback); - -VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks *pAllocator); - -VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, - int32_t msgCode, const char *pLayerPrefix, const char *pMsg); - -VkResult util_CreateDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT callback); -VkResult util_CreateDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, - uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos, - VkDebugReportCallbackEXT *callbacks); -VkBool32 util_DebugReportMessage(const struct loader_instance *inst, VkFlags msgFlags, VkDebugReportObjectTypeEXT objectType, - uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg); -VkResult util_CopyDebugReportCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, uint32_t *num_callbacks, - VkDebugReportCallbackCreateInfoEXT **infos, VkDebugReportCallbackEXT **callbacks); -void util_DestroyDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks *pAllocator); -void util_DestroyDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, uint32_t num_callbacks, - VkDebugReportCallbackEXT *callbacks); -void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackCreateInfoEXT *infos, - VkDebugReportCallbackEXT *callbacks); diff --git a/loader/dev_ext_trampoline.c b/loader/dev_ext_trampoline.c deleted file mode 100644 index 55eee0c2..00000000 --- a/loader/dev_ext_trampoline.c +++ /dev/null @@ -1,538 +0,0 @@ -/* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Jon Ashburn - * Author: Lenny Komow - */ - -#include "vk_loader_platform.h" -#include "loader.h" -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC optimize(3) // force gcc to use tail-calls -#endif - -// Clang-format does not understand macros. -// clang-format off - -VKAPI_ATTR void VKAPI_CALL vkdev_ext0(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext1(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext2(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext3(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext4(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext5(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext6(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext7(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext8(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext9(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext10(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext11(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext12(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext13(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext14(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext15(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext16(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext17(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext18(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext19(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext20(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext21(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext22(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext23(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext24(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext25(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext26(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext27(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext28(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext29(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext30(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext31(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext32(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext33(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext34(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext35(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext36(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext37(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext38(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext39(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext40(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext41(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext42(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext43(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext44(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext45(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext46(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext47(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext48(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext49(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext50(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext51(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext52(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext53(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext54(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext55(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext56(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext57(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext58(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext59(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext60(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext61(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext62(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext63(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext64(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext65(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext66(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext67(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext68(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext69(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext70(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext71(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext72(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext73(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext74(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext75(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext76(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext77(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext78(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext79(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext80(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext81(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext82(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext83(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext84(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext85(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext86(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext87(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext88(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext89(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext90(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext91(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext92(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext93(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext94(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext95(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext96(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext97(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext98(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext99(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext100(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext101(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext102(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext103(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext104(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext105(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext106(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext107(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext108(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext109(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext110(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext111(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext112(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext113(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext114(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext115(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext116(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext117(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext118(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext119(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext120(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext121(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext122(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext123(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext124(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext125(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext126(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext127(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext128(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext129(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext130(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext131(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext132(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext133(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext134(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext135(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext136(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext137(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext138(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext139(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext140(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext141(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext142(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext143(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext144(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext145(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext146(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext147(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext148(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext149(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext150(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext151(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext152(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext153(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext154(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext155(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext156(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext157(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext158(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext159(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext160(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext161(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext162(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext163(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext164(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext165(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext166(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext167(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext168(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext169(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext170(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext171(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext172(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext173(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext174(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext175(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext176(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext177(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext178(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext179(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext180(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext181(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext182(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext183(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext184(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext185(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext186(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext187(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext188(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext189(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext190(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext191(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext192(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext193(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext194(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext195(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext196(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext197(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext198(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext199(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext200(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext201(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext202(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext203(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext204(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext205(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext206(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext207(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext208(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext209(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext210(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext211(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext212(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext213(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext214(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext215(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext216(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext217(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext218(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext219(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext220(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext221(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext222(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext223(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext224(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext225(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext226(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext227(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext228(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext229(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext230(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext231(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext232(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext233(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext234(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext235(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext236(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext237(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext238(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext239(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext240(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext241(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext242(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext243(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext244(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext245(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext246(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext247(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext248(VkDevice device); -VKAPI_ATTR void VKAPI_CALL vkdev_ext249(VkDevice device); - -void *loader_get_dev_ext_trampoline(uint32_t index) { - switch (index) { -#define CASE_HANDLE(num) case num: return vkdev_ext##num - CASE_HANDLE(0); - CASE_HANDLE(1); - CASE_HANDLE(2); - CASE_HANDLE(3); - CASE_HANDLE(4); - CASE_HANDLE(5); - CASE_HANDLE(6); - CASE_HANDLE(7); - CASE_HANDLE(8); - CASE_HANDLE(9); - CASE_HANDLE(10); - CASE_HANDLE(11); - CASE_HANDLE(12); - CASE_HANDLE(13); - CASE_HANDLE(14); - CASE_HANDLE(15); - CASE_HANDLE(16); - CASE_HANDLE(17); - CASE_HANDLE(18); - CASE_HANDLE(19); - CASE_HANDLE(20); - CASE_HANDLE(21); - CASE_HANDLE(22); - CASE_HANDLE(23); - CASE_HANDLE(24); - CASE_HANDLE(25); - CASE_HANDLE(26); - CASE_HANDLE(27); - CASE_HANDLE(28); - CASE_HANDLE(29); - CASE_HANDLE(30); - CASE_HANDLE(31); - CASE_HANDLE(32); - CASE_HANDLE(33); - CASE_HANDLE(34); - CASE_HANDLE(35); - CASE_HANDLE(36); - CASE_HANDLE(37); - CASE_HANDLE(38); - CASE_HANDLE(39); - CASE_HANDLE(40); - CASE_HANDLE(41); - CASE_HANDLE(42); - CASE_HANDLE(43); - CASE_HANDLE(44); - CASE_HANDLE(45); - CASE_HANDLE(46); - CASE_HANDLE(47); - CASE_HANDLE(48); - CASE_HANDLE(49); - CASE_HANDLE(50); - CASE_HANDLE(51); - CASE_HANDLE(52); - CASE_HANDLE(53); - CASE_HANDLE(54); - CASE_HANDLE(55); - CASE_HANDLE(56); - CASE_HANDLE(57); - CASE_HANDLE(58); - CASE_HANDLE(59); - CASE_HANDLE(60); - CASE_HANDLE(61); - CASE_HANDLE(62); - CASE_HANDLE(63); - CASE_HANDLE(64); - CASE_HANDLE(65); - CASE_HANDLE(66); - CASE_HANDLE(67); - CASE_HANDLE(68); - CASE_HANDLE(69); - CASE_HANDLE(70); - CASE_HANDLE(71); - CASE_HANDLE(72); - CASE_HANDLE(73); - CASE_HANDLE(74); - CASE_HANDLE(75); - CASE_HANDLE(76); - CASE_HANDLE(77); - CASE_HANDLE(78); - CASE_HANDLE(79); - CASE_HANDLE(80); - CASE_HANDLE(81); - CASE_HANDLE(82); - CASE_HANDLE(83); - CASE_HANDLE(84); - CASE_HANDLE(85); - CASE_HANDLE(86); - CASE_HANDLE(87); - CASE_HANDLE(88); - CASE_HANDLE(89); - CASE_HANDLE(90); - CASE_HANDLE(91); - CASE_HANDLE(92); - CASE_HANDLE(93); - CASE_HANDLE(94); - CASE_HANDLE(95); - CASE_HANDLE(96); - CASE_HANDLE(97); - CASE_HANDLE(98); - CASE_HANDLE(99); - CASE_HANDLE(100); - CASE_HANDLE(101); - CASE_HANDLE(102); - CASE_HANDLE(103); - CASE_HANDLE(104); - CASE_HANDLE(105); - CASE_HANDLE(106); - CASE_HANDLE(107); - CASE_HANDLE(108); - CASE_HANDLE(109); - CASE_HANDLE(110); - CASE_HANDLE(111); - CASE_HANDLE(112); - CASE_HANDLE(113); - CASE_HANDLE(114); - CASE_HANDLE(115); - CASE_HANDLE(116); - CASE_HANDLE(117); - CASE_HANDLE(118); - CASE_HANDLE(119); - CASE_HANDLE(120); - CASE_HANDLE(121); - CASE_HANDLE(122); - CASE_HANDLE(123); - CASE_HANDLE(124); - CASE_HANDLE(125); - CASE_HANDLE(126); - CASE_HANDLE(127); - CASE_HANDLE(128); - CASE_HANDLE(129); - CASE_HANDLE(130); - CASE_HANDLE(131); - CASE_HANDLE(132); - CASE_HANDLE(133); - CASE_HANDLE(134); - CASE_HANDLE(135); - CASE_HANDLE(136); - CASE_HANDLE(137); - CASE_HANDLE(138); - CASE_HANDLE(139); - CASE_HANDLE(140); - CASE_HANDLE(141); - CASE_HANDLE(142); - CASE_HANDLE(143); - CASE_HANDLE(144); - CASE_HANDLE(145); - CASE_HANDLE(146); - CASE_HANDLE(147); - CASE_HANDLE(148); - CASE_HANDLE(149); - CASE_HANDLE(150); - CASE_HANDLE(151); - CASE_HANDLE(152); - CASE_HANDLE(153); - CASE_HANDLE(154); - CASE_HANDLE(155); - CASE_HANDLE(156); - CASE_HANDLE(157); - CASE_HANDLE(158); - CASE_HANDLE(159); - CASE_HANDLE(160); - CASE_HANDLE(161); - CASE_HANDLE(162); - CASE_HANDLE(163); - CASE_HANDLE(164); - CASE_HANDLE(165); - CASE_HANDLE(166); - CASE_HANDLE(167); - CASE_HANDLE(168); - CASE_HANDLE(169); - CASE_HANDLE(170); - CASE_HANDLE(171); - CASE_HANDLE(172); - CASE_HANDLE(173); - CASE_HANDLE(174); - CASE_HANDLE(175); - CASE_HANDLE(176); - CASE_HANDLE(177); - CASE_HANDLE(178); - CASE_HANDLE(179); - CASE_HANDLE(180); - CASE_HANDLE(181); - CASE_HANDLE(182); - CASE_HANDLE(183); - CASE_HANDLE(184); - CASE_HANDLE(185); - CASE_HANDLE(186); - CASE_HANDLE(187); - CASE_HANDLE(188); - CASE_HANDLE(189); - CASE_HANDLE(190); - CASE_HANDLE(191); - CASE_HANDLE(192); - CASE_HANDLE(193); - CASE_HANDLE(194); - CASE_HANDLE(195); - CASE_HANDLE(196); - CASE_HANDLE(197); - CASE_HANDLE(198); - CASE_HANDLE(199); - CASE_HANDLE(200); - CASE_HANDLE(201); - CASE_HANDLE(202); - CASE_HANDLE(203); - CASE_HANDLE(204); - CASE_HANDLE(205); - CASE_HANDLE(206); - CASE_HANDLE(207); - CASE_HANDLE(208); - CASE_HANDLE(209); - CASE_HANDLE(210); - CASE_HANDLE(211); - CASE_HANDLE(212); - CASE_HANDLE(213); - CASE_HANDLE(214); - CASE_HANDLE(215); - CASE_HANDLE(216); - CASE_HANDLE(217); - CASE_HANDLE(218); - CASE_HANDLE(219); - CASE_HANDLE(220); - CASE_HANDLE(221); - CASE_HANDLE(222); - CASE_HANDLE(223); - CASE_HANDLE(224); - CASE_HANDLE(225); - CASE_HANDLE(226); - CASE_HANDLE(227); - CASE_HANDLE(228); - CASE_HANDLE(229); - CASE_HANDLE(230); - CASE_HANDLE(231); - CASE_HANDLE(232); - CASE_HANDLE(233); - CASE_HANDLE(234); - CASE_HANDLE(235); - CASE_HANDLE(236); - CASE_HANDLE(237); - CASE_HANDLE(238); - CASE_HANDLE(239); - CASE_HANDLE(240); - CASE_HANDLE(241); - CASE_HANDLE(242); - CASE_HANDLE(243); - CASE_HANDLE(244); - CASE_HANDLE(245); - CASE_HANDLE(246); - CASE_HANDLE(247); - CASE_HANDLE(248); - CASE_HANDLE(249); - } - - return NULL; -} diff --git a/loader/dirent_on_windows.c b/loader/dirent_on_windows.c deleted file mode 100644 index 16318cc7..00000000 --- a/loader/dirent_on_windows.c +++ /dev/null @@ -1,128 +0,0 @@ -/* - - Implementation of POSIX directory browsing functions and types for Win32. - - Author: Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com) - History: Created March 1997. Updated June 2003 and July 2012. - Rights: See end of file. - -*/ -#include "dirent_on_windows.h" -#include -#include /* _findfirst and _findnext set errno iff they return -1 */ -#include -#include -#include "vk_loader_platform.h" -#include "loader.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef ptrdiff_t handle_type; /* C99's intptr_t not sufficiently portable */ - -struct DIR { - handle_type handle; /* -1 for failed rewind */ - struct _finddata_t info; - struct dirent result; /* d_name null iff first time */ - char *name; /* null-terminated char string */ -}; - -DIR *opendir(const char *name) { - DIR *dir = 0; - - if (name && name[0]) { - size_t base_length = strlen(name); - const char *all = /* search pattern must end with suitable wildcard */ - strchr("/\\", name[base_length - 1]) ? "*" : "/*"; - - if ((dir = (DIR *)loader_instance_tls_heap_alloc(sizeof *dir)) != 0 && - (dir->name = (char *)loader_instance_tls_heap_alloc(base_length + strlen(all) + 1)) != 0) { - strcat(strcpy(dir->name, name), all); - - if ((dir->handle = (handle_type)_findfirst(dir->name, &dir->info)) != -1) { - dir->result.d_name = 0; - } else /* rollback */ - { - loader_instance_tls_heap_free(dir->name); - loader_instance_tls_heap_free(dir); - dir = 0; - } - } else /* rollback */ - { - loader_instance_tls_heap_free(dir); - dir = 0; - errno = ENOMEM; - } - } else { - errno = EINVAL; - } - - return dir; -} - -int closedir(DIR *dir) { - int result = -1; - - if (dir) { - if (dir->handle != -1) { - result = _findclose(dir->handle); - } - - loader_instance_tls_heap_free(dir->name); - loader_instance_tls_heap_free(dir); - } - - if (result == -1) /* map all errors to EBADF */ - { - errno = EBADF; - } - - return result; -} - -struct dirent *readdir(DIR *dir) { - struct dirent *result = 0; - - if (dir && dir->handle != -1) { - if (!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1) { - result = &dir->result; - result->d_name = dir->info.name; - } - } else { - errno = EBADF; - } - - return result; -} - -void rewinddir(DIR *dir) { - if (dir && dir->handle != -1) { - _findclose(dir->handle); - dir->handle = (handle_type)_findfirst(dir->name, &dir->info); - dir->result.d_name = 0; - } else { - errno = EBADF; - } -} - -#ifdef __cplusplus -} -#endif - -/* - - Copyright Kevlin Henney, 1997, 2003, 2012. All rights reserved. - Copyright (c) 2015 The Khronos Group Inc. - Copyright (c) 2015 Valve Corporation - Copyright (c) 2015 LunarG, Inc. - Permission to use, copy, modify, and distribute this software and its - documentation for any purpose is hereby granted without fee, provided - that this copyright and permissions notice appear in all copies and - derivatives. - - This software is supplied "as is" without express or implied warranty. - - But that said, if there are any problems please get in touch. - -*/ diff --git a/loader/dirent_on_windows.h b/loader/dirent_on_windows.h deleted file mode 100644 index 8600f8ef..00000000 --- a/loader/dirent_on_windows.h +++ /dev/null @@ -1,51 +0,0 @@ -#ifndef DIRENT_INCLUDED -#define DIRENT_INCLUDED - -/* - - Declaration of POSIX directory browsing functions and types for Win32. - - Author: Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com) - History: Created March 1997. Updated June 2003. - Rights: See end of file. - -*/ - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct DIR DIR; - -struct dirent { - char *d_name; -}; - -DIR *opendir(const char *); -int closedir(DIR *); -struct dirent *readdir(DIR *); -void rewinddir(DIR *); - -/* - - Copyright Kevlin Henney, 1997, 2003. All rights reserved. - Copyright (c) 2015 The Khronos Group Inc. - Copyright (c) 2015 Valve Corporation - Copyright (c) 2015 LunarG, Inc. - - Permission to use, copy, modify, and distribute this software and its - documentation for any purpose is hereby granted without fee, provided - that this copyright and permissions notice appear in all copies and - derivatives. - - This software is supplied "as is" without express or implied warranty. - - But that said, if there are any problems please get in touch. - -*/ - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/loader/extension_manual.c b/loader/extension_manual.c deleted file mode 100644 index 2b70af70..00000000 --- a/loader/extension_manual.c +++ /dev/null @@ -1,362 +0,0 @@ -/* - * Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Mark Young - * Author: Lenny Komow - */ - -#define _GNU_SOURCE -#include -#include -#include -#include "vk_loader_platform.h" -#include "loader.h" -#include "vk_loader_extensions.h" -#include -#include "wsi.h" -#include "debug_utils.h" - -// ---- Manually added trampoline/terminator functions - -// These functions, for whatever reason, require more complex changes than -// can easily be automatically generated. - -// ---- VK_KHR_device_group extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetPhysicalDeviceSurfaceCapabilities2KHR(unwrapped_phys_dev, pSurfaceInfo, pSurfaceCapabilities); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - VkIcdSurface *icd_surface = (VkIcdSurface *)(pSurfaceInfo->surface); - uint8_t icd_index = phys_dev_term->icd_index; - - if (icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR != NULL) { - // Pass the call to the driver, possibly unwrapping the ICD surface - if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { - VkPhysicalDeviceSurfaceInfo2KHR info_copy = *pSurfaceInfo; - info_copy.surface = icd_surface->real_icd_surfaces[icd_index]; - return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev_term->phys_dev, &info_copy, - pSurfaceCapabilities); - } else { - return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev_term->phys_dev, pSurfaceInfo, - pSurfaceCapabilities); - } - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulating call in ICD \"%s\" using " - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", - icd_term->scanned_icd->lib_name); - - if (pSurfaceInfo->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulation found unrecognized structure type in " - "pSurfaceInfo->pNext - this struct will be ignored"); - } - - // Write to the VkSurfaceCapabilities2KHR struct - VkSurfaceKHR surface = pSurfaceInfo->surface; - if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { - surface = icd_surface->real_icd_surfaces[icd_index]; - } - VkResult res = icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, surface, - &pSurfaceCapabilities->surfaceCapabilities); - - if (pSurfaceCapabilities->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulation found unrecognized structure type in " - "pSurfaceCapabilities->pNext - this struct will be ignored"); - } - return res; - } -} - -// ---- VK_NV_external_memory_capabilities extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL -GetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, - VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - - return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV( - unwrapped_phys_dev, format, type, tiling, usage, flags, - externalHandleType, pExternalImageFormatProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL -terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, - VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) { - struct loader_physical_device_term *phys_dev_term = - (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - if (!icd_term->dispatch.GetPhysicalDeviceExternalImageFormatPropertiesNV) { - if (externalHandleType) { - return VK_ERROR_FORMAT_NOT_SUPPORTED; - } - - if (!icd_term->dispatch.GetPhysicalDeviceImageFormatProperties) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - pExternalImageFormatProperties->externalMemoryFeatures = 0; - pExternalImageFormatProperties->exportFromImportedHandleTypes = 0; - pExternalImageFormatProperties->compatibleHandleTypes = 0; - - return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties( - phys_dev_term->phys_dev, format, type, tiling, usage, flags, - &pExternalImageFormatProperties->imageFormatProperties); - } - - return icd_term->dispatch.GetPhysicalDeviceExternalImageFormatPropertiesNV( - phys_dev_term->phys_dev, format, type, tiling, usage, flags, - externalHandleType, pExternalImageFormatProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormat2KHR *pSurfaceFormats) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetPhysicalDeviceSurfaceFormats2KHR(unwrapped_phys_dev, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormat2KHR *pSurfaceFormats) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - VkIcdSurface *icd_surface = (VkIcdSurface *)(pSurfaceInfo->surface); - uint8_t icd_index = phys_dev_term->icd_index; - - if (icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR != NULL) { - // Pass the call to the driver, possibly unwrapping the ICD surface - if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { - VkPhysicalDeviceSurfaceInfo2KHR info_copy = *pSurfaceInfo; - info_copy.surface = icd_surface->real_icd_surfaces[icd_index]; - return icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR(phys_dev_term->phys_dev, &info_copy, pSurfaceFormatCount, - pSurfaceFormats); - } else { - return icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR(phys_dev_term->phys_dev, pSurfaceInfo, - pSurfaceFormatCount, pSurfaceFormats); - } - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceSurfaceFormatsKHR", - icd_term->scanned_icd->lib_name); - - if (pSurfaceInfo->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulation found unrecognized structure type in pSurfaceInfo->pNext " - "- this struct will be ignored"); - } - - VkSurfaceKHR surface = pSurfaceInfo->surface; - if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { - surface = icd_surface->real_icd_surfaces[icd_index]; - } - - if (*pSurfaceFormatCount == 0 || pSurfaceFormats == NULL) { - // Write to pSurfaceFormatCount - return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, pSurfaceFormatCount, - NULL); - } else { - // Allocate a temporary array for the output of the old function - VkSurfaceFormatKHR *formats = loader_stack_alloc(*pSurfaceFormatCount * sizeof(VkSurfaceFormatKHR)); - if (formats == NULL) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - VkResult res = icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, - pSurfaceFormatCount, formats); - for (uint32_t i = 0; i < *pSurfaceFormatCount; ++i) { - pSurfaceFormats[i].surfaceFormat = formats[i]; - if (pSurfaceFormats[i].pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulation found unrecognized structure type in " - "pSurfaceFormats[%d].pNext - this struct will be ignored", - i); - } - } - return res; - } - } -} - -// ---- VK_EXT_display_surface_counter extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetPhysicalDeviceSurfaceCapabilities2EXT(unwrapped_phys_dev, surface, pSurfaceCapabilities); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - VkIcdSurface *icd_surface = (VkIcdSurface *)(surface); - uint8_t icd_index = phys_dev_term->icd_index; - - // Unwrap the surface if needed - VkSurfaceKHR unwrapped_surface = surface; - if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { - unwrapped_surface = icd_surface->real_icd_surfaces[icd_index]; - } - - if (icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT != NULL) { - // Pass the call to the driver - return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev_term->phys_dev, unwrapped_surface, - pSurfaceCapabilities); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceCapabilities2EXT: Emulating call in ICD \"%s\" using " - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", - icd_term->scanned_icd->lib_name); - - VkSurfaceCapabilitiesKHR surface_caps; - VkResult res = - icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, unwrapped_surface, &surface_caps); - pSurfaceCapabilities->minImageCount = surface_caps.minImageCount; - pSurfaceCapabilities->maxImageCount = surface_caps.maxImageCount; - pSurfaceCapabilities->currentExtent = surface_caps.currentExtent; - pSurfaceCapabilities->minImageExtent = surface_caps.minImageExtent; - pSurfaceCapabilities->maxImageExtent = surface_caps.maxImageExtent; - pSurfaceCapabilities->maxImageArrayLayers = surface_caps.maxImageArrayLayers; - pSurfaceCapabilities->supportedTransforms = surface_caps.supportedTransforms; - pSurfaceCapabilities->currentTransform = surface_caps.currentTransform; - pSurfaceCapabilities->supportedCompositeAlpha = surface_caps.supportedCompositeAlpha; - pSurfaceCapabilities->supportedUsageFlags = surface_caps.supportedUsageFlags; - pSurfaceCapabilities->supportedSurfaceCounters = 0; - - if (pSurfaceCapabilities->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceSurfaceCapabilities2EXT: Emulation found unrecognized structure type in " - "pSurfaceCapabilities->pNext - this struct will be ignored"); - } - - return res; - } -} - -// ---- VK_EXT_direct_mode_display extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->ReleaseDisplayEXT(unwrapped_phys_dev, display); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - if (icd_term->dispatch.ReleaseDisplayEXT == NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD \"%s\" associated with VkPhysicalDevice does not support vkReleaseDisplayEXT - Consequently, the call is " - "invalid because it should not be possible to acquire a display on this device", - icd_term->scanned_icd->lib_name); - } - return icd_term->dispatch.ReleaseDisplayEXT(phys_dev_term->phys_dev, display); -} - -// ---- VK_EXT_acquire_xlib_display extension trampoline/terminators - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->AcquireXlibDisplayEXT(unwrapped_phys_dev, dpy, display); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, - VkDisplayKHR display) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - if (icd_term->dispatch.AcquireXlibDisplayEXT != NULL) { - // Pass the call to the driver - return icd_term->dispatch.AcquireXlibDisplayEXT(phys_dev_term->phys_dev, dpy, display); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkAcquireXLibDisplayEXT: Emulating call in ICD \"%s\" by returning error", icd_term->scanned_icd->lib_name); - - // Fail for the unsupported command - return VK_ERROR_INITIALIZATION_FAILED; - } -} - -VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, - VkDisplayKHR *pDisplay) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetRandROutputDisplayEXT(unwrapped_phys_dev, dpy, rrOutput, pDisplay); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, - VkDisplayKHR *pDisplay) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - if (icd_term->dispatch.GetRandROutputDisplayEXT != NULL) { - // Pass the call to the driver - return icd_term->dispatch.GetRandROutputDisplayEXT(phys_dev_term->phys_dev, dpy, rrOutput, pDisplay); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetRandROutputDisplayEXT: Emulating call in ICD \"%s\" by returning null display", - icd_term->scanned_icd->lib_name); - - // Return a null handle to indicate this can't be done - *pDisplay = VK_NULL_HANDLE; - return VK_SUCCESS; - } -} - -#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT diff --git a/loader/extension_manual.h b/loader/extension_manual.h deleted file mode 100644 index 5ae93bf0..00000000 --- a/loader/extension_manual.h +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Mark Young - */ - -#pragma once - -// ---- Manually added trampoline/terminator functions - -// These functions, for whatever reason, require more complex changes than -// can easily be automatically generated. - -VKAPI_ATTR VkResult VKAPI_CALL -GetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, - VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL -terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, - VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats); - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display); - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, - VkDisplayKHR display); - -VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, - VkDisplayKHR* pDisplay); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, - VkDisplayKHR* pDisplay); -#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h deleted file mode 100644 index 42c798f1..00000000 --- a/loader/gpa_helper.h +++ /dev/null @@ -1,232 +0,0 @@ -/* - * - * Copyright (c) 2015 The Khronos Group Inc. - * Copyright (c) 2015 Valve Corporation - * Copyright (c) 2015 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Jon Ashburn - */ - -#include -#include "debug_utils.h" -#include "wsi.h" - -static inline void *trampolineGetProcAddr(struct loader_instance *inst, const char *funcName) { - // Don't include or check global functions - if (!strcmp(funcName, "vkGetInstanceProcAddr")) return (PFN_vkVoidFunction)vkGetInstanceProcAddr; - if (!strcmp(funcName, "vkDestroyInstance")) return (PFN_vkVoidFunction)vkDestroyInstance; - if (!strcmp(funcName, "vkEnumeratePhysicalDevices")) return (PFN_vkVoidFunction)vkEnumeratePhysicalDevices; - if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceFeatures; - if (!strcmp(funcName, "vkGetPhysicalDeviceFormatProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceFormatProperties; - if (!strcmp(funcName, "vkGetPhysicalDeviceImageFormatProperties")) - return (PFN_vkVoidFunction)vkGetPhysicalDeviceImageFormatProperties; - if (!strcmp(funcName, "vkGetPhysicalDeviceSparseImageFormatProperties")) - return (PFN_vkVoidFunction)vkGetPhysicalDeviceSparseImageFormatProperties; - if (!strcmp(funcName, "vkGetPhysicalDeviceProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties; - if (!strcmp(funcName, "vkGetPhysicalDeviceQueueFamilyProperties")) - return (PFN_vkVoidFunction)vkGetPhysicalDeviceQueueFamilyProperties; - if (!strcmp(funcName, "vkGetPhysicalDeviceMemoryProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceMemoryProperties; - if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties")) return (PFN_vkVoidFunction)vkEnumerateDeviceLayerProperties; - if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties")) return (PFN_vkVoidFunction)vkEnumerateDeviceExtensionProperties; - if (!strcmp(funcName, "vkCreateDevice")) return (PFN_vkVoidFunction)vkCreateDevice; - if (!strcmp(funcName, "vkGetDeviceProcAddr")) return (PFN_vkVoidFunction)vkGetDeviceProcAddr; - if (!strcmp(funcName, "vkDestroyDevice")) return (PFN_vkVoidFunction)vkDestroyDevice; - if (!strcmp(funcName, "vkGetDeviceQueue")) return (PFN_vkVoidFunction)vkGetDeviceQueue; - if (!strcmp(funcName, "vkQueueSubmit")) return (PFN_vkVoidFunction)vkQueueSubmit; - if (!strcmp(funcName, "vkQueueWaitIdle")) return (PFN_vkVoidFunction)vkQueueWaitIdle; - if (!strcmp(funcName, "vkDeviceWaitIdle")) return (PFN_vkVoidFunction)vkDeviceWaitIdle; - if (!strcmp(funcName, "vkAllocateMemory")) return (PFN_vkVoidFunction)vkAllocateMemory; - if (!strcmp(funcName, "vkFreeMemory")) return (PFN_vkVoidFunction)vkFreeMemory; - if (!strcmp(funcName, "vkMapMemory")) return (PFN_vkVoidFunction)vkMapMemory; - if (!strcmp(funcName, "vkUnmapMemory")) return (PFN_vkVoidFunction)vkUnmapMemory; - if (!strcmp(funcName, "vkFlushMappedMemoryRanges")) return (PFN_vkVoidFunction)vkFlushMappedMemoryRanges; - if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges")) return (PFN_vkVoidFunction)vkInvalidateMappedMemoryRanges; - if (!strcmp(funcName, "vkGetDeviceMemoryCommitment")) return (PFN_vkVoidFunction)vkGetDeviceMemoryCommitment; - if (!strcmp(funcName, "vkGetImageSparseMemoryRequirements")) return (PFN_vkVoidFunction)vkGetImageSparseMemoryRequirements; - if (!strcmp(funcName, "vkGetImageMemoryRequirements")) return (PFN_vkVoidFunction)vkGetImageMemoryRequirements; - if (!strcmp(funcName, "vkGetBufferMemoryRequirements")) return (PFN_vkVoidFunction)vkGetBufferMemoryRequirements; - if (!strcmp(funcName, "vkBindImageMemory")) return (PFN_vkVoidFunction)vkBindImageMemory; - if (!strcmp(funcName, "vkBindBufferMemory")) return (PFN_vkVoidFunction)vkBindBufferMemory; - if (!strcmp(funcName, "vkQueueBindSparse")) return (PFN_vkVoidFunction)vkQueueBindSparse; - if (!strcmp(funcName, "vkCreateFence")) return (PFN_vkVoidFunction)vkCreateFence; - if (!strcmp(funcName, "vkDestroyFence")) return (PFN_vkVoidFunction)vkDestroyFence; - if (!strcmp(funcName, "vkGetFenceStatus")) return (PFN_vkVoidFunction)vkGetFenceStatus; - if (!strcmp(funcName, "vkResetFences")) return (PFN_vkVoidFunction)vkResetFences; - if (!strcmp(funcName, "vkWaitForFences")) return (PFN_vkVoidFunction)vkWaitForFences; - if (!strcmp(funcName, "vkCreateSemaphore")) return (PFN_vkVoidFunction)vkCreateSemaphore; - if (!strcmp(funcName, "vkDestroySemaphore")) return (PFN_vkVoidFunction)vkDestroySemaphore; - if (!strcmp(funcName, "vkCreateEvent")) return (PFN_vkVoidFunction)vkCreateEvent; - if (!strcmp(funcName, "vkDestroyEvent")) return (PFN_vkVoidFunction)vkDestroyEvent; - if (!strcmp(funcName, "vkGetEventStatus")) return (PFN_vkVoidFunction)vkGetEventStatus; - if (!strcmp(funcName, "vkSetEvent")) return (PFN_vkVoidFunction)vkSetEvent; - if (!strcmp(funcName, "vkResetEvent")) return (PFN_vkVoidFunction)vkResetEvent; - if (!strcmp(funcName, "vkCreateQueryPool")) return (PFN_vkVoidFunction)vkCreateQueryPool; - if (!strcmp(funcName, "vkDestroyQueryPool")) return (PFN_vkVoidFunction)vkDestroyQueryPool; - if (!strcmp(funcName, "vkGetQueryPoolResults")) return (PFN_vkVoidFunction)vkGetQueryPoolResults; - if (!strcmp(funcName, "vkCreateBuffer")) return (PFN_vkVoidFunction)vkCreateBuffer; - if (!strcmp(funcName, "vkDestroyBuffer")) return (PFN_vkVoidFunction)vkDestroyBuffer; - if (!strcmp(funcName, "vkCreateBufferView")) return (PFN_vkVoidFunction)vkCreateBufferView; - if (!strcmp(funcName, "vkDestroyBufferView")) return (PFN_vkVoidFunction)vkDestroyBufferView; - if (!strcmp(funcName, "vkCreateImage")) return (PFN_vkVoidFunction)vkCreateImage; - if (!strcmp(funcName, "vkDestroyImage")) return (PFN_vkVoidFunction)vkDestroyImage; - if (!strcmp(funcName, "vkGetImageSubresourceLayout")) return (PFN_vkVoidFunction)vkGetImageSubresourceLayout; - if (!strcmp(funcName, "vkCreateImageView")) return (PFN_vkVoidFunction)vkCreateImageView; - if (!strcmp(funcName, "vkDestroyImageView")) return (PFN_vkVoidFunction)vkDestroyImageView; - if (!strcmp(funcName, "vkCreateShaderModule")) return (PFN_vkVoidFunction)vkCreateShaderModule; - if (!strcmp(funcName, "vkDestroyShaderModule")) return (PFN_vkVoidFunction)vkDestroyShaderModule; - if (!strcmp(funcName, "vkCreatePipelineCache")) return (PFN_vkVoidFunction)vkCreatePipelineCache; - if (!strcmp(funcName, "vkDestroyPipelineCache")) return (PFN_vkVoidFunction)vkDestroyPipelineCache; - if (!strcmp(funcName, "vkGetPipelineCacheData")) return (PFN_vkVoidFunction)vkGetPipelineCacheData; - if (!strcmp(funcName, "vkMergePipelineCaches")) return (PFN_vkVoidFunction)vkMergePipelineCaches; - if (!strcmp(funcName, "vkCreateGraphicsPipelines")) return (PFN_vkVoidFunction)vkCreateGraphicsPipelines; - if (!strcmp(funcName, "vkCreateComputePipelines")) return (PFN_vkVoidFunction)vkCreateComputePipelines; - if (!strcmp(funcName, "vkDestroyPipeline")) return (PFN_vkVoidFunction)vkDestroyPipeline; - if (!strcmp(funcName, "vkCreatePipelineLayout")) return (PFN_vkVoidFunction)vkCreatePipelineLayout; - if (!strcmp(funcName, "vkDestroyPipelineLayout")) return (PFN_vkVoidFunction)vkDestroyPipelineLayout; - if (!strcmp(funcName, "vkCreateSampler")) return (PFN_vkVoidFunction)vkCreateSampler; - if (!strcmp(funcName, "vkDestroySampler")) return (PFN_vkVoidFunction)vkDestroySampler; - if (!strcmp(funcName, "vkCreateDescriptorSetLayout")) return (PFN_vkVoidFunction)vkCreateDescriptorSetLayout; - if (!strcmp(funcName, "vkDestroyDescriptorSetLayout")) return (PFN_vkVoidFunction)vkDestroyDescriptorSetLayout; - if (!strcmp(funcName, "vkCreateDescriptorPool")) return (PFN_vkVoidFunction)vkCreateDescriptorPool; - if (!strcmp(funcName, "vkDestroyDescriptorPool")) return (PFN_vkVoidFunction)vkDestroyDescriptorPool; - if (!strcmp(funcName, "vkResetDescriptorPool")) return (PFN_vkVoidFunction)vkResetDescriptorPool; - if (!strcmp(funcName, "vkAllocateDescriptorSets")) return (PFN_vkVoidFunction)vkAllocateDescriptorSets; - if (!strcmp(funcName, "vkFreeDescriptorSets")) return (PFN_vkVoidFunction)vkFreeDescriptorSets; - if (!strcmp(funcName, "vkUpdateDescriptorSets")) return (PFN_vkVoidFunction)vkUpdateDescriptorSets; - if (!strcmp(funcName, "vkCreateFramebuffer")) return (PFN_vkVoidFunction)vkCreateFramebuffer; - if (!strcmp(funcName, "vkDestroyFramebuffer")) return (PFN_vkVoidFunction)vkDestroyFramebuffer; - if (!strcmp(funcName, "vkCreateRenderPass")) return (PFN_vkVoidFunction)vkCreateRenderPass; - if (!strcmp(funcName, "vkDestroyRenderPass")) return (PFN_vkVoidFunction)vkDestroyRenderPass; - if (!strcmp(funcName, "vkGetRenderAreaGranularity")) return (PFN_vkVoidFunction)vkGetRenderAreaGranularity; - if (!strcmp(funcName, "vkCreateCommandPool")) return (PFN_vkVoidFunction)vkCreateCommandPool; - if (!strcmp(funcName, "vkDestroyCommandPool")) return (PFN_vkVoidFunction)vkDestroyCommandPool; - if (!strcmp(funcName, "vkResetCommandPool")) return (PFN_vkVoidFunction)vkResetCommandPool; - if (!strcmp(funcName, "vkAllocateCommandBuffers")) return (PFN_vkVoidFunction)vkAllocateCommandBuffers; - if (!strcmp(funcName, "vkFreeCommandBuffers")) return (PFN_vkVoidFunction)vkFreeCommandBuffers; - if (!strcmp(funcName, "vkBeginCommandBuffer")) return (PFN_vkVoidFunction)vkBeginCommandBuffer; - if (!strcmp(funcName, "vkEndCommandBuffer")) return (PFN_vkVoidFunction)vkEndCommandBuffer; - if (!strcmp(funcName, "vkResetCommandBuffer")) return (PFN_vkVoidFunction)vkResetCommandBuffer; - if (!strcmp(funcName, "vkCmdBindPipeline")) return (PFN_vkVoidFunction)vkCmdBindPipeline; - if (!strcmp(funcName, "vkCmdBindDescriptorSets")) return (PFN_vkVoidFunction)vkCmdBindDescriptorSets; - if (!strcmp(funcName, "vkCmdBindVertexBuffers")) return (PFN_vkVoidFunction)vkCmdBindVertexBuffers; - if (!strcmp(funcName, "vkCmdBindIndexBuffer")) return (PFN_vkVoidFunction)vkCmdBindIndexBuffer; - if (!strcmp(funcName, "vkCmdSetViewport")) return (PFN_vkVoidFunction)vkCmdSetViewport; - if (!strcmp(funcName, "vkCmdSetScissor")) return (PFN_vkVoidFunction)vkCmdSetScissor; - if (!strcmp(funcName, "vkCmdSetLineWidth")) return (PFN_vkVoidFunction)vkCmdSetLineWidth; - if (!strcmp(funcName, "vkCmdSetDepthBias")) return (PFN_vkVoidFunction)vkCmdSetDepthBias; - if (!strcmp(funcName, "vkCmdSetBlendConstants")) return (PFN_vkVoidFunction)vkCmdSetBlendConstants; - if (!strcmp(funcName, "vkCmdSetDepthBounds")) return (PFN_vkVoidFunction)vkCmdSetDepthBounds; - if (!strcmp(funcName, "vkCmdSetStencilCompareMask")) return (PFN_vkVoidFunction)vkCmdSetStencilCompareMask; - if (!strcmp(funcName, "vkCmdSetStencilWriteMask")) return (PFN_vkVoidFunction)vkCmdSetStencilWriteMask; - if (!strcmp(funcName, "vkCmdSetStencilReference")) return (PFN_vkVoidFunction)vkCmdSetStencilReference; - if (!strcmp(funcName, "vkCmdDraw")) return (PFN_vkVoidFunction)vkCmdDraw; - if (!strcmp(funcName, "vkCmdDrawIndexed")) return (PFN_vkVoidFunction)vkCmdDrawIndexed; - if (!strcmp(funcName, "vkCmdDrawIndirect")) return (PFN_vkVoidFunction)vkCmdDrawIndirect; - if (!strcmp(funcName, "vkCmdDrawIndexedIndirect")) return (PFN_vkVoidFunction)vkCmdDrawIndexedIndirect; - if (!strcmp(funcName, "vkCmdDispatch")) return (PFN_vkVoidFunction)vkCmdDispatch; - if (!strcmp(funcName, "vkCmdDispatchIndirect")) return (PFN_vkVoidFunction)vkCmdDispatchIndirect; - if (!strcmp(funcName, "vkCmdCopyBuffer")) return (PFN_vkVoidFunction)vkCmdCopyBuffer; - if (!strcmp(funcName, "vkCmdCopyImage")) return (PFN_vkVoidFunction)vkCmdCopyImage; - if (!strcmp(funcName, "vkCmdBlitImage")) return (PFN_vkVoidFunction)vkCmdBlitImage; - if (!strcmp(funcName, "vkCmdCopyBufferToImage")) return (PFN_vkVoidFunction)vkCmdCopyBufferToImage; - if (!strcmp(funcName, "vkCmdCopyImageToBuffer")) return (PFN_vkVoidFunction)vkCmdCopyImageToBuffer; - if (!strcmp(funcName, "vkCmdUpdateBuffer")) return (PFN_vkVoidFunction)vkCmdUpdateBuffer; - if (!strcmp(funcName, "vkCmdFillBuffer")) return (PFN_vkVoidFunction)vkCmdFillBuffer; - if (!strcmp(funcName, "vkCmdClearColorImage")) return (PFN_vkVoidFunction)vkCmdClearColorImage; - if (!strcmp(funcName, "vkCmdClearDepthStencilImage")) return (PFN_vkVoidFunction)vkCmdClearDepthStencilImage; - if (!strcmp(funcName, "vkCmdClearAttachments")) return (PFN_vkVoidFunction)vkCmdClearAttachments; - if (!strcmp(funcName, "vkCmdResolveImage")) return (PFN_vkVoidFunction)vkCmdResolveImage; - if (!strcmp(funcName, "vkCmdSetEvent")) return (PFN_vkVoidFunction)vkCmdSetEvent; - if (!strcmp(funcName, "vkCmdResetEvent")) return (PFN_vkVoidFunction)vkCmdResetEvent; - if (!strcmp(funcName, "vkCmdWaitEvents")) return (PFN_vkVoidFunction)vkCmdWaitEvents; - if (!strcmp(funcName, "vkCmdPipelineBarrier")) return (PFN_vkVoidFunction)vkCmdPipelineBarrier; - if (!strcmp(funcName, "vkCmdBeginQuery")) return (PFN_vkVoidFunction)vkCmdBeginQuery; - if (!strcmp(funcName, "vkCmdEndQuery")) return (PFN_vkVoidFunction)vkCmdEndQuery; - if (!strcmp(funcName, "vkCmdResetQueryPool")) return (PFN_vkVoidFunction)vkCmdResetQueryPool; - if (!strcmp(funcName, "vkCmdWriteTimestamp")) return (PFN_vkVoidFunction)vkCmdWriteTimestamp; - if (!strcmp(funcName, "vkCmdCopyQueryPoolResults")) return (PFN_vkVoidFunction)vkCmdCopyQueryPoolResults; - if (!strcmp(funcName, "vkCmdPushConstants")) return (PFN_vkVoidFunction)vkCmdPushConstants; - if (!strcmp(funcName, "vkCmdBeginRenderPass")) return (PFN_vkVoidFunction)vkCmdBeginRenderPass; - if (!strcmp(funcName, "vkCmdNextSubpass")) return (PFN_vkVoidFunction)vkCmdNextSubpass; - if (!strcmp(funcName, "vkCmdEndRenderPass")) return (PFN_vkVoidFunction)vkCmdEndRenderPass; - if (!strcmp(funcName, "vkCmdExecuteCommands")) return (PFN_vkVoidFunction)vkCmdExecuteCommands; - - // Core 1.1 functions - if (!strcmp(funcName, "vkEnumeratePhysicalDeviceGroups")) return (PFN_vkVoidFunction)vkEnumeratePhysicalDeviceGroups; - if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures2")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceFeatures2; - if (!strcmp(funcName, "vkGetPhysicalDeviceProperties2")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties2; - if (!strcmp(funcName, "vkGetPhysicalDeviceFormatProperties2")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceFormatProperties2; - if (!strcmp(funcName, "vkGetPhysicalDeviceImageFormatProperties2")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceImageFormatProperties2; - if (!strcmp(funcName, "vkGetPhysicalDeviceQueueFamilyProperties2")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceQueueFamilyProperties2; - if (!strcmp(funcName, "vkGetPhysicalDeviceMemoryProperties2")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceMemoryProperties2; - if (!strcmp(funcName, "vkGetPhysicalDeviceSparseImageFormatProperties2")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceSparseImageFormatProperties2; - if (!strcmp(funcName, "vkGetPhysicalDeviceExternalBufferProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceExternalBufferProperties; - if (!strcmp(funcName, "vkGetPhysicalDeviceExternalSemaphoreProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceExternalSemaphoreProperties; - if (!strcmp(funcName, "vkGetPhysicalDeviceExternalFenceProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceExternalFenceProperties; - if (!strcmp(funcName, "vkBindBufferMemory2")) return (PFN_vkVoidFunction)vkBindBufferMemory2; - if (!strcmp(funcName, "vkBindImageMemory2")) return (PFN_vkVoidFunction)vkBindImageMemory2; - if (!strcmp(funcName, "vkGetDeviceGroupPeerMemoryFeatures")) return (PFN_vkVoidFunction)vkGetDeviceGroupPeerMemoryFeatures; - if (!strcmp(funcName, "vkCmdSetDeviceMask")) return (PFN_vkVoidFunction)vkCmdSetDeviceMask; - if (!strcmp(funcName, "vkCmdDispatchBase")) return (PFN_vkVoidFunction)vkCmdDispatchBase; - if (!strcmp(funcName, "vkGetImageMemoryRequirements2")) return (PFN_vkVoidFunction)vkGetImageMemoryRequirements2; - if (!strcmp(funcName, "vkTrimCommandPool")) return (PFN_vkVoidFunction)vkTrimCommandPool; - if (!strcmp(funcName, "vkGetDeviceQueue2")) return (PFN_vkVoidFunction)vkGetDeviceQueue2; - if (!strcmp(funcName, "vkCreateSamplerYcbcrConversion")) return (PFN_vkVoidFunction)vkCreateSamplerYcbcrConversion; - if (!strcmp(funcName, "vkDestroySamplerYcbcrConversion")) return (PFN_vkVoidFunction)vkDestroySamplerYcbcrConversion; - if (!strcmp(funcName, "vkGetDescriptorSetLayoutSupport")) return (PFN_vkVoidFunction)vkGetDescriptorSetLayoutSupport; - if (!strcmp(funcName, "vkCreateDescriptorUpdateTemplate")) return (PFN_vkCreateDescriptorUpdateTemplate)vkCreateDescriptorUpdateTemplate; - if (!strcmp(funcName, "vkDestroyDescriptorUpdateTemplate")) return (PFN_vkDestroyDescriptorUpdateTemplate)vkDestroyDescriptorUpdateTemplate; - if (!strcmp(funcName, "vkUpdateDescriptorSetWithTemplate")) return (PFN_vkUpdateDescriptorSetWithTemplate)vkUpdateDescriptorSetWithTemplate; - - // Instance extensions - void *addr; - if (debug_utils_InstanceGpa(inst, funcName, &addr)) return addr; - - if (wsi_swapchain_instance_gpa(inst, funcName, &addr)) return addr; - - if (extension_instance_gpa(inst, funcName, &addr)) return addr; - - // Unknown physical device extensions - if (loader_phys_dev_ext_gpa(inst, funcName, true, &addr, NULL)) return addr; - - // Unknown device extensions - addr = loader_dev_ext_gpa(inst, funcName); - return addr; -} - -static inline void *globalGetProcAddr(const char *name) { - if (!name || name[0] != 'v' || name[1] != 'k') return NULL; - - name += 2; - if (!strcmp(name, "CreateInstance")) return (void *)vkCreateInstance; - if (!strcmp(name, "EnumerateInstanceExtensionProperties")) return (void *)vkEnumerateInstanceExtensionProperties; - if (!strcmp(name, "EnumerateInstanceLayerProperties")) return (void *)vkEnumerateInstanceLayerProperties; - if (!strcmp(name, "EnumerateInstanceVersion")) return (void *)vkEnumerateInstanceVersion; - - return NULL; -} - -static inline void *loader_non_passthrough_gdpa(const char *name) { - if (!name || name[0] != 'v' || name[1] != 'k') return NULL; - - name += 2; - - if (!strcmp(name, "GetDeviceProcAddr")) return (void *)vkGetDeviceProcAddr; - if (!strcmp(name, "DestroyDevice")) return (void *)vkDestroyDevice; - if (!strcmp(name, "GetDeviceQueue")) return (void *)vkGetDeviceQueue; - if (!strcmp(name, "AllocateCommandBuffers")) return (void *)vkAllocateCommandBuffers; - - return NULL; -} diff --git a/loader/images/function_device_chain.png b/loader/images/function_device_chain.png deleted file mode 100644 index 62ba7a3d..00000000 Binary files a/loader/images/function_device_chain.png and /dev/null differ diff --git a/loader/images/function_device_chain_white.png b/loader/images/function_device_chain_white.png deleted file mode 100644 index b6107a89..00000000 Binary files a/loader/images/function_device_chain_white.png and /dev/null differ diff --git a/loader/images/function_instance_chain.png b/loader/images/function_instance_chain.png deleted file mode 100644 index b79fd969..00000000 Binary files a/loader/images/function_instance_chain.png and /dev/null differ diff --git a/loader/images/function_instance_chain_white.png b/loader/images/function_instance_chain_white.png deleted file mode 100644 index 48705a2a..00000000 Binary files a/loader/images/function_instance_chain_white.png and /dev/null differ diff --git a/loader/images/high_level_loader.png b/loader/images/high_level_loader.png deleted file mode 100644 index 391abb7d..00000000 Binary files a/loader/images/high_level_loader.png and /dev/null differ diff --git a/loader/images/high_level_loader_white.png b/loader/images/high_level_loader_white.png deleted file mode 100644 index c83cade1..00000000 Binary files a/loader/images/high_level_loader_white.png and /dev/null differ diff --git a/loader/images/loader_device_chain_app.png b/loader/images/loader_device_chain_app.png deleted file mode 100644 index 764fcd6e..00000000 Binary files a/loader/images/loader_device_chain_app.png and /dev/null differ diff --git a/loader/images/loader_device_chain_app_white.png b/loader/images/loader_device_chain_app_white.png deleted file mode 100644 index 8bd28ee0..00000000 Binary files a/loader/images/loader_device_chain_app_white.png and /dev/null differ diff --git a/loader/images/loader_device_chain_loader.png b/loader/images/loader_device_chain_loader.png deleted file mode 100644 index d226a3e9..00000000 Binary files a/loader/images/loader_device_chain_loader.png and /dev/null differ diff --git a/loader/images/loader_device_chain_loader_white.png b/loader/images/loader_device_chain_loader_white.png deleted file mode 100644 index 993a5551..00000000 Binary files a/loader/images/loader_device_chain_loader_white.png and /dev/null differ diff --git a/loader/images/loader_instance_chain.png b/loader/images/loader_instance_chain.png deleted file mode 100644 index 8bc06d09..00000000 Binary files a/loader/images/loader_instance_chain.png and /dev/null differ diff --git a/loader/images/loader_instance_chain_white.png b/loader/images/loader_instance_chain_white.png deleted file mode 100644 index 4c3c0664..00000000 Binary files a/loader/images/loader_instance_chain_white.png and /dev/null differ diff --git a/loader/images/loader_layer_order.png b/loader/images/loader_layer_order.png deleted file mode 100644 index 80b9ea4a..00000000 Binary files a/loader/images/loader_layer_order.png and /dev/null differ diff --git a/loader/images/loader_layer_order_white.png b/loader/images/loader_layer_order_white.png deleted file mode 100644 index ed25dc97..00000000 Binary files a/loader/images/loader_layer_order_white.png and /dev/null differ diff --git a/loader/loader.aps b/loader/loader.aps deleted file mode 100644 index 1ba7f211..00000000 Binary files a/loader/loader.aps and /dev/null differ diff --git a/loader/loader.c b/loader/loader.c deleted file mode 100644 index 3d3f9be3..00000000 --- a/loader/loader.c +++ /dev/null @@ -1,7055 +0,0 @@ -/* - * - * Copyright (c) 2014-2018 The Khronos Group Inc. - * Copyright (c) 2014-2018 Valve Corporation - * Copyright (c) 2014-2018 LunarG, Inc. - * Copyright (C) 2015 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: Jon Ashburn - * Author: Courtney Goeltzenleuchter - * Author: Mark Young - * Author: Lenny Komow - * - */ - -#define _GNU_SOURCE -#include -#include -#include -#include -#include -#include -#include -#if defined(__APPLE__) -#include -#include -#endif -#include -#if defined(_WIN32) -#include "dirent_on_windows.h" -#else // _WIN32 -#include -#endif // _WIN32 -#include "vk_loader_platform.h" -#include "loader.h" -#include "gpa_helper.h" -#include "debug_utils.h" -#include "wsi.h" -#include "vulkan/vk_icd.h" -#include "cJSON.h" -#include "murmurhash.h" - -#if defined(_WIN32) -#include -#include -#include -#endif - -// This is a CMake generated file with #defines for any functions/includes -// that it found present. This is currently necessary to properly determine -// if secure_getenv or __secure_getenv are present -#if !defined(VULKAN_NON_CMAKE_BUILD) -#include "loader_cmake_config.h" -#endif // !defined(VULKAN_NON_CMAKE_BUILD) - -// Generated file containing all the extension data -#include "vk_loader_extensions.c" - -struct loader_struct loader = {0}; -// TLS for instance for alloc/free callbacks -THREAD_LOCAL_DECL struct loader_instance *tls_instance; - -static size_t loader_platform_combine_path(char *dest, size_t len, ...); - -struct loader_phys_dev_per_icd { - uint32_t count; - VkPhysicalDevice *phys_devs; - struct loader_icd_term *this_icd_term; -}; - -enum loader_debug { - LOADER_INFO_BIT = 0x01, - LOADER_WARN_BIT = 0x02, - LOADER_PERF_BIT = 0x04, - LOADER_ERROR_BIT = 0x08, - LOADER_DEBUG_BIT = 0x10, -}; - -uint32_t g_loader_debug = 0; -uint32_t g_loader_log_msgs = 0; - -// thread safety lock for accessing global data structures such as "loader" -// all entrypoints on the instance chain need to be locked except GPA -// additionally CreateDevice and DestroyDevice needs to be locked -loader_platform_thread_mutex loader_lock; -loader_platform_thread_mutex loader_json_lock; - -LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init); - -// This loader supports Vulkan API version 1.1 -uint32_t loader_major_version = 1; -uint32_t loader_minor_version = 1; - -void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope alloc_scope) { - void *pMemory = NULL; -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (instance && instance->alloc_callbacks.pfnAllocation) { - // These are internal structures, so it's best to align everything to - // the largest unit size which is the size of a uint64_t. - pMemory = instance->alloc_callbacks.pfnAllocation(instance->alloc_callbacks.pUserData, size, sizeof(uint64_t), alloc_scope); - } else { -#endif - pMemory = malloc(size); - } - - return pMemory; -} - -void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory) { - if (pMemory != NULL) { -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (instance && instance->alloc_callbacks.pfnFree) { - instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMemory); - } else { -#endif - free(pMemory); - } - } -} - -void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size, - VkSystemAllocationScope alloc_scope) { - void *pNewMem = NULL; - if (pMemory == NULL || orig_size == 0) { - pNewMem = loader_instance_heap_alloc(instance, size, alloc_scope); - } else if (size == 0) { - loader_instance_heap_free(instance, pMemory); -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) -#else - } else if (instance && instance->alloc_callbacks.pfnReallocation) { - // These are internal structures, so it's best to align everything to - // the largest unit size which is the size of a uint64_t. - pNewMem = instance->alloc_callbacks.pfnReallocation(instance->alloc_callbacks.pUserData, pMemory, size, sizeof(uint64_t), - alloc_scope); -#endif - } else { - pNewMem = realloc(pMemory, size); - } - return pNewMem; -} - -void *loader_instance_tls_heap_alloc(size_t size) { - return loader_instance_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); -} - -void loader_instance_tls_heap_free(void *pMemory) { loader_instance_heap_free(tls_instance, pMemory); } - -void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope alloc_scope) { - void *pMemory = NULL; -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (device && device->alloc_callbacks.pfnAllocation) { - // These are internal structures, so it's best to align everything to - // the largest unit size which is the size of a uint64_t. - pMemory = device->alloc_callbacks.pfnAllocation(device->alloc_callbacks.pUserData, size, sizeof(uint64_t), alloc_scope); - } else { -#endif - pMemory = malloc(size); - } - return pMemory; -} - -void loader_device_heap_free(const struct loader_device *device, void *pMemory) { - if (pMemory != NULL) { -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (device && device->alloc_callbacks.pfnFree) { - device->alloc_callbacks.pfnFree(device->alloc_callbacks.pUserData, pMemory); - } else { -#endif - free(pMemory); - } - } -} - -void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size, - VkSystemAllocationScope alloc_scope) { - void *pNewMem = NULL; - if (pMemory == NULL || orig_size == 0) { - pNewMem = loader_device_heap_alloc(device, size, alloc_scope); - } else if (size == 0) { - loader_device_heap_free(device, pMemory); -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) -#else - } else if (device && device->alloc_callbacks.pfnReallocation) { - // These are internal structures, so it's best to align everything to - // the largest unit size which is the size of a uint64_t. - pNewMem = device->alloc_callbacks.pfnReallocation(device->alloc_callbacks.pUserData, pMemory, size, sizeof(uint64_t), - alloc_scope); -#endif - } else { - pNewMem = realloc(pMemory, size); - } - return pNewMem; -} - -// Environment variables -#if defined(__linux__) || defined(__APPLE__) - -static inline char *loader_getenv(const char *name, const struct loader_instance *inst) { - // No allocation of memory necessary for Linux, but we should at least touch - // the inst pointer to get rid of compiler warnings. - (void)inst; - return getenv(name); -} - -static inline char *loader_secure_getenv(const char *name, const struct loader_instance *inst) { -#if defined(__APPLE__) - // Apple does not appear to have a secure getenv implementation. - // The main difference between secure getenv and getenv is that secure getenv - // returns NULL if the process is being run with elevated privileges by a normal user. - // The idea is to prevent the reading of malicious environment variables by a process - // that can do damage. - // This algorithm is derived from glibc code that sets an internal - // variable (__libc_enable_secure) if the process is running under setuid or setgid. - return geteuid() != getuid() || getegid() != getgid() ? NULL : loader_getenv(name, inst); -#else -// Linux -#ifdef HAVE_SECURE_GETENV - (void)inst; - return secure_getenv(name); -#elif defined(HAVE___SECURE_GETENV) - (void)inst; - return __secure_getenv(name); -#else -#pragma message( \ - "Warning: Falling back to non-secure getenv for environmental lookups! Consider" \ - " updating to a different libc.") - return loader_getenv(name, inst); -#endif -#endif -} - -static inline void loader_free_getenv(char *val, const struct loader_instance *inst) { - // No freeing of memory necessary for Linux, but we should at least touch - // the val and inst pointers to get rid of compiler warnings. - (void)val; - (void)inst; -} - -#elif defined(WIN32) - -static inline char *loader_getenv(const char *name, const struct loader_instance *inst) { - char *retVal; - DWORD valSize; - - valSize = GetEnvironmentVariableA(name, NULL, 0); - - // valSize DOES include the null terminator, so for any set variable - // will always be at least 1. If it's 0, the variable wasn't set. - if (valSize == 0) return NULL; - - // Allocate the space necessary for the registry entry - if (NULL != inst && NULL != inst->alloc_callbacks.pfnAllocation) { - retVal = (char *)inst->alloc_callbacks.pfnAllocation(inst->alloc_callbacks.pUserData, valSize, sizeof(char *), - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); - } else { - retVal = (char *)malloc(valSize); - } - - if (NULL != retVal) { - GetEnvironmentVariableA(name, retVal, valSize); - } - - return retVal; -} - -static inline char *loader_secure_getenv(const char *name, const struct loader_instance *inst) { - // No secure version for Windows as far as I know - return loader_getenv(name, inst); -} - -static inline void loader_free_getenv(char *val, const struct loader_instance *inst) { - if (NULL != inst && NULL != inst->alloc_callbacks.pfnFree) { - inst->alloc_callbacks.pfnFree(inst->alloc_callbacks.pUserData, val); - } else { - free((void *)val); - } -} - -#else - -static inline char *loader_getenv(const char *name, const struct loader_instance *inst) { - // stub func - (void)inst; - (void)name; - return NULL; -} -static inline void loader_free_getenv(char *val, const struct loader_instance *inst) { - // stub func - (void)val; - (void)inst; -} - -#endif - -void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...) { - char msg[512]; - char cmd_line_msg[512]; - size_t cmd_line_size = sizeof(cmd_line_msg); - va_list ap; - int ret; - - va_start(ap, format); - ret = vsnprintf(msg, sizeof(msg), format, ap); - if ((ret >= (int)sizeof(msg)) || ret < 0) { - msg[sizeof(msg) - 1] = '\0'; - } - va_end(ap); - - if (inst) { - VkDebugUtilsMessageSeverityFlagBitsEXT severity = 0; - VkDebugUtilsMessageTypeFlagsEXT type; - VkDebugUtilsMessengerCallbackDataEXT callback_data; - VkDebugUtilsObjectNameInfoEXT object_name; - - if ((msg_type & LOADER_INFO_BIT) != 0) { - severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; - } else if ((msg_type & LOADER_WARN_BIT) != 0) { - severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - } else if ((msg_type & LOADER_ERROR_BIT) != 0) { - severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; - } else if ((msg_type & LOADER_DEBUG_BIT) != 0) { - severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; - } - - if ((msg_type & LOADER_PERF_BIT) != 0) { - type = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; - } else { - type = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT; - } - - callback_data.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; - callback_data.pNext = NULL; - callback_data.flags = 0; - callback_data.pMessageIdName = "Loader Message"; - callback_data.messageIdNumber = 0; - callback_data.pMessage = msg; - callback_data.queueLabelCount = 0; - callback_data.pQueueLabels = NULL; - callback_data.cmdBufLabelCount = 0; - callback_data.pCmdBufLabels = NULL; - callback_data.objectCount = 1; - callback_data.pObjects = &object_name; - object_name.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; - object_name.pNext = NULL; - object_name.objectType = VK_OBJECT_TYPE_INSTANCE; - object_name.objectHandle = (uint64_t)(uintptr_t)inst; - object_name.pObjectName = NULL; - - util_SubmitDebugUtilsMessageEXT(inst, severity, type, &callback_data); - } - - if (!(msg_type & g_loader_log_msgs)) { - return; - } - - cmd_line_msg[0] = '\0'; - cmd_line_size -= 1; - size_t original_size = cmd_line_size; - - va_start(ap, format); - if ((msg_type & LOADER_INFO_BIT) != 0) { - strncat(cmd_line_msg, "INFO", cmd_line_size); - cmd_line_size -= 4; - } - if ((msg_type & LOADER_WARN_BIT) != 0) { - if (cmd_line_size != original_size) { - strncat(cmd_line_msg, " | ", cmd_line_size); - cmd_line_size -= 3; - } - strncat(cmd_line_msg, "WARNING", cmd_line_size); - cmd_line_size -= 7; - } - if ((msg_type & LOADER_PERF_BIT) != 0) { - if (cmd_line_size != original_size) { - strncat(cmd_line_msg, " | ", cmd_line_size); - cmd_line_size -= 3; - } - strncat(cmd_line_msg, "PERF", cmd_line_size); - cmd_line_size -= 4; - } - if ((msg_type & LOADER_ERROR_BIT) != 0) { - if (cmd_line_size != original_size) { - strncat(cmd_line_msg, " | ", cmd_line_size); - cmd_line_size -= 3; - } - strncat(cmd_line_msg, "ERROR", cmd_line_size); - cmd_line_size -= 5; - } - if ((msg_type & LOADER_DEBUG_BIT) != 0) { - if (cmd_line_size != original_size) { - strncat(cmd_line_msg, " | ", cmd_line_size); - cmd_line_size -= 3; - } - strncat(cmd_line_msg, "DEBUG", cmd_line_size); - cmd_line_size -= 5; - } - if (cmd_line_size != original_size) { - strncat(cmd_line_msg, ": ", cmd_line_size); - cmd_line_size -= 2; - } - - if (0 < cmd_line_size) { - // If the message is too long, trim it down - if (strlen(msg) > cmd_line_size) { - msg[cmd_line_size - 1] = '\0'; - } - strncat(cmd_line_msg, msg, cmd_line_size); - } else { - // Shouldn't get here, but check to make sure if we've already overrun - // the string boundary - assert(false); - } - -#if defined(WIN32) - OutputDebugString(cmd_line_msg); - OutputDebugString("\n"); -#endif - - fputs(cmd_line_msg, stderr); - fputc('\n', stderr); -} - -VKAPI_ATTR VkResult VKAPI_CALL vkSetInstanceDispatch(VkInstance instance, void *object) { - struct loader_instance *inst = loader_get_instance(instance); - if (!inst) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkSetInstanceDispatch: Can not retrieve Instance " - "dispatch table."); - return VK_ERROR_INITIALIZATION_FAILED; - } - loader_set_dispatch(object, inst->disp); - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkSetDeviceDispatch(VkDevice device, void *object) { - struct loader_device *dev; - struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL); - - if (NULL == icd_term) { - return VK_ERROR_INITIALIZATION_FAILED; - } - loader_set_dispatch(object, &dev->loader_dispatch); - return VK_SUCCESS; -} - -#if defined(_WIN32) - -// Append the JSON path data to the list and allocate/grow the list if it's not large enough. -// Function returns true if filename was appended to reg_data list. -// Caller should free reg_data. -static bool loaderAddJsonEntry(const struct loader_instance *inst, - char **reg_data, // list of JSON files - PDWORD total_size, // size of reg_data - LPCTSTR key_name, // key name - used for debug prints - i.e. VulkanDriverName - DWORD key_type, // key data type - LPSTR json_path, // JSON string to add to the list reg_data - DWORD json_size, // size in bytes of json_path - VkResult *result) { - if (NULL == *reg_data) { - *reg_data = loader_instance_heap_alloc(inst, *total_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == *reg_data) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderAddJsonEntry: Failed to allocate space for registry data for key %s", json_path); - *result = VK_ERROR_OUT_OF_HOST_MEMORY; - return false; - } - *reg_data[0] = '\0'; - } else if (strlen(*reg_data) + json_size + 1 > *total_size) { - void *new_ptr = - loader_instance_heap_realloc(inst, *reg_data, *total_size, *total_size * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_ptr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderAddJsonEntry: Failed to reallocate space for registry value of size %d for key %s", *total_size * 2, - json_path); - *result = VK_ERROR_OUT_OF_HOST_MEMORY; - return false; - } - *reg_data = new_ptr; - *total_size *= 2; - } - - for (char *curr_filename = json_path; curr_filename[0] != '\0'; curr_filename += strlen(curr_filename) + 1) { - if (strlen(*reg_data) == 0) { - (void)snprintf(*reg_data, json_size + 1, "%s", curr_filename); - } else { - (void)snprintf(*reg_data + strlen(*reg_data), json_size + 2, "%c%s", PATH_SEPARATOR, curr_filename); - } - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "%s: Located json file \"%s\" from PnP registry: %s", __FUNCTION__, - curr_filename, key_name); - - if (key_type == REG_SZ) { - break; - } - } - return true; -} - -// Find the list of registry files (names VulkanDriverName/VulkanDriverNameWow) in hkr. -// -// This function looks for filename in given device handle, filename is then added to return list -// function return true if filename was appended to reg_data list -// If error occures result is updated with failure reason -bool loaderGetDeviceRegistryEntry(const struct loader_instance *inst, char **reg_data, PDWORD total_size, DEVINST dev_id, LPCTSTR value_name, VkResult *result) -{ - HKEY hkrKey = INVALID_HANDLE_VALUE; - DWORD requiredSize, data_type; - char *manifest_path = NULL; - bool found = false; - - if (NULL == total_size || NULL == reg_data) { - *result = VK_ERROR_INITIALIZATION_FAILED; - return false; - } - - CONFIGRET status = CM_Open_DevNode_Key(dev_id, KEY_QUERY_VALUE, 0, RegDisposition_OpenExisting, &hkrKey, CM_REGISTRY_SOFTWARE); - if (status != CR_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loaderGetDeviceRegistryEntry: Failed to open registry key for DeviceID(%d)", dev_id); - *result = VK_ERROR_INITIALIZATION_FAILED; - return false; - } - - // query value - LSTATUS ret = RegQueryValueEx( - hkrKey, - value_name, - NULL, - NULL, - NULL, - &requiredSize); - - if (ret != ERROR_SUCCESS) { - if (ret == ERROR_FILE_NOT_FOUND) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "loaderGetDeviceRegistryEntry: Device ID(%d) Does not contain a value for \"%s\"", dev_id, value_name); - } else { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "loaderGetDeviceRegistryEntry: DeviceID(%d) Failed to obtain %s size", dev_id, value_name); - } - goto out; - } - - manifest_path = loader_instance_heap_alloc(inst, requiredSize, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (manifest_path == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetDeviceRegistryEntry: Failed to allocate space for DriverName."); - *result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - ret = RegQueryValueEx( - hkrKey, - value_name, - NULL, - &data_type, - (BYTE *)manifest_path, - &requiredSize - ); - - if (ret != ERROR_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetDeviceRegistryEntry: DeviceID(%d) Failed to obtain %s", value_name); - - *result = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - if (data_type != REG_SZ && data_type != REG_MULTI_SZ) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetDeviceRegistryEntry: Invalid %s data type. Expected REG_SZ or REG_MULTI_SZ.", value_name); - *result = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - found = loaderAddJsonEntry(inst, reg_data, total_size, value_name, data_type, manifest_path, requiredSize, result); - -out: - if (manifest_path != NULL) { - loader_instance_heap_free(inst, manifest_path); - } - RegCloseKey(hkrKey); - return found; -} - -// Find the list of registry files (names VulkanDriverName/VulkanDriverNameWow) in hkr . -// -// This function looks for display devices and childish software components -// for a list of files which are added to a returned list (function return -// value). -// Function return is a string with a ';' separated list of filenames. -// Function return is NULL if no valid name/value pairs are found in the key, -// or the key is not found. -// -// *reg_data contains a string list of filenames as pointer. -// When done using the returned string list, the caller should free the pointer. -VkResult loaderGetDeviceRegistryFiles(const struct loader_instance *inst, char **reg_data, PDWORD reg_data_size, LPCTSTR value_name) { - static const wchar_t *softwareComponentGUID = L"{5c4c3332-344d-483c-8739-259e934c9cc8}"; - static const wchar_t *displayGUID = L"{4d36e968-e325-11ce-bfc1-08002be10318}"; - const ULONG flags = CM_GETIDLIST_FILTER_CLASS | CM_GETIDLIST_FILTER_PRESENT; - - wchar_t childGuid[MAX_GUID_STRING_LEN + 2]; // +2 for brackets {} - ULONG childGuidSize = sizeof(childGuid); - - DEVINST devID = 0, childID = 0; - wchar_t *pDeviceNames = NULL; - ULONG deviceNamesSize = 0; - VkResult result = VK_SUCCESS; - bool found = false; - - if (NULL == reg_data) { - result = VK_ERROR_INITIALIZATION_FAILED; - return result; - } - - // if after obtaining the DeviceNameSize, new device is added start over - do { - CM_Get_Device_ID_List_SizeW(&deviceNamesSize, displayGUID, flags); - - if (pDeviceNames != NULL) { - loader_instance_heap_free(inst, pDeviceNames); - } - - pDeviceNames = loader_instance_heap_alloc(inst, deviceNamesSize * sizeof(wchar_t), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (pDeviceNames == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetDeviceRegistryFiles: Failed to allocate space for display device names."); - result = VK_ERROR_OUT_OF_HOST_MEMORY; - return result; - } - } while (CM_Get_Device_ID_ListW(displayGUID, pDeviceNames, deviceNamesSize, flags) == CR_BUFFER_SMALL); - - if (pDeviceNames) { - for (wchar_t *deviceName = pDeviceNames; *deviceName; deviceName += wcslen(deviceName) + 1) { - CONFIGRET status = CM_Locate_DevNodeW(&devID, deviceName, CM_LOCATE_DEVNODE_NORMAL); - if (CR_SUCCESS != status) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loaderGetDeviceRegistryFiles: failed to open DevNode %s", - deviceName); - continue; - } - ULONG ulStatus, ulProblem; - status = CM_Get_DevNode_Status(&ulStatus, &ulProblem, devID, 0); - - if (CR_SUCCESS != status) - { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loaderGetDeviceRegistryFiles: failed to probe device status %s", - deviceName); - continue; - } - if ((ulStatus & DN_HAS_PROBLEM) && (ulProblem == CM_PROB_NEED_RESTART || ulProblem == DN_NEED_RESTART)) - { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "loaderGetDeviceRegistryFiles: device %s is pending reboot, skipping ...", deviceName); - continue; - } - - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "loaderGetDeviceRegistryFiles: opening device %s", deviceName); - - if (loaderGetDeviceRegistryEntry(inst, reg_data, reg_data_size, devID, value_name, &result)) { - found = true; - continue; - } - else if (result == VK_ERROR_OUT_OF_HOST_MEMORY) { - break; - } - - status = CM_Get_Child(&childID, devID, 0); - if (status != CR_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "loaderGetDeviceRegistryFiles: unable to open child-device error:%d", status); - continue; - } - - do { - wchar_t buffer[MAX_DEVICE_ID_LEN]; - CM_Get_Device_IDW(childID, buffer, MAX_DEVICE_ID_LEN, 0); - - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "loaderGetDeviceRegistryFiles: Opening child device %d - %s", childID, buffer); - - status = CM_Get_DevNode_Registry_PropertyW(childID, CM_DRP_CLASSGUID, NULL, &childGuid, &childGuidSize, 0); - if (status != CR_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetDeviceRegistryFiles: unable to obtain GUID for:%d error:%d", childID, status); - - result = VK_ERROR_INITIALIZATION_FAILED; - continue; - } - - if (wcscmp(childGuid, softwareComponentGUID) != 0) { - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, - "loaderGetDeviceRegistryFiles: GUID for %d is not SoftwareComponent skipping", childID); - continue; - } - - if (loaderGetDeviceRegistryEntry(inst, reg_data, reg_data_size, childID, value_name, &result)) { - found = true; - break; // check next-display-device - } - - } while (CM_Get_Sibling(&childID, childID, 0) == CR_SUCCESS); - } - - loader_instance_heap_free(inst, pDeviceNames); - } - - if (!found && result != VK_ERROR_OUT_OF_HOST_MEMORY) { - result = VK_ERROR_INITIALIZATION_FAILED; - } - - return result; -} - -static char *loader_get_next_path(char *path); - -// Find the list of registry files (names within a key) in key "location". -// -// This function looks in the registry (hive = DEFAULT_VK_REGISTRY_HIVE) key as -// given in "location" -// for a list or name/values which are added to a returned list (function return -// value). -// The DWORD values within the key must be 0 or they are skipped. -// Function return is a string with a ';' separated list of filenames. -// Function return is NULL if no valid name/value pairs are found in the key, -// or the key is not found. -// -// *reg_data contains a string list of filenames as pointer. -// When done using the returned string list, the caller should free the pointer. -VkResult loaderGetRegistryFiles(const struct loader_instance *inst, char *location, bool use_secondary_hive, char **reg_data, PDWORD reg_data_size) { - LONG rtn_value; - HKEY hive = DEFAULT_VK_REGISTRY_HIVE, key; - DWORD access_flags; - char name[2048]; - char *loc = location; - char *next; - DWORD idx; - DWORD name_size = sizeof(name); - DWORD value; - DWORD value_size = sizeof(value); - VkResult result = VK_SUCCESS; - bool found = false; - - if (NULL == reg_data) { - result = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - while (*loc) { - next = loader_get_next_path(loc); - access_flags = KEY_QUERY_VALUE; - rtn_value = RegOpenKeyEx(hive, loc, 0, access_flags, &key); - if (ERROR_SUCCESS == rtn_value) { - idx = 0; - while ((rtn_value = RegEnumValue(key, idx++, name, &name_size, NULL, NULL, (LPBYTE)&value, &value_size)) == - ERROR_SUCCESS) { - if (value_size == sizeof(value) && value == 0) { - if (NULL == *reg_data) { - *reg_data = loader_instance_heap_alloc(inst, *reg_data_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == *reg_data) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetRegistryFiles: Failed to allocate space for registry data for key %s", name); - RegCloseKey(key); - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - *reg_data[0] = '\0'; - } else if (strlen(*reg_data) + name_size + 1 > *reg_data_size) { - void *new_ptr = loader_instance_heap_realloc(inst, *reg_data, *reg_data_size, *reg_data_size * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_ptr) { - loader_log( - inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetRegistryFiles: Failed to reallocate space for registry value of size %d for key %s", - *reg_data_size * 2, name); - RegCloseKey(key); - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - *reg_data = new_ptr; - *reg_data_size *= 2; - } - loader_log( - inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Located json file \"%s\" from registry \"%s\\%s\"", name, - hive == DEFAULT_VK_REGISTRY_HIVE ? DEFAULT_VK_REGISTRY_HIVE_STR : SECONDARY_VK_REGISTRY_HIVE_STR, location); - if (strlen(*reg_data) == 0) { - // The list is emtpy. Add the first entry. - (void)snprintf(*reg_data, name_size + 1, "%s", name); - found = true; - } else { - // At this point the reg_data variable contains other JSON paths, likely from the PNP/device section - // of the registry that we want to have precendence over this non-device specific section of the registry. - // To make sure we avoid enumerating old JSON files/drivers that might be present in the non-device specific - // area of the registry when a newer device specific JSON file is present, do a check before adding. - // Find the file name, without path, of the JSON file found in the non-device specific registry location. - // If the same JSON file name is already found in the list, don't add it again. - bool foundDuplicate = false; - char *pLastSlashName = strrchr(name, '\\'); - if (pLastSlashName != NULL) { - char *foundMatch = strstr(*reg_data, pLastSlashName + 1); - if (foundMatch != NULL) { - foundDuplicate = true; - } - } - - if (foundDuplicate == false) { - // Add the new entry to the list. - (void)snprintf(*reg_data + strlen(*reg_data), name_size + 2, "%c%s", PATH_SEPARATOR, name); - found = true; - } else { - loader_log( - inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "Skipping adding of json file \"%s\" from registry \"%s\\%s\" to the list due to duplication", name, - hive == DEFAULT_VK_REGISTRY_HIVE ? DEFAULT_VK_REGISTRY_HIVE_STR : SECONDARY_VK_REGISTRY_HIVE_STR, - location); - } - } - } - name_size = 2048; - } - RegCloseKey(key); - } - - // Advance the location - if the next location is in the secondary hive, then reset the locations and advance the hive - if (use_secondary_hive && (hive == DEFAULT_VK_REGISTRY_HIVE) && (*next == '\0')) { - loc = location; - hive = SECONDARY_VK_REGISTRY_HIVE; - } else { - loc = next; - } - } - - if (!found && result != VK_ERROR_OUT_OF_HOST_MEMORY) { - result = VK_ERROR_INITIALIZATION_FAILED; - } - -out: - - return result; -} - -#endif // WIN32 - -// Combine path elements, separating each element with the platform-specific -// directory separator, and save the combined string to a destination buffer, -// not exceeding the given length. Path elements are given as variable args, -// with a NULL element terminating the list. -// -// \returns the total length of the combined string, not including an ASCII -// NUL termination character. This length may exceed the available storage: -// in this case, the written string will be truncated to avoid a buffer -// overrun, and the return value will greater than or equal to the storage -// size. A NULL argument may be provided as the destination buffer in order -// to determine the required string length without actually writing a string. -static size_t loader_platform_combine_path(char *dest, size_t len, ...) { - size_t required_len = 0; - va_list ap; - const char *component; - - va_start(ap, len); - - while ((component = va_arg(ap, const char *))) { - if (required_len > 0) { - // This path element is not the first non-empty element; prepend - // a directory separator if space allows - if (dest && required_len + 1 < len) { - (void)snprintf(dest + required_len, len - required_len, "%c", DIRECTORY_SYMBOL); - } - required_len++; - } - - if (dest && required_len < len) { - strncpy(dest + required_len, component, len - required_len); - } - required_len += strlen(component); - } - - va_end(ap); - - // strncpy(3) won't add a NUL terminating byte in the event of truncation. - if (dest && required_len >= len) { - dest[len - 1] = '\0'; - } - - return required_len; -} - -// Given string of three part form "maj.min.pat" convert to a vulkan version number. -static uint32_t loader_make_version(char *vers_str) { - uint32_t vers = 0, major = 0, minor = 0, patch = 0; - char *vers_tok; - - if (!vers_str) { - return vers; - } - - vers_tok = strtok(vers_str, ".\"\n\r"); - if (NULL != vers_tok) { - major = (uint16_t)atoi(vers_tok); - vers_tok = strtok(NULL, ".\"\n\r"); - if (NULL != vers_tok) { - minor = (uint16_t)atoi(vers_tok); - vers_tok = strtok(NULL, ".\"\n\r"); - if (NULL != vers_tok) { - patch = (uint16_t)atoi(vers_tok); - } - } - } - - return VK_MAKE_VERSION(major, minor, patch); -} - -bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2) { - return strcmp(op1->extensionName, op2->extensionName) == 0 ? true : false; -} - -// Search the given ext_array for an extension matching the given vk_ext_prop -bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count, - const VkExtensionProperties *ext_array) { - for (uint32_t i = 0; i < count; i++) { - if (compare_vk_extension_properties(vk_ext_prop, &ext_array[i])) return true; - } - return false; -} - -// Search the given ext_list for an extension matching the given vk_ext_prop -bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list) { - for (uint32_t i = 0; i < ext_list->count; i++) { - if (compare_vk_extension_properties(&ext_list->list[i], vk_ext_prop)) return true; - } - return false; -} - -// Search the given ext_list for a device extension matching the given ext_prop -bool has_vk_dev_ext_property(const VkExtensionProperties *ext_prop, const struct loader_device_extension_list *ext_list) { - for (uint32_t i = 0; i < ext_list->count; i++) { - if (compare_vk_extension_properties(&ext_list->list[i].props, ext_prop)) return true; - } - return false; -} - -// Search the given layer list for a layer matching the given layer name -static struct loader_layer_properties *loader_get_layer_property(const char *name, const struct loader_layer_list *layer_list) { - for (uint32_t i = 0; i < layer_list->count; i++) { - const VkLayerProperties *item = &layer_list->list[i].info; - if (strcmp(name, item->layerName) == 0) return &layer_list->list[i]; - } - return NULL; -} - -// Get the next unused layer property in the list. Init the property to zero. -static struct loader_layer_properties *loader_get_next_layer_property(const struct loader_instance *inst, - struct loader_layer_list *layer_list) { - if (layer_list->capacity == 0) { - layer_list->list = - loader_instance_heap_alloc(inst, sizeof(struct loader_layer_properties) * 64, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (layer_list->list == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_next_layer_property: Out of memory can " - "not add any layer properties to list"); - return NULL; - } - memset(layer_list->list, 0, sizeof(struct loader_layer_properties) * 64); - layer_list->capacity = sizeof(struct loader_layer_properties) * 64; - } - - // Ensure enough room to add an entry - if ((layer_list->count + 1) * sizeof(struct loader_layer_properties) > layer_list->capacity) { - void *new_ptr = loader_instance_heap_realloc(inst, layer_list->list, layer_list->capacity, layer_list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_ptr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_next_layer_property: realloc failed for layer list"); - return NULL; - } - layer_list->list = new_ptr; - layer_list->capacity *= 2; - } - - layer_list->count++; - return &(layer_list->list[layer_list->count - 1]); -} - -// Remove all layer properties entries from the list -void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list) { - uint32_t i, j, k; - struct loader_device_extension_list *dev_ext_list; - struct loader_dev_ext_props *ext_props; - if (!layer_list) return; - - for (i = 0; i < layer_list->count; i++) { - if (NULL != layer_list->list[i].component_layer_names) { - loader_instance_heap_free(inst, layer_list->list[i].component_layer_names); - layer_list->list[i].component_layer_names = NULL; - } - loader_destroy_generic_list(inst, (struct loader_generic_list *)&layer_list->list[i].instance_extension_list); - dev_ext_list = &layer_list->list[i].device_extension_list; - if (dev_ext_list->capacity > 0 && NULL != dev_ext_list->list) { - for (j = 0; j < dev_ext_list->count; j++) { - ext_props = &dev_ext_list->list[j]; - if (ext_props->entrypoint_count > 0) { - for (k = 0; k < ext_props->entrypoint_count; k++) { - loader_instance_heap_free(inst, ext_props->entrypoints[k]); - } - loader_instance_heap_free(inst, ext_props->entrypoints); - } - } - } - loader_destroy_generic_list(inst, (struct loader_generic_list *)dev_ext_list); - } - layer_list->count = 0; - - if (layer_list->capacity > 0) { - layer_list->capacity = 0; - loader_instance_heap_free(inst, layer_list->list); - } -} - -static VkResult loader_add_instance_extensions(const struct loader_instance *inst, - const PFN_vkEnumerateInstanceExtensionProperties fp_get_props, const char *lib_name, - struct loader_extension_list *ext_list) { - uint32_t i, count = 0; - VkExtensionProperties *ext_props; - VkResult res = VK_SUCCESS; - - if (!fp_get_props) { - // No EnumerateInstanceExtensionProperties defined - goto out; - } - - res = fp_get_props(NULL, &count, NULL); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_instance_extensions: Error getting Instance " - "extension count from %s", - lib_name); - goto out; - } - - if (count == 0) { - // No ExtensionProperties to report - goto out; - } - - ext_props = loader_stack_alloc(count * sizeof(VkExtensionProperties)); - if (NULL == ext_props) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - res = fp_get_props(NULL, &count, ext_props); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_instance_extensions: Error getting Instance " - "extensions from %s", - lib_name); - goto out; - } - - for (i = 0; i < count; i++) { - char spec_version[64]; - - bool ext_unsupported = wsi_unsupported_instance_extension(&ext_props[i]); - if (!ext_unsupported) { - (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion), - VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion)); - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Instance Extension: %s (%s) version %s", ext_props[i].extensionName, - lib_name, spec_version); - - res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_instance_extensions: Failed to add %s " - "to Instance extension list", - lib_name); - goto out; - } - } - } - -out: - return res; -} - -// Initialize ext_list with the physical device extensions. -// The extension properties are passed as inputs in count and ext_props. -static VkResult loader_init_device_extensions(const struct loader_instance *inst, struct loader_physical_device_term *phys_dev_term, - uint32_t count, VkExtensionProperties *ext_props, - struct loader_extension_list *ext_list) { - VkResult res; - uint32_t i; - - res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(VkExtensionProperties)); - if (VK_SUCCESS != res) { - return res; - } - - for (i = 0; i < count; i++) { - char spec_version[64]; - (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion), - VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion)); - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName, - phys_dev_term->this_icd_term->scanned_icd->lib_name, spec_version); - res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); - if (res != VK_SUCCESS) return res; - } - - return VK_SUCCESS; -} - -VkResult loader_add_device_extensions(const struct loader_instance *inst, - PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties, - VkPhysicalDevice physical_device, const char *lib_name, - struct loader_extension_list *ext_list) { - uint32_t i, count; - VkResult res; - VkExtensionProperties *ext_props; - - res = fpEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL); - if (res == VK_SUCCESS && count > 0) { - ext_props = loader_stack_alloc(count * sizeof(VkExtensionProperties)); - if (!ext_props) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_device_extensions: Failed to allocate space" - " for device extension properties."); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - res = fpEnumerateDeviceExtensionProperties(physical_device, NULL, &count, ext_props); - if (res != VK_SUCCESS) { - return res; - } - for (i = 0; i < count; i++) { - char spec_version[64]; - (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion), - VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion)); - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName, - lib_name, spec_version); - res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); - if (res != VK_SUCCESS) { - return res; - } - } - } else { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_device_extensions: Error getting physical " - "device extension info count from library %s", - lib_name); - return res; - } - - return VK_SUCCESS; -} - -VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size) { - size_t capacity = 32 * element_size; - list_info->count = 0; - list_info->capacity = 0; - list_info->list = loader_instance_heap_alloc(inst, capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (list_info->list == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_init_generic_list: Failed to allocate space " - "for generic list"); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memset(list_info->list, 0, capacity); - list_info->capacity = capacity; - return VK_SUCCESS; -} - -void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list) { - loader_instance_heap_free(inst, list->list); - list->count = 0; - list->capacity = 0; -} - -// Append non-duplicate extension properties defined in props to the given ext_list. -// Return - Vk_SUCCESS on success -VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list, - uint32_t prop_list_count, const VkExtensionProperties *props) { - uint32_t i; - const VkExtensionProperties *cur_ext; - - if (ext_list->list == NULL || ext_list->capacity == 0) { - VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(VkExtensionProperties)); - if (VK_SUCCESS != res) { - return res; - } - } - - for (i = 0; i < prop_list_count; i++) { - cur_ext = &props[i]; - - // look for duplicates - if (has_vk_extension_property(cur_ext, ext_list)) { - continue; - } - - // add to list at end - // check for enough capacity - if (ext_list->count * sizeof(VkExtensionProperties) >= ext_list->capacity) { - void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (new_ptr == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_ext_list: Failed to reallocate " - "space for extension list"); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - ext_list->list = new_ptr; - - // double capacity - ext_list->capacity *= 2; - } - - memcpy(&ext_list->list[ext_list->count], cur_ext, sizeof(VkExtensionProperties)); - ext_list->count++; - } - return VK_SUCCESS; -} - -// Append one extension property defined in props with entrypoints defined in entries to the given -// ext_list. Do not append if a duplicate. -// Return - Vk_SUCCESS on success -VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list, - const VkExtensionProperties *props, uint32_t entry_count, char **entrys) { - uint32_t idx; - if (ext_list->list == NULL || ext_list->capacity == 0) { - VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(struct loader_dev_ext_props)); - if (VK_SUCCESS != res) { - return res; - } - } - - // look for duplicates - if (has_vk_dev_ext_property(props, ext_list)) { - return VK_SUCCESS; - } - - idx = ext_list->count; - // add to list at end - // check for enough capacity - if (idx * sizeof(struct loader_dev_ext_props) >= ext_list->capacity) { - void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - - if (NULL == new_ptr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_dev_ext_list: Failed to reallocate space for device extension list"); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - ext_list->list = new_ptr; - - // double capacity - ext_list->capacity *= 2; - } - - memcpy(&ext_list->list[idx].props, props, sizeof(*props)); - ext_list->list[idx].entrypoint_count = entry_count; - if (entry_count == 0) { - ext_list->list[idx].entrypoints = NULL; - } else { - ext_list->list[idx].entrypoints = - loader_instance_heap_alloc(inst, sizeof(char *) * entry_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (ext_list->list[idx].entrypoints == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_dev_ext_list: Failed to allocate space " - "for device extension entrypoint list in list %d", - idx); - ext_list->list[idx].entrypoint_count = 0; - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - for (uint32_t i = 0; i < entry_count; i++) { - ext_list->list[idx].entrypoints[i] = - loader_instance_heap_alloc(inst, strlen(entrys[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (ext_list->list[idx].entrypoints[i] == NULL) { - for (uint32_t j = 0; j < i; j++) { - loader_instance_heap_free(inst, ext_list->list[idx].entrypoints[j]); - } - loader_instance_heap_free(inst, ext_list->list[idx].entrypoints); - ext_list->list[idx].entrypoint_count = 0; - ext_list->list[idx].entrypoints = NULL; - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_dev_ext_list: Failed to allocate space " - "for device extension entrypoint %d name", - i); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - strcpy(ext_list->list[idx].entrypoints[i], entrys[i]); - } - } - ext_list->count++; - - return VK_SUCCESS; -} - -// Prototype of loader_add_meta_layer function since we use it in the loader_add_implicit_layer, but can also -// call loader_add_implicit_layer from loader_add_meta_layer. -bool loader_add_meta_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop, - struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, - const struct loader_layer_list *source_list); - -// Search the given layer list for a list matching the given VkLayerProperties -bool has_vk_layer_property(const VkLayerProperties *vk_layer_prop, const struct loader_layer_list *list) { - for (uint32_t i = 0; i < list->count; i++) { - if (strcmp(vk_layer_prop->layerName, list->list[i].info.layerName) == 0) return true; - } - return false; -} - -// Search the given layer list for a layer matching the given name -bool has_layer_name(const char *name, const struct loader_layer_list *list) { - for (uint32_t i = 0; i < list->count; i++) { - if (strcmp(name, list->list[i].info.layerName) == 0) return true; - } - return false; -} - -// Search the given search_list for any layers in the props list. Add these to the -// output layer_list. Don't add duplicates to the output layer_list. -static VkResult loader_add_layer_names_to_list(const struct loader_instance *inst, struct loader_layer_list *output_list, - struct loader_layer_list *expanded_output_list, uint32_t name_count, - const char *const *names, const struct loader_layer_list *source_list) { - struct loader_layer_properties *layer_prop; - VkResult err = VK_SUCCESS; - - for (uint32_t i = 0; i < name_count; i++) { - const char *source_name = names[i]; - layer_prop = loader_get_layer_property(source_name, source_list); - if (NULL == layer_prop) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_layer_names_to_list: Unable to find layer" - " %s", - source_name); - err = VK_ERROR_LAYER_NOT_PRESENT; - continue; - } - - // If not a meta-layer, simply add it. - if (0 == (layer_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) { - if (!has_vk_layer_property(&layer_prop->info, output_list)) { - loader_add_to_layer_list(inst, output_list, 1, layer_prop); - } - if (!has_vk_layer_property(&layer_prop->info, expanded_output_list)) { - loader_add_to_layer_list(inst, expanded_output_list, 1, layer_prop); - } - } else { - if (!has_vk_layer_property(&layer_prop->info, output_list) || - !has_vk_layer_property(&layer_prop->info, expanded_output_list)) { - loader_add_meta_layer(inst, layer_prop, output_list, expanded_output_list, source_list); - } - } - } - - return err; -} - -// Manage lists of VkLayerProperties -static bool loader_init_layer_list(const struct loader_instance *inst, struct loader_layer_list *list) { - list->capacity = 32 * sizeof(struct loader_layer_properties); - list->list = loader_instance_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (list->list == NULL) { - return false; - } - memset(list->list, 0, list->capacity); - list->count = 0; - return true; -} - -void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device, - struct loader_layer_list *layer_list) { - if (device) { - loader_device_heap_free(device, layer_list->list); - } else { - loader_instance_heap_free(inst, layer_list->list); - } - layer_list->count = 0; - layer_list->capacity = 0; -} - -// Append non-duplicate layer properties defined in prop_list to the given layer_info list -VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count, - const struct loader_layer_properties *props) { - uint32_t i; - struct loader_layer_properties *layer; - - if (list->list == NULL || list->capacity == 0) { - loader_init_layer_list(inst, list); - } - - if (list->list == NULL) return VK_SUCCESS; - - for (i = 0; i < prop_list_count; i++) { - layer = (struct loader_layer_properties *)&props[i]; - - // Look for duplicates, and skip - if (has_vk_layer_property(&layer->info, list)) { - continue; - } - - // Check for enough capacity - if (((list->count + 1) * sizeof(struct loader_layer_properties)) >= list->capacity) { - size_t new_capacity = list->capacity * 2; - void *new_ptr = - loader_instance_heap_realloc(inst, list->list, list->capacity, new_capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_ptr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_layer_list: Realloc failed for when attempting to add new layer"); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - list->list = new_ptr; - list->capacity = new_capacity; - } - - memcpy(&list->list[list->count], layer, sizeof(struct loader_layer_properties)); - list->count++; - } - - return VK_SUCCESS; -} - -// Check the individual implicit layer for the enable/disable environment variable settings. Only add it after -// every check has passed indicating it should be used. -static void loader_add_implicit_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop, - struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, - const struct loader_layer_list *source_list) { - bool enable = loader_is_implicit_layer_enabled(inst, prop); - - // If the implicit layer is supposed to be enable, make sure the layer supports at least the same API version - // that the application is asking (i.e. layer's API >= app's API). If it's not, disable this layer. - if (enable) { - uint16_t layer_api_major_version = VK_VERSION_MAJOR(prop->info.specVersion); - uint16_t layer_api_minor_version = VK_VERSION_MINOR(prop->info.specVersion); - if (inst->app_api_major_version > layer_api_major_version || - (inst->app_api_major_version == layer_api_major_version && inst->app_api_minor_version > layer_api_minor_version)) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "loader_add_implicit_layer: Disabling implicit layer %s for using an old API version %d.%d versus " - "application requested %d.%d", - prop->info.layerName, layer_api_major_version, layer_api_minor_version, inst->app_api_major_version, - inst->app_api_minor_version); - enable = false; - } - } - - if (enable) { - if (0 == (prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) { - if (NULL != target_list && !has_vk_layer_property(&prop->info, target_list)) { - loader_add_to_layer_list(inst, target_list, 1, prop); - } - if (NULL != expanded_target_list && !has_vk_layer_property(&prop->info, expanded_target_list)) { - loader_add_to_layer_list(inst, expanded_target_list, 1, prop); - } - } else { - if (!has_vk_layer_property(&prop->info, target_list) || - (NULL != expanded_target_list && !has_vk_layer_property(&prop->info, expanded_target_list))) { - loader_add_meta_layer(inst, prop, target_list, expanded_target_list, source_list); - } - } - } -} - -// Add the component layers of a meta-layer to the active list of layers -bool loader_add_meta_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop, - struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, - const struct loader_layer_list *source_list) { - bool found = true; - - // We need to add all the individual component layers - for (uint32_t comp_layer = 0; comp_layer < prop->num_component_layers; comp_layer++) { - bool found_comp = false; - const struct loader_layer_properties *search_prop = - loader_get_layer_property(prop->component_layer_names[comp_layer], source_list); - if (search_prop != NULL) { - found_comp = true; - - // If the component layer is itself an implicit layer, we need to do the implicit layer enable - // checks - if (0 == (search_prop->type_flags & VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER)) { - loader_add_implicit_layer(inst, search_prop, target_list, expanded_target_list, source_list); - } else { - if (NULL != expanded_target_list && !has_vk_layer_property(&search_prop->info, expanded_target_list)) { - loader_add_to_layer_list(inst, expanded_target_list, 1, search_prop); - } - } - } - if (!found_comp) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_add_meta_layer: Failed to find layer name %s component layer " - "%s to activate", - search_prop->info.layerName, prop->component_layer_names[comp_layer]); - found = false; - } - } - - // Add this layer to the overall target list (not the expanded one) - if (found && !has_vk_layer_property(&prop->info, target_list)) { - loader_add_to_layer_list(inst, target_list, 1, prop); - } - - return found; -} - -// Search the source_list for any layer with a name that matches the given name and a type -// that matches the given type. Add all matching layers to the target_list. -// Do not add if found loader_layer_properties is already on the target_list. -void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags, - const struct loader_layer_list *source_list, struct loader_layer_list *target_list, - struct loader_layer_list *expanded_target_list) { - bool found = false; - for (uint32_t i = 0; i < source_list->count; i++) { - struct loader_layer_properties *source_prop = &source_list->list[i]; - if (0 == strcmp(source_prop->info.layerName, name) && (source_prop->type_flags & type_flags) == type_flags) { - // If not a meta-layer, simply add it. - if (0 == (source_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) { - if (NULL != target_list && !has_vk_layer_property(&source_prop->info, target_list) && - VK_SUCCESS == loader_add_to_layer_list(inst, target_list, 1, source_prop)) { - found = true; - } - if (NULL != expanded_target_list && !has_vk_layer_property(&source_prop->info, expanded_target_list) && - VK_SUCCESS == loader_add_to_layer_list(inst, expanded_target_list, 1, source_prop)) { - found = true; - } - } else { - found = loader_add_meta_layer(inst, source_prop, target_list, expanded_target_list, source_list); - } - } - } - if (!found) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_find_layer_name_add_list: Failed to find layer name %s to activate", name); - } -} - -static VkExtensionProperties *get_extension_property(const char *name, const struct loader_extension_list *list) { - for (uint32_t i = 0; i < list->count; i++) { - if (strcmp(name, list->list[i].extensionName) == 0) return &list->list[i]; - } - return NULL; -} - -static VkExtensionProperties *get_dev_extension_property(const char *name, const struct loader_device_extension_list *list) { - for (uint32_t i = 0; i < list->count; i++) { - if (strcmp(name, list->list[i].props.extensionName) == 0) return &list->list[i].props; - } - return NULL; -} - -// For Instance extensions implemented within the loader (i.e. DEBUG_REPORT -// the extension must provide two entry points for the loader to use: -// - "trampoline" entry point - this is the address returned by GetProcAddr -// and will always do what's necessary to support a -// global call. -// - "terminator" function - this function will be put at the end of the -// instance chain and will contain the necessary logic -// to call / process the extension for the appropriate -// ICDs that are available. -// There is no generic mechanism for including these functions, the references -// must be placed into the appropriate loader entry points. -// GetInstanceProcAddr: call extension GetInstanceProcAddr to check for GetProcAddr -// requests -// loader_coalesce_extensions(void) - add extension records to the list of global -// extension available to the app. -// instance_disp - add function pointer for terminator function -// to this array. -// The extension itself should be in a separate file that will be linked directly -// with the loader. -VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list, - struct loader_extension_list *inst_exts) { - struct loader_extension_list icd_exts; - VkResult res = VK_SUCCESS; - char *env_value; - bool filter_extensions = true; - - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Build ICD instance extension list"); - - // Check if a user wants to disable the instance extension filtering behavior - env_value = loader_getenv("VK_LOADER_DISABLE_INST_EXT_FILTER", inst); - if (NULL != env_value && atoi(env_value) != 0) { - filter_extensions = false; - } - loader_free_getenv(env_value, inst); - - // traverse scanned icd list adding non-duplicate extensions to the list - for (uint32_t i = 0; i < icd_tramp_list->count; i++) { - res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties)); - if (VK_SUCCESS != res) { - goto out; - } - res = loader_add_instance_extensions(inst, icd_tramp_list->scanned_list[i].EnumerateInstanceExtensionProperties, - icd_tramp_list->scanned_list[i].lib_name, &icd_exts); - if (VK_SUCCESS == res) { - if (filter_extensions) { - // Remove any extensions not recognized by the loader - for (int32_t j = 0; j < (int32_t)icd_exts.count; j++) { - // See if the extension is in the list of supported extensions - bool found = false; - for (uint32_t k = 0; LOADER_INSTANCE_EXTENSIONS[k] != NULL; k++) { - if (strcmp(icd_exts.list[j].extensionName, LOADER_INSTANCE_EXTENSIONS[k]) == 0) { - found = true; - break; - } - } - - // If it isn't in the list, remove it - if (!found) { - for (uint32_t k = j + 1; k < icd_exts.count; k++) { - icd_exts.list[k - 1] = icd_exts.list[k]; - } - --icd_exts.count; - --j; - } - } - } - - res = loader_add_to_ext_list(inst, inst_exts, icd_exts.count, icd_exts.list); - } - loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts); - if (VK_SUCCESS != res) { - goto out; - } - }; - - // Traverse loader's extensions, adding non-duplicate extensions to the list - debug_utils_AddInstanceExtensions(inst, inst_exts); - -out: - return res; -} - -struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index) { - *found_dev = NULL; - for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) { - uint32_t index = 0; - for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) { - for (struct loader_device *dev = icd_term->logical_device_list; dev; dev = dev->next) - // Value comparison of device prevents object wrapping by layers - if (loader_get_dispatch(dev->icd_device) == loader_get_dispatch(device) || - loader_get_dispatch(dev->chain_device) == loader_get_dispatch(device)) { - *found_dev = dev; - if (NULL != icd_index) { - *icd_index = index; - } - return icd_term; - } - index++; - } - } - return NULL; -} - -void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev, - const VkAllocationCallbacks *pAllocator) { - if (pAllocator) { - dev->alloc_callbacks = *pAllocator; - } - if (NULL != dev->expanded_activated_layer_list.list) { - loader_deactivate_layers(inst, dev, &dev->expanded_activated_layer_list); - } - if (NULL != dev->app_activated_layer_list.list) { - loader_destroy_layer_list(inst, dev, &dev->app_activated_layer_list); - } - loader_device_heap_free(dev, dev); -} - -struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator) { - struct loader_device *new_dev; -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator) { - new_dev = (struct loader_device *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(struct loader_device), - sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); - } else { -#endif - new_dev = (struct loader_device *)malloc(sizeof(struct loader_device)); - } - - if (!new_dev) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_create_logical_device: Failed to alloc struct " - "loader_device"); - return NULL; - } - - memset(new_dev, 0, sizeof(struct loader_device)); - if (pAllocator) { - new_dev->alloc_callbacks = *pAllocator; - } - - return new_dev; -} - -void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, struct loader_device *dev) { - dev->next = icd_term->logical_device_list; - icd_term->logical_device_list = dev; -} - -void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, - struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator) { - struct loader_device *dev, *prev_dev; - - if (!icd_term || !found_dev) return; - - prev_dev = NULL; - dev = icd_term->logical_device_list; - while (dev && dev != found_dev) { - prev_dev = dev; - dev = dev->next; - } - - if (prev_dev) - prev_dev->next = found_dev->next; - else - icd_term->logical_device_list = found_dev->next; - loader_destroy_logical_device(inst, found_dev, pAllocator); -} - -static void loader_icd_destroy(struct loader_instance *ptr_inst, struct loader_icd_term *icd_term, - const VkAllocationCallbacks *pAllocator) { - ptr_inst->total_icd_count--; - for (struct loader_device *dev = icd_term->logical_device_list; dev;) { - struct loader_device *next_dev = dev->next; - loader_destroy_logical_device(ptr_inst, dev, pAllocator); - dev = next_dev; - } - - loader_instance_heap_free(ptr_inst, icd_term); -} - -static struct loader_icd_term *loader_icd_create(const struct loader_instance *inst) { - struct loader_icd_term *icd_term; - - icd_term = loader_instance_heap_alloc(inst, sizeof(struct loader_icd_term), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (!icd_term) { - return NULL; - } - - memset(icd_term, 0, sizeof(struct loader_icd_term)); - - return icd_term; -} - -static struct loader_icd_term *loader_icd_add(struct loader_instance *ptr_inst, const struct loader_scanned_icd *scanned_icd) { - struct loader_icd_term *icd_term; - - icd_term = loader_icd_create(ptr_inst); - if (!icd_term) { - return NULL; - } - - icd_term->scanned_icd = scanned_icd; - icd_term->this_instance = ptr_inst; - - // Prepend to the list - icd_term->next = ptr_inst->icd_terms; - ptr_inst->icd_terms = icd_term; - ptr_inst->total_icd_count++; - - return icd_term; -} - -// Determine the ICD interface version to use. -// @param icd -// @param pVersion Output parameter indicating which version to use or 0 if -// the negotiation API is not supported by the ICD -// @return bool indicating true if the selected interface version is supported -// by the loader, false indicates the version is not supported -bool loader_get_icd_interface_version(PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version, uint32_t *pVersion) { - if (fp_negotiate_icd_version == NULL) { - // ICD does not support the negotiation API, it supports version 0 or 1 - // calling code must determine if it is version 0 or 1 - *pVersion = 0; - } else { - // ICD supports the negotiation API, so call it with the loader's - // latest version supported - *pVersion = CURRENT_LOADER_ICD_INTERFACE_VERSION; - VkResult result = fp_negotiate_icd_version(pVersion); - - if (result == VK_ERROR_INCOMPATIBLE_DRIVER) { - // ICD no longer supports the loader's latest interface version so - // fail loading the ICD - return false; - } - } - -#if MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION > 0 - if (*pVersion < MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION) { - // Loader no longer supports the ICD's latest interface version so fail - // loading the ICD - return false; - } -#endif - return true; -} - -void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) { - if (0 != icd_tramp_list->capacity) { - for (uint32_t i = 0; i < icd_tramp_list->count; i++) { - loader_platform_close_library(icd_tramp_list->scanned_list[i].handle); - loader_instance_heap_free(inst, icd_tramp_list->scanned_list[i].lib_name); - } - loader_instance_heap_free(inst, icd_tramp_list->scanned_list); - icd_tramp_list->capacity = 0; - icd_tramp_list->count = 0; - icd_tramp_list->scanned_list = NULL; - } -} - -static VkResult loader_scanned_icd_init(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) { - VkResult err = VK_SUCCESS; - loader_scanned_icd_clear(inst, icd_tramp_list); - icd_tramp_list->capacity = 8 * sizeof(struct loader_scanned_icd); - icd_tramp_list->scanned_list = loader_instance_heap_alloc(inst, icd_tramp_list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == icd_tramp_list->scanned_list) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_init: Realloc failed for layer list when " - "attempting to add new layer"); - err = VK_ERROR_OUT_OF_HOST_MEMORY; - } - return err; -} - -static VkResult loader_scanned_icd_add(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list, - const char *filename, uint32_t api_version) { - loader_platform_dl_handle handle; - PFN_vkCreateInstance fp_create_inst; - PFN_vkEnumerateInstanceExtensionProperties fp_get_inst_ext_props; - PFN_vkGetInstanceProcAddr fp_get_proc_addr; - PFN_GetPhysicalDeviceProcAddr fp_get_phys_dev_proc_addr = NULL; - PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version; - struct loader_scanned_icd *new_scanned_icd; - uint32_t interface_vers; - VkResult res = VK_SUCCESS; - - // TODO implement smarter opening/closing of libraries. For now this - // function leaves libraries open and the scanned_icd_clear closes them - handle = loader_platform_open_library(filename); - if (NULL == handle) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, loader_platform_open_library_error(filename)); - goto out; - } - - // Get and settle on an ICD interface version - fp_negotiate_icd_version = loader_platform_get_proc_address(handle, "vk_icdNegotiateLoaderICDInterfaceVersion"); - - if (!loader_get_icd_interface_version(fp_negotiate_icd_version, &interface_vers)) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: ICD %s doesn't support interface" - " version compatible with loader, skip this ICD.", - filename); - goto out; - } - - fp_get_proc_addr = loader_platform_get_proc_address(handle, "vk_icdGetInstanceProcAddr"); - if (NULL == fp_get_proc_addr) { - assert(interface_vers == 0); - // Use deprecated interface from version 0 - fp_get_proc_addr = loader_platform_get_proc_address(handle, "vkGetInstanceProcAddr"); - if (NULL == fp_get_proc_addr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: Attempt to retrieve either " - "\'vkGetInstanceProcAddr\' or " - "\'vk_icdGetInstanceProcAddr\' from ICD %s failed.", - filename); - goto out; - } else { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_scanned_icd_add: Using deprecated ICD " - "interface of \'vkGetInstanceProcAddr\' instead of " - "\'vk_icdGetInstanceProcAddr\' for ICD %s", - filename); - } - fp_create_inst = loader_platform_get_proc_address(handle, "vkCreateInstance"); - if (NULL == fp_create_inst) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: Failed querying " - "\'vkCreateInstance\' via dlsym/loadlibrary for " - "ICD %s", - filename); - goto out; - } - fp_get_inst_ext_props = loader_platform_get_proc_address(handle, "vkEnumerateInstanceExtensionProperties"); - if (NULL == fp_get_inst_ext_props) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: Could not get \'vkEnumerate" - "InstanceExtensionProperties\' via dlsym/loadlibrary " - "for ICD %s", - filename); - goto out; - } - } else { - // Use newer interface version 1 or later - if (interface_vers == 0) { - interface_vers = 1; - } - - fp_create_inst = (PFN_vkCreateInstance)fp_get_proc_addr(NULL, "vkCreateInstance"); - if (NULL == fp_create_inst) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: Could not get " - "\'vkCreateInstance\' via \'vk_icdGetInstanceProcAddr\'" - " for ICD %s", - filename); - goto out; - } - fp_get_inst_ext_props = - (PFN_vkEnumerateInstanceExtensionProperties)fp_get_proc_addr(NULL, "vkEnumerateInstanceExtensionProperties"); - if (NULL == fp_get_inst_ext_props) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: Could not get \'vkEnumerate" - "InstanceExtensionProperties\' via " - "\'vk_icdGetInstanceProcAddr\' for ICD %s", - filename); - goto out; - } - fp_get_phys_dev_proc_addr = loader_platform_get_proc_address(handle, "vk_icdGetPhysicalDeviceProcAddr"); - } - - // check for enough capacity - if ((icd_tramp_list->count * sizeof(struct loader_scanned_icd)) >= icd_tramp_list->capacity) { - void *new_ptr = loader_instance_heap_realloc(inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity, - icd_tramp_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_ptr) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: Realloc failed on icd library list for ICD %s", filename); - goto out; - } - icd_tramp_list->scanned_list = new_ptr; - - // double capacity - icd_tramp_list->capacity *= 2; - } - - new_scanned_icd = &(icd_tramp_list->scanned_list[icd_tramp_list->count]); - new_scanned_icd->handle = handle; - new_scanned_icd->api_version = api_version; - new_scanned_icd->GetInstanceProcAddr = fp_get_proc_addr; - new_scanned_icd->GetPhysicalDeviceProcAddr = fp_get_phys_dev_proc_addr; - new_scanned_icd->EnumerateInstanceExtensionProperties = fp_get_inst_ext_props; - new_scanned_icd->CreateInstance = fp_create_inst; - new_scanned_icd->interface_version = interface_vers; - - new_scanned_icd->lib_name = (char *)loader_instance_heap_alloc(inst, strlen(filename) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_scanned_icd->lib_name) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Out of memory can't add ICD %s", filename); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - strcpy(new_scanned_icd->lib_name, filename); - icd_tramp_list->count++; - -out: - - return res; -} - -static void loader_debug_init(void) { - char *env, *orig; - - if (g_loader_debug > 0) return; - - g_loader_debug = 0; - - // Parse comma-separated debug options - orig = env = loader_getenv("VK_LOADER_DEBUG", NULL); - while (env) { - char *p = strchr(env, ','); - size_t len; - - if (p) - len = p - env; - else - len = strlen(env); - - if (len > 0) { - if (strncmp(env, "all", len) == 0) { - g_loader_debug = ~0u; - g_loader_log_msgs = ~0u; - } else if (strncmp(env, "warn", len) == 0) { - g_loader_debug |= LOADER_WARN_BIT; - g_loader_log_msgs |= VK_DEBUG_REPORT_WARNING_BIT_EXT; - } else if (strncmp(env, "info", len) == 0) { - g_loader_debug |= LOADER_INFO_BIT; - g_loader_log_msgs |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT; - } else if (strncmp(env, "perf", len) == 0) { - g_loader_debug |= LOADER_PERF_BIT; - g_loader_log_msgs |= VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; - } else if (strncmp(env, "error", len) == 0) { - g_loader_debug |= LOADER_ERROR_BIT; - g_loader_log_msgs |= VK_DEBUG_REPORT_ERROR_BIT_EXT; - } else if (strncmp(env, "debug", len) == 0) { - g_loader_debug |= LOADER_DEBUG_BIT; - g_loader_log_msgs |= VK_DEBUG_REPORT_DEBUG_BIT_EXT; - } - } - - if (!p) break; - - env = p + 1; - } - - loader_free_getenv(orig, NULL); -} - -void loader_initialize(void) { - // initialize mutexs - loader_platform_thread_create_mutex(&loader_lock); - loader_platform_thread_create_mutex(&loader_json_lock); - - // initialize logging - loader_debug_init(); - - // initial cJSON to use alloc callbacks - cJSON_Hooks alloc_fns = { - .malloc_fn = loader_instance_tls_heap_alloc, .free_fn = loader_instance_tls_heap_free, - }; - cJSON_InitHooks(&alloc_fns); -} - -struct loader_manifest_files { - uint32_t count; - char **filename_list; -}; - -void loader_release() { - // release mutexs - loader_platform_thread_delete_mutex(&loader_lock); - loader_platform_thread_delete_mutex(&loader_json_lock); -} - -// Get next file or dirname given a string list or registry key path -// -// \returns -// A pointer to first char in the next path. -// The next path (or NULL) in the list is returned in next_path. -// Note: input string is modified in some cases. PASS IN A COPY! -static char *loader_get_next_path(char *path) { - uint32_t len; - char *next; - - if (path == NULL) return NULL; - next = strchr(path, PATH_SEPARATOR); - if (next == NULL) { - len = (uint32_t)strlen(path); - next = path + len; - } else { - *next = '\0'; - next++; - } - - return next; -} - -// Given a path which is absolute or relative, expand the path if relative or -// leave the path unmodified if absolute. The base path to prepend to relative -// paths is given in rel_base. -// -// @return - A string in out_fullpath of the full absolute path -static void loader_expand_path(const char *path, const char *rel_base, size_t out_size, char *out_fullpath) { - if (loader_platform_is_path_absolute(path)) { - // do not prepend a base to an absolute path - rel_base = ""; - } - - loader_platform_combine_path(out_fullpath, out_size, rel_base, path, NULL); -} - -// Given a filename (file) and a list of paths (dir), try to find an existing -// file in the paths. If filename already is a path then no searching in the given paths. -// -// @return - A string in out_fullpath of either the full path or file. -static void loader_get_fullpath(const char *file, const char *dirs, size_t out_size, char *out_fullpath) { - if (!loader_platform_is_path(file) && *dirs) { - char *dirs_copy, *dir, *next_dir; - - dirs_copy = loader_stack_alloc(strlen(dirs) + 1); - strcpy(dirs_copy, dirs); - - // find if file exists after prepending paths in given list - for (dir = dirs_copy; *dir && (next_dir = loader_get_next_path(dir)); dir = next_dir) { - loader_platform_combine_path(out_fullpath, out_size, dir, file, NULL); - if (loader_platform_file_exists(out_fullpath)) { - return; - } - } - } - - (void)snprintf(out_fullpath, out_size, "%s", file); -} - -// Read a JSON file into a buffer. -// -// @return - A pointer to a cJSON object representing the JSON parse tree. -// This returned buffer should be freed by caller. -static VkResult loader_get_json(const struct loader_instance *inst, const char *filename, cJSON **json) { - FILE *file = NULL; - char *json_buf; - size_t len; - VkResult res = VK_SUCCESS; - - if (NULL == json) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Received invalid JSON file"); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - *json = NULL; - - file = fopen(filename, "rb"); - if (!file) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to open JSON file %s", filename); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - fseek(file, 0, SEEK_END); - len = ftell(file); - fseek(file, 0, SEEK_SET); - json_buf = (char *)loader_stack_alloc(len + 1); - if (json_buf == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_json: Failed to allocate space for " - "JSON file %s buffer of length %d", - filename, len); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - if (fread(json_buf, sizeof(char), len, file) != len) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to read JSON file %s.", filename); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - json_buf[len] = '\0'; - - // Parse text from file - *json = cJSON_Parse(json_buf); - if (*json == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_json: Failed to parse JSON file %s, " - "this is usually because something ran out of " - "memory.", - filename); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - -out: - if (NULL != file) { - fclose(file); - } - - return res; -} - -// Do a deep copy of the loader_layer_properties structure. -VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst, - struct loader_layer_properties *src) { - uint32_t cnt, i; - memcpy(dst, src, sizeof(*src)); - dst->instance_extension_list.list = loader_instance_heap_alloc( - inst, sizeof(VkExtensionProperties) * src->instance_extension_list.count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == dst->instance_extension_list.list) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_copy_layer_properties: Failed to allocate space " - "for instance extension list of size %d.", - src->instance_extension_list.count); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) * src->instance_extension_list.count; - memcpy(dst->instance_extension_list.list, src->instance_extension_list.list, dst->instance_extension_list.capacity); - dst->device_extension_list.list = loader_instance_heap_alloc( - inst, sizeof(struct loader_dev_ext_props) * src->device_extension_list.count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == dst->device_extension_list.list) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_copy_layer_properties: Failed to allocate space " - "for device extension list of size %d.", - src->device_extension_list.count); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memset(dst->device_extension_list.list, 0, sizeof(struct loader_dev_ext_props) * src->device_extension_list.count); - - dst->device_extension_list.capacity = sizeof(struct loader_dev_ext_props) * src->device_extension_list.count; - memcpy(dst->device_extension_list.list, src->device_extension_list.list, dst->device_extension_list.capacity); - if (src->device_extension_list.count > 0 && src->device_extension_list.list->entrypoint_count > 0) { - cnt = src->device_extension_list.list->entrypoint_count; - dst->device_extension_list.list->entrypoints = - loader_instance_heap_alloc(inst, sizeof(char *) * cnt, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == dst->device_extension_list.list->entrypoints) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_copy_layer_properties: Failed to allocate space " - "for device extension entrypoint list of size %d.", - cnt); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memset(dst->device_extension_list.list->entrypoints, 0, sizeof(char *) * cnt); - - for (i = 0; i < cnt; i++) { - dst->device_extension_list.list->entrypoints[i] = loader_instance_heap_alloc( - inst, strlen(src->device_extension_list.list->entrypoints[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == dst->device_extension_list.list->entrypoints[i]) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_copy_layer_properties: Failed to " - "allocate space for device extension entrypoint " - "%d name of length", - i); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - strcpy(dst->device_extension_list.list->entrypoints[i], src->device_extension_list.list->entrypoints[i]); - } - } - - return VK_SUCCESS; -} - -static bool loader_find_layer_name_list(const char *name, const struct loader_layer_list *layer_list) { - if (NULL == layer_list) { - return false; - } - for (uint32_t j = 0; j < layer_list->count; j++) { - if (!strcmp(name, layer_list->list[j].info.layerName)) { - return true; - } - } - return false; -} - -bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]) { - if (!layer_list) return false; - for (uint32_t j = 0; j < layer_count; j++) - if (!strcmp(name, layer_list[j])) return true; - return false; -} - -const char *std_validation_str = "VK_LAYER_LUNARG_standard_validation"; - -// Adds the legacy VK_LAYER_LUNARG_standard_validation as a meta-layer if it -// fails to find it in the list already. This is usually an indication that a -// newer loader is being used with an older layer set. -static bool loader_add_legacy_std_val_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list) { - uint32_t i; - bool success = true; - struct loader_layer_properties *props = loader_get_next_layer_property(inst, layer_instance_list); - const char std_validation_names[6][VK_MAX_EXTENSION_NAME_SIZE] = { - "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation", "VK_LAYER_LUNARG_object_tracker", - "VK_LAYER_LUNARG_core_validation", "VK_LAYER_GOOGLE_unique_objects"}; - uint32_t layer_count = sizeof(std_validation_names) / sizeof(std_validation_names[0]); - - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, - "Adding VK_LAYER_LUNARG_standard_validation using the loader legacy path. This is" - " not an error."); - - if (NULL == props) { - goto out; - } - - memset(props, 0, sizeof(struct loader_layer_properties)); - props->type_flags = VK_LAYER_TYPE_FLAG_INSTANCE_LAYER | VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER | VK_LAYER_TYPE_FLAG_META_LAYER; - strncpy(props->info.description, "LunarG Standard Validation Layer", sizeof(props->info.description)); - props->info.implementationVersion = 1; - strncpy(props->info.layerName, std_validation_str, sizeof(props->info.layerName)); - props->info.specVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION); - - props->component_layer_names = - loader_instance_heap_alloc(inst, sizeof(char[MAX_STRING_SIZE]) * layer_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == props->component_layer_names) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "Failed to allocate space for legacy VK_LAYER_LUNARG_standard_validation" - " meta-layer component_layers information."); - success = false; - goto out; - } - for (i = 0; i < layer_count; i++) { - strncpy(props->component_layer_names[i], std_validation_names[i], MAX_STRING_SIZE - 1); - props->component_layer_names[i][MAX_STRING_SIZE - 1] = '\0'; - } - -out: - - if (!success && NULL != props && NULL != props->component_layer_names) { - loader_instance_heap_free(inst, props->component_layer_names); - props->component_layer_names = NULL; - } - - return success; -} - -// Verify that all component layers in a meta-layer are valid. -static bool verify_meta_layer_comp_layers(const struct loader_instance *inst, struct loader_layer_properties *prop, - struct loader_layer_list *instance_layers) { - bool success = true; - const uint32_t expected_major = VK_VERSION_MAJOR(prop->info.specVersion); - const uint32_t expected_minor = VK_VERSION_MINOR(prop->info.specVersion); - - for (uint32_t comp_layer = 0; comp_layer < prop->num_component_layers; comp_layer++) { - if (!loader_find_layer_name_list(prop->component_layer_names[comp_layer], instance_layers)) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Meta-layer %s can't find component layer %s at index %d." - " Skipping this layer.", - prop->info.layerName, prop->component_layer_names[comp_layer], comp_layer); - success = false; - break; - } else { - struct loader_layer_properties *comp_prop = - loader_get_layer_property(prop->component_layer_names[comp_layer], instance_layers); - if (comp_prop == NULL) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Meta-layer %s can't find property for component layer %s at index %d." - " Skipping this layer.", - prop->info.layerName, prop->component_layer_names[comp_layer], comp_layer); - success = false; - break; - } - - // Check the version of each layer, they need to at least match MAJOR and MINOR - uint32_t cur_major = VK_VERSION_MAJOR(comp_prop->info.specVersion); - uint32_t cur_minor = VK_VERSION_MINOR(comp_prop->info.specVersion); - if (cur_major != expected_major || cur_minor != expected_minor) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Meta-layer uses API version %d.%d, but component layer %d uses API " - "version %d.%d. Skipping this layer.", - expected_major, expected_minor, comp_layer, cur_major, cur_minor); - success = false; - break; - } - - // Make sure the layer isn't using it's own name - if (!strcmp(prop->info.layerName, prop->component_layer_names[comp_layer])) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Meta-layer %s lists itself in its component layer list at index %d." - " Skipping this layer.", - prop->info.layerName, comp_layer); - success = false; - break; - } - if (comp_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "verify_meta_layer_comp_layers: Adding meta-layer %s which also contains meta-layer %s", - prop->info.layerName, comp_prop->info.layerName); - - // Make sure if the layer is using a meta-layer in its component list that we also verify that. - if (!verify_meta_layer_comp_layers(inst, comp_prop, instance_layers)) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Meta-layer %s component layer %s can not find all component layers." - " Skipping this layer.", - prop->info.layerName, prop->component_layer_names[comp_layer]); - success = false; - break; - } - } - - // Add any instance and device extensions from component layers to this layer - // list, so that anyone querying extensions will only need to look at the meta-layer - for (uint32_t ext = 0; ext < comp_prop->instance_extension_list.count; ext++) { - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Meta-layer %s component layer %s adding instance extension %s", - prop->info.layerName, prop->component_layer_names[comp_layer], - comp_prop->instance_extension_list.list[ext].extensionName); - if (!has_vk_extension_property(&comp_prop->instance_extension_list.list[ext], &prop->instance_extension_list)) { - loader_add_to_ext_list(inst, &prop->instance_extension_list, 1, &comp_prop->instance_extension_list.list[ext]); - } - } - - for (uint32_t ext = 0; ext < comp_prop->device_extension_list.count; ext++) { - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Meta-layer %s component layer %s adding device extension %s", - prop->info.layerName, prop->component_layer_names[comp_layer], - comp_prop->device_extension_list.list[ext].props.extensionName); - if (!has_vk_dev_ext_property(&comp_prop->device_extension_list.list[ext].props, &prop->device_extension_list)) { - loader_add_to_dev_ext_list(inst, &prop->device_extension_list, - &comp_prop->device_extension_list.list[ext].props, 0, NULL); - } - } - } - } - if (success) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Meta-layer %s all %d component layers appear to be valid.", - prop->info.layerName, prop->num_component_layers); - } - return success; -} - -// Verify that all meta-layers in a layer list are valid. -static void verify_all_meta_layers(const struct loader_instance *inst, struct loader_layer_list *instance_layers) { - for (int32_t i = 0; i < (int32_t)instance_layers->count; i++) { - struct loader_layer_properties *prop = &instance_layers->list[i]; - - // If this is a meta-layer, make sure it is valid - if ((prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER) && !verify_meta_layer_comp_layers(inst, prop, instance_layers)) { - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, - "Removing meta-layer %s from instance layer list since it appears invalid.", prop->info.layerName); - - // Delete the component layers - loader_instance_heap_free(inst, prop->component_layer_names); - - // Remove the current invalid meta-layer from the layer list. Use memmove since we are - // overlapping the source and destination addresses. - memmove(&instance_layers->list[i], &instance_layers->list[i + 1], - sizeof(struct loader_layer_properties) * (instance_layers->count - 1 - i)); - - // Decrement the count (because we now have one less) and decrement the loop index since we need to - // re-check this index. - instance_layers->count--; - i--; - } - } -} - -// This structure is used to store the json file version -// in a more manageable way. -typedef struct { - uint16_t major; - uint16_t minor; - uint16_t patch; -} layer_json_version; - -static inline bool is_valid_layer_json_version(const layer_json_version *layer_json) { - // Supported versions are: 1.0.0, 1.0.1, 1.1.0, 1.1.1, and 1.1.2. - if ((layer_json->major == 1 && layer_json->minor == 1 && layer_json->patch < 3) || - (layer_json->major == 1 && layer_json->minor == 0 && layer_json->patch < 2)) { - return true; - } - return false; -} - -static inline bool layer_json_supports_layers_tag(const layer_json_version *layer_json) { - // Supported versions started in 1.0.1, so anything newer - if ((layer_json->major > 1 || layer_json->minor > 0 || layer_json->patch > 1)) { - return true; - } - return false; -} - -static inline bool layer_json_supports_pre_instance_tag(const layer_json_version *layer_json) { - // Supported versions started in 1.1.2, so anything newer - return layer_json->major > 1 || layer_json->minor > 1 || (layer_json->minor == 1 && layer_json->patch > 1); -} - -static VkResult loader_read_json_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list, - cJSON *layer_node, layer_json_version version, cJSON *item, cJSON *disable_environment, - bool is_implicit, char *filename) { - char *temp; - char *name, *type, *library_path_str, *api_version; - char *implementation_version, *description; - cJSON *ext_item, *library_path, *component_layers; - VkExtensionProperties ext_prop; - VkResult result = VK_ERROR_INITIALIZATION_FAILED; - struct loader_layer_properties *props = NULL; - int i, j; - -// The following are required in the "layer" object: -// (required) "name" -// (required) "type" -// (required) "library_path" -// (required) "api_version" -// (required) "implementation_version" -// (required) "description" -// (required for implicit layers) "disable_environment" -#define GET_JSON_OBJECT(node, var) \ - { \ - var = cJSON_GetObjectItem(node, #var); \ - if (var == NULL) { \ - layer_node = layer_node->next; \ - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, \ - "Didn't find required layer object %s in manifest " \ - "JSON file, skipping this layer", \ - #var); \ - goto out; \ - } \ - } -#define GET_JSON_ITEM(node, var) \ - { \ - item = cJSON_GetObjectItem(node, #var); \ - if (item == NULL) { \ - layer_node = layer_node->next; \ - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, \ - "Didn't find required layer value %s in manifest JSON " \ - "file, skipping this layer", \ - #var); \ - goto out; \ - } \ - temp = cJSON_Print(item); \ - if (temp == NULL) { \ - layer_node = layer_node->next; \ - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, \ - "Problem accessing layer value %s in manifest JSON " \ - "file, skipping this layer", \ - #var); \ - result = VK_ERROR_OUT_OF_HOST_MEMORY; \ - goto out; \ - } \ - temp[strlen(temp) - 1] = '\0'; \ - var = loader_stack_alloc(strlen(temp) + 1); \ - strcpy(var, &temp[1]); \ - cJSON_Free(temp); \ - } - GET_JSON_ITEM(layer_node, name) - GET_JSON_ITEM(layer_node, type) - GET_JSON_ITEM(layer_node, api_version) - GET_JSON_ITEM(layer_node, implementation_version) - GET_JSON_ITEM(layer_node, description) - - // Add list entry - if (!strcmp(type, "DEVICE")) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Device layers are deprecated skipping this layer"); - layer_node = layer_node->next; - goto out; - } - - // Allow either GLOBAL or INSTANCE type interchangeably to handle - // layers that must work with older loaders - if (!strcmp(type, "INSTANCE") || !strcmp(type, "GLOBAL")) { - if (layer_instance_list == NULL) { - layer_node = layer_node->next; - goto out; - } - props = loader_get_next_layer_property(inst, layer_instance_list); - if (NULL == props) { - // Error already triggered in loader_get_next_layer_property. - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - props->type_flags = VK_LAYER_TYPE_FLAG_INSTANCE_LAYER; - if (!is_implicit) { - props->type_flags |= VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER; - } - } else { - layer_node = layer_node->next; - goto out; - } - - // Library path no longer required unless component_layers is also not defined - library_path = cJSON_GetObjectItem(layer_node, "library_path"); - component_layers = cJSON_GetObjectItem(layer_node, "component_layers"); - if (NULL != library_path) { - if (NULL != component_layers) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Indicating meta-layer-specific component_layers, but also " - "defining layer library path. Both are not compatible, so " - "skipping this layer"); - goto out; - } - props->num_component_layers = 0; - props->component_layer_names = NULL; - - temp = cJSON_Print(library_path); - if (NULL == temp) { - layer_node = layer_node->next; - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Problem accessing layer value library_path in manifest JSON " - "file, skipping this layer"); - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - temp[strlen(temp) - 1] = '\0'; - library_path_str = loader_stack_alloc(strlen(temp) + 1); - strcpy(library_path_str, &temp[1]); - cJSON_Free(temp); - - char *fullpath = props->lib_name; - char *rel_base; - if (NULL != library_path_str) { - if (loader_platform_is_path(library_path_str)) { - // A relative or absolute path - char *name_copy = loader_stack_alloc(strlen(filename) + 1); - strcpy(name_copy, filename); - rel_base = loader_platform_dirname(name_copy); - loader_expand_path(library_path_str, rel_base, MAX_STRING_SIZE, fullpath); - } else { - // A filename which is assumed in a system directory - loader_get_fullpath(library_path_str, DEFAULT_VK_LAYERS_PATH, MAX_STRING_SIZE, fullpath); - } - } - } else if (NULL != component_layers) { - if (version.major == 1 && (version.minor < 1 || version.patch < 1)) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Indicating meta-layer-specific component_layers, but using older " - "JSON file version."); - } - int count = cJSON_GetArraySize(component_layers); - props->num_component_layers = count; - - // Allocate buffer for layer names - props->component_layer_names = - loader_instance_heap_alloc(inst, sizeof(char[MAX_STRING_SIZE]) * count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == props->component_layer_names) { - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - // Copy the component layers into the array - for (i = 0; i < count; i++) { - cJSON *comp_layer = cJSON_GetArrayItem(component_layers, i); - if (NULL != comp_layer) { - temp = cJSON_Print(comp_layer); - if (NULL == temp) { - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - temp[strlen(temp) - 1] = '\0'; - strncpy(props->component_layer_names[i], temp + 1, MAX_STRING_SIZE - 1); - props->component_layer_names[i][MAX_STRING_SIZE - 1] = '\0'; - cJSON_Free(temp); - } - } - - // This is now, officially, a meta-layer - props->type_flags |= VK_LAYER_TYPE_FLAG_META_LAYER; - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Encountered meta-layer %s", name); - - // Make sure we set up other things so we head down the correct branches below - library_path_str = NULL; - } else { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Layer missing both library_path and component_layers fields. One or the " - "other MUST be defined. Skipping this layer"); - goto out; - } - - if (is_implicit) { - GET_JSON_OBJECT(layer_node, disable_environment) - } -#undef GET_JSON_ITEM -#undef GET_JSON_OBJECT - - strncpy(props->info.layerName, name, sizeof(props->info.layerName)); - props->info.layerName[sizeof(props->info.layerName) - 1] = '\0'; - props->info.specVersion = loader_make_version(api_version); - props->info.implementationVersion = atoi(implementation_version); - strncpy((char *)props->info.description, description, sizeof(props->info.description)); - props->info.description[sizeof(props->info.description) - 1] = '\0'; - if (is_implicit) { - if (!disable_environment || !disable_environment->child) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Didn't find required layer child value disable_environment" - "in manifest JSON file, skipping this layer"); - layer_node = layer_node->next; - goto out; - } - strncpy(props->disable_env_var.name, disable_environment->child->string, sizeof(props->disable_env_var.name)); - props->disable_env_var.name[sizeof(props->disable_env_var.name) - 1] = '\0'; - strncpy(props->disable_env_var.value, disable_environment->child->valuestring, sizeof(props->disable_env_var.value)); - props->disable_env_var.value[sizeof(props->disable_env_var.value) - 1] = '\0'; - } - -// Now get all optional items and objects and put in list: -// functions -// instance_extensions -// device_extensions -// enable_environment (implicit layers only) -#define GET_JSON_OBJECT(node, var) \ - { var = cJSON_GetObjectItem(node, #var); } -#define GET_JSON_ITEM(node, var) \ - { \ - item = cJSON_GetObjectItem(node, #var); \ - if (item != NULL) { \ - temp = cJSON_Print(item); \ - if (temp != NULL) { \ - temp[strlen(temp) - 1] = '\0'; \ - var = loader_stack_alloc(strlen(temp) + 1); \ - strcpy(var, &temp[1]); \ - cJSON_Free(temp); \ - } else { \ - result = VK_ERROR_OUT_OF_HOST_MEMORY; \ - goto out; \ - } \ - } \ - } - - cJSON *instance_extensions, *device_extensions, *functions, *enable_environment; - cJSON *entrypoints = NULL; - char *vkGetInstanceProcAddr = NULL; - char *vkGetDeviceProcAddr = NULL; - char *vkNegotiateLoaderLayerInterfaceVersion = NULL; - char *spec_version = NULL; - char **entry_array = NULL; - - // Layer interface functions - // vkGetInstanceProcAddr - // vkGetDeviceProcAddr - // vkNegotiateLoaderLayerInterfaceVersion (starting with JSON file 1.1.0) - GET_JSON_OBJECT(layer_node, functions) - if (functions != NULL) { - if (version.major > 1 || version.minor >= 1) { - GET_JSON_ITEM(functions, vkNegotiateLoaderLayerInterfaceVersion) - if (vkNegotiateLoaderLayerInterfaceVersion != NULL) - strncpy(props->functions.str_negotiate_interface, vkNegotiateLoaderLayerInterfaceVersion, - sizeof(props->functions.str_negotiate_interface)); - props->functions.str_negotiate_interface[sizeof(props->functions.str_negotiate_interface) - 1] = '\0'; - } else { - props->functions.str_negotiate_interface[0] = '\0'; - } - GET_JSON_ITEM(functions, vkGetInstanceProcAddr) - GET_JSON_ITEM(functions, vkGetDeviceProcAddr) - if (vkGetInstanceProcAddr != NULL) { - strncpy(props->functions.str_gipa, vkGetInstanceProcAddr, sizeof(props->functions.str_gipa)); - if (version.major > 1 || version.minor >= 1) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Layer \"%s\" using deprecated \'vkGetInstanceProcAddr\' tag which was deprecated starting with JSON " - "file version 1.1.0. Instead, use the new vkNegotiateLayerInterfaceVersion function to return the " - "GetInstanceProcAddr function for this layer.", - name); - } - } - props->functions.str_gipa[sizeof(props->functions.str_gipa) - 1] = '\0'; - if (vkGetDeviceProcAddr != NULL) { - strncpy(props->functions.str_gdpa, vkGetDeviceProcAddr, sizeof(props->functions.str_gdpa)); - if (version.major > 1 || version.minor >= 1) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Layer \"%s\" using deprecated \'vkGetDeviceProcAddr\' tag which was deprecated starting with JSON " - "file version 1.1.0. Instead, use the new vkNegotiateLayerInterfaceVersion function to return the " - "GetDeviceProcAddr function for this layer.", - name); - } - } - props->functions.str_gdpa[sizeof(props->functions.str_gdpa) - 1] = '\0'; - } - - // instance_extensions - // array of { - // name - // spec_version - // } - GET_JSON_OBJECT(layer_node, instance_extensions) - if (instance_extensions != NULL) { - int count = cJSON_GetArraySize(instance_extensions); - for (i = 0; i < count; i++) { - ext_item = cJSON_GetArrayItem(instance_extensions, i); - GET_JSON_ITEM(ext_item, name) - if (name != NULL) { - strncpy(ext_prop.extensionName, name, sizeof(ext_prop.extensionName)); - ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] = '\0'; - } - GET_JSON_ITEM(ext_item, spec_version) - if (NULL != spec_version) { - ext_prop.specVersion = atoi(spec_version); - } else { - ext_prop.specVersion = 0; - } - bool ext_unsupported = wsi_unsupported_instance_extension(&ext_prop); - if (!ext_unsupported) { - loader_add_to_ext_list(inst, &props->instance_extension_list, 1, &ext_prop); - } - } - } - - // device_extensions - // array of { - // name - // spec_version - // entrypoints - // } - GET_JSON_OBJECT(layer_node, device_extensions) - if (device_extensions != NULL) { - int count = cJSON_GetArraySize(device_extensions); - for (i = 0; i < count; i++) { - ext_item = cJSON_GetArrayItem(device_extensions, i); - GET_JSON_ITEM(ext_item, name) - GET_JSON_ITEM(ext_item, spec_version) - if (name != NULL) { - strncpy(ext_prop.extensionName, name, sizeof(ext_prop.extensionName)); - ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] = '\0'; - } - if (NULL != spec_version) { - ext_prop.specVersion = atoi(spec_version); - } else { - ext_prop.specVersion = 0; - } - // entrypoints = cJSON_GetObjectItem(ext_item, "entrypoints"); - GET_JSON_OBJECT(ext_item, entrypoints) - int entry_count; - if (entrypoints == NULL) { - loader_add_to_dev_ext_list(inst, &props->device_extension_list, &ext_prop, 0, NULL); - continue; - } - entry_count = cJSON_GetArraySize(entrypoints); - if (entry_count) { - entry_array = (char **)loader_stack_alloc(sizeof(char *) * entry_count); - } - for (j = 0; j < entry_count; j++) { - ext_item = cJSON_GetArrayItem(entrypoints, j); - if (ext_item != NULL) { - temp = cJSON_Print(ext_item); - if (NULL == temp) { - entry_array[j] = NULL; - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - temp[strlen(temp) - 1] = '\0'; - entry_array[j] = loader_stack_alloc(strlen(temp) + 1); - strcpy(entry_array[j], &temp[1]); - cJSON_Free(temp); - } - } - loader_add_to_dev_ext_list(inst, &props->device_extension_list, &ext_prop, entry_count, entry_array); - } - } - if (is_implicit) { - GET_JSON_OBJECT(layer_node, enable_environment) - - // enable_environment is optional - if (enable_environment) { - strncpy(props->enable_env_var.name, enable_environment->child->string, sizeof(props->enable_env_var.name)); - props->enable_env_var.name[sizeof(props->enable_env_var.name) - 1] = '\0'; - strncpy(props->enable_env_var.value, enable_environment->child->valuestring, sizeof(props->enable_env_var.value)); - props->enable_env_var.value[sizeof(props->enable_env_var.value) - 1] = '\0'; - } - } - - // Read in the pre-instance stuff - cJSON *pre_instance = cJSON_GetObjectItem(layer_node, "pre_instance_functions"); - if (pre_instance) { - if (!layer_json_supports_pre_instance_tag(&version)) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "Found pre_instance_functions section in layer from \"%s\". " - "This section is only valid in manifest version 1.1.2 or later. The section will be ignored", - filename); - } else if (!is_implicit) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Found pre_instance_functions section in explicit layer from " - "\"%s\". This section is only valid in implicit layers. The section will be ignored", - filename); - } else { - cJSON *inst_ext_json = cJSON_GetObjectItem(pre_instance, "vkEnumerateInstanceExtensionProperties"); - if (inst_ext_json) { - char *inst_ext_name = cJSON_Print(inst_ext_json); - if (inst_ext_name == NULL) { - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - size_t len = strlen(inst_ext_name) >= MAX_STRING_SIZE ? MAX_STRING_SIZE - 3 : strlen(inst_ext_name) - 2; - strncpy(props->pre_instance_functions.enumerate_instance_extension_properties, inst_ext_name + 1, len); - props->pre_instance_functions.enumerate_instance_extension_properties[len] = '\0'; - cJSON_Free(inst_ext_name); - } - - cJSON *inst_layer_json = cJSON_GetObjectItem(pre_instance, "vkEnumerateInstanceLayerProperties"); - if (inst_layer_json) { - char *inst_layer_name = cJSON_Print(inst_layer_json); - if (inst_layer_name == NULL) { - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - size_t len = strlen(inst_layer_name) >= MAX_STRING_SIZE ? MAX_STRING_SIZE - 3 : strlen(inst_layer_name) - 2; - strncpy(props->pre_instance_functions.enumerate_instance_layer_properties, inst_layer_name + 1, len); - props->pre_instance_functions.enumerate_instance_layer_properties[len] = '\0'; - cJSON_Free(inst_layer_name); - } - - cJSON *inst_version_json = cJSON_GetObjectItem(pre_instance, "vkEnumerateInstanceVersion"); - if (inst_version_json) { - char *inst_version_name = cJSON_Print(inst_version_json); - if (inst_version_json) { - result = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - size_t len = strlen(inst_version_name) >= MAX_STRING_SIZE ? MAX_STRING_SIZE - 3 : strlen(inst_version_name) - 2; - strncpy(props->pre_instance_functions.enumerate_instance_version, inst_version_name + 1, len); - props->pre_instance_functions.enumerate_instance_version[len] = '\0'; - cJSON_Free(inst_version_name); - } - } - } - - result = VK_SUCCESS; - -out: - -#undef GET_JSON_ITEM -#undef GET_JSON_OBJECT - - if (VK_SUCCESS != result && NULL != props) { - props->num_component_layers = 0; - if (NULL != props->component_layer_names) { - loader_instance_heap_free(inst, props->component_layer_names); - } - props->component_layer_names = NULL; - } - - return result; -} - -// Given a cJSON struct (json) of the top level JSON object from layer manifest -// file, add entry to the layer_list. Fill out the layer_properties in this list -// entry from the input cJSON object. -// -// \returns -// void -// layer_list has a new entry and initialized accordingly. -// If the json input object does not have all the required fields no entry -// is added to the list. -static VkResult loader_add_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list, - cJSON *json, bool is_implicit, char *filename) { - // The following Fields in layer manifest file that are required: - // - "file_format_version" - // - If more than one "layer" object are used, then the "layers" array is - // required - VkResult result = VK_ERROR_INITIALIZATION_FAILED; - cJSON *item, *layers_node, *layer_node; - layer_json_version json_version = {0, 0, 0}; - char *vers_tok; - cJSON *disable_environment = NULL; - item = cJSON_GetObjectItem(json, "file_format_version"); - if (item == NULL) { - goto out; - } - char *file_vers = cJSON_PrintUnformatted(item); - if (NULL == file_vers) { - goto out; - } - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found manifest file %s, version %s", filename, file_vers); - // Get the major/minor/and patch as integers for easier comparison - vers_tok = strtok(file_vers, ".\"\n\r"); - if (NULL != vers_tok) { - json_version.major = (uint16_t)atoi(vers_tok); - vers_tok = strtok(NULL, ".\"\n\r"); - if (NULL != vers_tok) { - json_version.minor = (uint16_t)atoi(vers_tok); - vers_tok = strtok(NULL, ".\"\n\r"); - if (NULL != vers_tok) { - json_version.patch = (uint16_t)atoi(vers_tok); - } - } - } - - if (!is_valid_layer_json_version(&json_version)) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_add_layer_properties: %s invalid layer " - "manifest file version %d.%d.%d. May cause errors.", - filename, json_version.major, json_version.minor, json_version.patch); - } - cJSON_Free(file_vers); - - // If "layers" is present, read in the array of layer objects - layers_node = cJSON_GetObjectItem(json, "layers"); - if (layers_node != NULL) { - int numItems = cJSON_GetArraySize(layers_node); - if (!layer_json_supports_layers_tag(&json_version)) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_add_layer_properties: \'layers\' tag not " - "supported until file version 1.0.1, but %s is " - "reporting version %s", - filename, file_vers); - } - for (int curLayer = 0; curLayer < numItems; curLayer++) { - layer_node = cJSON_GetArrayItem(layers_node, curLayer); - if (layer_node == NULL) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_add_layer_properties: Can not find " - "\'layers\' array element %d object in manifest " - "JSON file %s. Skipping this file", - curLayer, filename); - goto out; - } - result = loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, - is_implicit, filename); - } - } else { - // Otherwise, try to read in individual layers - layer_node = cJSON_GetObjectItem(json, "layer"); - if (layer_node == NULL) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_add_layer_properties: Can not find \'layer\' " - "object in manifest JSON file %s. Skipping this file.", - filename); - goto out; - } - // Loop through all "layer" objects in the file to get a count of them - // first. - uint16_t layer_count = 0; - cJSON *tempNode = layer_node; - do { - tempNode = tempNode->next; - layer_count++; - } while (tempNode != NULL); - - // Throw a warning if we encounter multiple "layer" objects in file - // versions newer than 1.0.0. Having multiple objects with the same - // name at the same level is actually a JSON standard violation. - if (layer_count > 1 && layer_json_supports_layers_tag(&json_version)) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_layer_properties: Multiple \'layer\' nodes" - " are deprecated starting in file version \"1.0.1\". " - "Please use \'layers\' : [] array instead in %s.", - filename); - } else { - do { - result = loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, - is_implicit, filename); - layer_node = layer_node->next; - } while (layer_node != NULL); - } - } - -out: - - return result; -} - -// Find the Vulkan library manifest files. -// -// This function scans the "location" or "env_override" directories/files -// for a list of JSON manifest files. If env_override is non-NULL -// and has a valid value. Then the location is ignored. Otherwise -// location is used to look for manifest files. The location -// is interpreted as Registry path on Windows and a directory path(s) -// on Linux. "home_location" is an additional directory in the users home -// directory to look at. It is expanded into the dir path -// $XDG_DATA_HOME/home_location or $HOME/.local/share/home_location depending -// on environment variables. This "home_location" is only used on Linux. -// -// \returns -// VKResult -// A string list of manifest files to be opened in out_files param. -// List has a pointer to string for each manifest filename. -// When done using the list in out_files, pointers should be freed. -// Location or override string lists can be either files or directories as -// follows: -// | location | override -// -------------------------------- -// Win ICD | files | files -// Win Layer | files | dirs -// Linux ICD | dirs | files -// Linux Layer| dirs | dirs -static VkResult loader_get_manifest_files(const struct loader_instance *inst, const char *env_override, const char *source_override, - bool is_layer, bool warn_if_not_present, const char *location, - const char *relative_location, struct loader_manifest_files *out_files) { - const char *override = NULL; - char *override_getenv = NULL; - char *loc, *orig_loc = NULL; - size_t loc_size = 0; - char *reg = NULL; - char *file, *next_file, *name; - size_t alloced_count = 64; - char full_path[2048]; - DIR *sysdir = NULL; - bool list_is_dirs = false; - struct dirent *dent; - VkResult res = VK_SUCCESS; - - out_files->count = 0; - out_files->filename_list = NULL; - - if (source_override != NULL) { - override = source_override; - } else if (env_override != NULL) { -#if !defined(_WIN32) - if (geteuid() != getuid() || getegid() != getgid()) { - // Don't allow setuid apps to use the env var: - env_override = NULL; - } -#endif - if (env_override != NULL) { - override = override_getenv = loader_secure_getenv(env_override, inst); - } - } -#if !defined(_WIN32) - if (relative_location == NULL) { -#else - relative_location = NULL; - if (location == NULL) { -#endif - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Can not get manifest files with " - "NULL location, env_override=%s", - (env_override != NULL) ? env_override : ""); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - -#if defined(_WIN32) - list_is_dirs = (is_layer && override != NULL) ? true : false; -#else - list_is_dirs = (override == NULL || is_layer) ? true : false; -#endif - // Make a copy of the input we are using so it is not modified - // Also handle getting the location(s) from registry on Windows - if (override == NULL) { -#if !defined(_WIN32) - const char *xdgconfdirs = loader_secure_getenv("XDG_CONFIG_DIRS", inst); - const char *xdgdatadirs = loader_secure_getenv("XDG_DATA_DIRS", inst); - if (xdgconfdirs == NULL || xdgconfdirs[0] == '\0') xdgconfdirs = FALLBACK_CONFIG_DIRS; - if (xdgdatadirs == NULL || xdgdatadirs[0] == '\0') xdgdatadirs = FALLBACK_DATA_DIRS; - const size_t rel_size = strlen(relative_location); - // Leave space for trailing separators - loc_size += strlen(xdgconfdirs) + strlen(xdgdatadirs) + 2 * rel_size + 2; - for (const char *x = xdgconfdirs; *x; ++x) - if (*x == PATH_SEPARATOR) loc_size += rel_size; - for (const char *x = xdgdatadirs; *x; ++x) - if (*x == PATH_SEPARATOR) loc_size += rel_size; - loc_size += strlen(SYSCONFDIR) + rel_size + 1; -#if defined(EXTRASYSCONFDIR) - loc_size += strlen(EXTRASYSCONFDIR) + rel_size + 1; -#endif -#if defined(__APPLE__) - // For bundle path - loc_size += MAXPATHLEN; -#endif -#else - loc_size += strlen(location) + 1; -#endif - loc = loader_stack_alloc(loc_size); - if (loc == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate " - "%d bytes for manifest file location.", - loc_size); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - char *loc_write = loc; -#if !defined(_WIN32) - const char *loc_read; - size_t start, stop; - -#if defined(__APPLE__) - // Add the bundle's Resources dir to the beginning of the search path. - // Looks for manifests in the bundle first, before any system directories. - CFBundleRef main_bundle = CFBundleGetMainBundle(); - if (NULL != main_bundle) { - CFURLRef ref = CFBundleCopyResourcesDirectoryURL(main_bundle); - if (NULL != ref) { - if (CFURLGetFileSystemRepresentation(ref, TRUE, (UInt8 *)loc_write, loc_size)) { - loc_write += strlen(loc_write); - memcpy(loc_write, relative_location, rel_size); - loc_write += rel_size; - *loc_write++ = PATH_SEPARATOR; - } - CFRelease(ref); - } - } -#endif - loc_read = &xdgconfdirs[0]; - start = 0; - while (loc_read[start] != '\0') { - while (loc_read[start] == PATH_SEPARATOR) { - start++; - } - stop = start; - while (loc_read[stop] != PATH_SEPARATOR && loc_read[stop] != '\0') { - stop++; - } - const size_t s = stop - start; - if (s) { - memcpy(loc_write, &loc_read[start], s); - loc_write += s; - memcpy(loc_write, relative_location, rel_size); - loc_write += rel_size; - *loc_write++ = PATH_SEPARATOR; - start = stop; - } - } - - memcpy(loc_write, SYSCONFDIR, strlen(SYSCONFDIR)); - loc_write += strlen(SYSCONFDIR); - memcpy(loc_write, relative_location, rel_size); - loc_write += rel_size; - *loc_write++ = PATH_SEPARATOR; - -#if defined(EXTRASYSCONFDIR) - memcpy(loc_write, EXTRASYSCONFDIR, strlen(EXTRASYSCONFDIR)); - loc_write += strlen(EXTRASYSCONFDIR); - memcpy(loc_write, relative_location, rel_size); - loc_write += rel_size; - *loc_write++ = PATH_SEPARATOR; -#endif - - loc_read = &xdgdatadirs[0]; - start = 0; - while (loc_read[start] != '\0') { - while (loc_read[start] == PATH_SEPARATOR) { - start++; - } - stop = start; - while (loc_read[stop] != PATH_SEPARATOR && loc_read[stop] != '\0') { - stop++; - } - const size_t s = stop - start; - if (s) { - memcpy(loc_write, &loc_read[start], s); - loc_write += s; - memcpy(loc_write, relative_location, rel_size); - loc_write += rel_size; - *loc_write++ = PATH_SEPARATOR; - start = stop; - } - } - - --loc_write; -#else - memcpy(loc_write, location, strlen(location)); - loc_write += strlen(location); -#endif - assert(loc_write - loc < (ptrdiff_t)loc_size); - *loc_write = '\0'; - -#if defined(_WIN32) - VkResult regHKR_result = VK_SUCCESS; - - DWORD reg_size = 4096; - - // These calls look at the PNP/Device section of the registry. - if (!strncmp(loc, DEFAULT_VK_DRIVERS_INFO, sizeof(DEFAULT_VK_DRIVERS_INFO))) { - regHKR_result = loaderGetDeviceRegistryFiles(inst, ®, ®_size, LoaderPnpDriverRegistry()); - } else if (!strncmp(loc, DEFAULT_VK_ELAYERS_INFO, sizeof(DEFAULT_VK_ELAYERS_INFO))) { - regHKR_result = loaderGetDeviceRegistryFiles(inst, ®, ®_size, LoaderPnpELayerRegistry()); - } else if (!strncmp(loc, DEFAULT_VK_ILAYERS_INFO, sizeof(DEFAULT_VK_ILAYERS_INFO))) { - regHKR_result = loaderGetDeviceRegistryFiles(inst, ®, ®_size, LoaderPnpILayerRegistry()); - } - - // This call looks into the Khronos non-device specific section of the registry. - VkResult reg_result = loaderGetRegistryFiles(inst, loc, is_layer, ®, ®_size); - - if ((VK_SUCCESS != reg_result && VK_SUCCESS != regHKR_result) || NULL == reg) { - if (!is_layer) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Registry lookup failed " - "to get ICD manifest files. Possibly missing Vulkan" - " driver?"); - if (VK_SUCCESS == regHKR_result || VK_ERROR_OUT_OF_HOST_MEMORY == regHKR_result) { - res = regHKR_result; - } else if (VK_SUCCESS == reg_result || VK_ERROR_OUT_OF_HOST_MEMORY == reg_result) { - res = reg_result; - } else { - res = VK_ERROR_INCOMPATIBLE_DRIVER; - } - } else { - if (warn_if_not_present) { - // This is only a warning for layers - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_get_manifest_files: Registry lookup failed " - "to get layer manifest files."); - } - if (reg_result == VK_ERROR_OUT_OF_HOST_MEMORY) { - res = reg_result; - } else { - // Return success for now since it's not critical for layers - res = VK_SUCCESS; - } - } - goto out; - } - orig_loc = loc; - loc = reg; -#endif - } else { - loc = loader_stack_alloc(strlen(override) + 1); - if (loc == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate space for " - "override environment variable of length %d", - strlen(override) + 1); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - strcpy(loc, override); - } - - size_t n = 0; - loc_size = strlen(loc); - // Remove duplicated directory symbols (could hide duplicated paths) - for (size_t i = 0; i < loc_size; i++) { - if (n > 0) loc[i] = loc[i + n]; - if (loc[i] == DIRECTORY_SYMBOL && loc[i + 1 + n] == DIRECTORY_SYMBOL) { - loc_size--; - n++; - } - } - loc[loc_size] = '\0'; - - // Print out the paths being searched if debugging is enabled - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following paths for manifest files: %s\n", loc); - - file = loc; - while (*file) { - next_file = loader_get_next_path(file); - if (list_is_dirs) { - sysdir = opendir(file); - name = NULL; - if (sysdir) { - dent = readdir(sysdir); - if (dent == NULL) break; - name = &(dent->d_name[0]); - loader_get_fullpath(name, file, sizeof(full_path), full_path); - name = full_path; - } - } else { -#if defined(_WIN32) - name = file; -#else - // only Linux has relative paths - char *dir; - // make a copy of location so it isn't modified - dir = loader_stack_alloc(strlen(loc) + 1); - if (dir == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate " - "space for relative location path length %d", - strlen(loc) + 1); - goto out; - } - strcpy(dir, loc); - - loader_get_fullpath(file, dir, sizeof(full_path), full_path); - - name = full_path; -#endif - } - while (name) { - // Look for files ending with ".json" suffix - uint32_t nlen = (uint32_t)strlen(name); - const char *suf = name + nlen - 5; - - // Check if the file is already present - bool file_already_loaded = false; - for (uint32_t i = 0; i < out_files->count; ++i) { - if (!strcmp(out_files->filename_list[i], name)) { - file_already_loaded = true; - } - } - - if (!file_already_loaded && (nlen > 5) && !strncmp(suf, ".json", 5)) { - if (out_files->count == 0) { - out_files->filename_list = - loader_instance_heap_alloc(inst, alloced_count * sizeof(char *), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); - if (NULL == out_files->filename_list) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate space for manifest file name list"); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - } else if (out_files->count == alloced_count) { - void *new_ptr = - loader_instance_heap_realloc(inst, out_files->filename_list, alloced_count * sizeof(char *), - alloced_count * sizeof(char *) * 2, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); - if (NULL == new_ptr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to reallocate space for manifest file name list"); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - out_files->filename_list = new_ptr; - alloced_count *= 2; - } - out_files->filename_list[out_files->count] = - loader_instance_heap_alloc(inst, strlen(name) + 1, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); - if (out_files->filename_list[out_files->count] == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate " - "space for manifest file %d list", - out_files->count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - strcpy(out_files->filename_list[out_files->count], name); - out_files->count++; - } else if(file_already_loaded) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "Skipping manifest file %s - The file has already been read once", name); - } else if (!list_is_dirs) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Skipping manifest file %s, file name must end in .json", - name); - } - if (list_is_dirs) { - dent = readdir(sysdir); - if (dent == NULL) { - break; - } - name = &(dent->d_name[0]); - loader_get_fullpath(name, file, sizeof(full_path), full_path); - name = full_path; - } else { - break; - } - } - if (sysdir) { - closedir(sysdir); - sysdir = NULL; - } - file = next_file; -#if !defined(_WIN32) - if (relative_location != NULL && (next_file == NULL || *next_file == '\0') && override == NULL) { - char *xdgdatahome = loader_secure_getenv("XDG_DATA_HOME", inst); - size_t len; - if (xdgdatahome != NULL) { - size_t alloc_len = strlen(xdgdatahome) + 2 + strlen(relative_location); - char *home_loc = loader_stack_alloc(alloc_len); - if (home_loc == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate " - "space for manifest file XDG Home location"); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - strcpy(home_loc, xdgdatahome); - // Add directory separator if needed - if (relative_location[0] != DIRECTORY_SYMBOL) { - len = strlen(home_loc); - home_loc[len] = DIRECTORY_SYMBOL; - home_loc[len + 1] = '\0'; - } - strncat(home_loc, relative_location, alloc_len); - file = home_loc; - next_file = loader_get_next_path(file); - relative_location = NULL; - - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following path for manifest files: %s\n", - home_loc); - list_is_dirs = true; - - } else { - char *home = loader_secure_getenv("HOME", inst); - if (home != NULL) { - size_t alloc_len = strlen(home) + 16 + strlen(relative_location); - char *home_loc = loader_stack_alloc(alloc_len); - if (home_loc == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate " - "space for manifest file Home location"); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - strncpy(home_loc, home, alloc_len); - - len = strlen(home); - if (home[len] != DIRECTORY_SYMBOL) { - home_loc[len] = DIRECTORY_SYMBOL; - home_loc[len + 1] = '\0'; - } - strncat(home_loc, ".local/share", alloc_len); - - if (relative_location[0] != DIRECTORY_SYMBOL) { - len = strlen(home_loc); - home_loc[len] = DIRECTORY_SYMBOL; - home_loc[len + 1] = '\0'; - } - strncat(home_loc, relative_location, alloc_len); - file = home_loc; - next_file = loader_get_next_path(file); - relative_location = NULL; - - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following path for manifest files: %s\n", - home_loc); - list_is_dirs = true; - } else { - // without knowing HOME, we just.. give up - } - } - } -#endif - } - -out: - if (VK_SUCCESS != res && NULL != out_files->filename_list) { - for (uint32_t remove = 0; remove < out_files->count; remove++) { - loader_instance_heap_free(inst, out_files->filename_list[remove]); - } - loader_instance_heap_free(inst, out_files->filename_list); - out_files->count = 0; - out_files->filename_list = NULL; - } - - if (NULL != sysdir) { - closedir(sysdir); - } - - if (override_getenv != NULL) { - loader_free_getenv(override_getenv, inst); - } - - if (NULL != reg && reg != orig_loc) { - loader_instance_heap_free(inst, reg); - } - return res; -} - -void loader_init_icd_lib_list() {} - -void loader_destroy_icd_lib_list() {} - -// Try to find the Vulkan ICD driver(s). -// -// This function scans the default system loader path(s) or path -// specified by the \c VK_ICD_FILENAMES environment variable in -// order to find loadable VK ICDs manifest files. From these -// manifest files it finds the ICD libraries. -// -// \returns -// Vulkan result -// (on result == VK_SUCCESS) a list of icds that were discovered -VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) { - char *file_str; - uint16_t file_major_vers = 0; - uint16_t file_minor_vers = 0; - uint16_t file_patch_vers = 0; - char *vers_tok; - struct loader_manifest_files manifest_files; - VkResult res = VK_SUCCESS; - bool lockedMutex = false; - cJSON *json = NULL; - uint32_t num_good_icds = 0; - - memset(&manifest_files, 0, sizeof(struct loader_manifest_files)); - - res = loader_scanned_icd_init(inst, icd_tramp_list); - if (VK_SUCCESS != res) { - goto out; - } - - // Get a list of manifest files for ICDs - res = loader_get_manifest_files(inst, "VK_ICD_FILENAMES", NULL, false, true, DEFAULT_VK_DRIVERS_INFO, RELATIVE_VK_DRIVERS_INFO, - &manifest_files); - if (VK_SUCCESS != res || manifest_files.count == 0) { - goto out; - } - - loader_platform_thread_lock_mutex(&loader_json_lock); - lockedMutex = true; - for (uint32_t i = 0; i < manifest_files.count; i++) { - file_str = manifest_files.filename_list[i]; - if (file_str == NULL) { - continue; - } - - VkResult temp_res = loader_get_json(inst, file_str, &json); - if (NULL == json || temp_res != VK_SUCCESS) { - if (NULL != json) { - cJSON_Delete(json); - json = NULL; - } - // If we haven't already found an ICD, copy this result to - // the returned result. - if (num_good_icds == 0) { - res = temp_res; - } - if (temp_res == VK_ERROR_OUT_OF_HOST_MEMORY) { - break; - } else { - continue; - } - } - res = temp_res; - - cJSON *item, *itemICD; - item = cJSON_GetObjectItem(json, "file_format_version"); - if (item == NULL) { - if (num_good_icds == 0) { - res = VK_ERROR_INITIALIZATION_FAILED; - } - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: ICD JSON %s does not have a" - " \'file_format_version\' field. Skipping ICD JSON.", - file_str); - cJSON_Delete(json); - json = NULL; - continue; - } - - char *file_vers = cJSON_Print(item); - if (NULL == file_vers) { - // Only reason the print can fail is if there was an allocation issue - if (num_good_icds == 0) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - } - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: Failed retrieving ICD JSON %s" - " \'file_format_version\' field. Skipping ICD JSON", - file_str); - cJSON_Delete(json); - json = NULL; - continue; - } - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found ICD manifest file %s, version %s", file_str, file_vers); - - // Get the major/minor/and patch as integers for easier comparison - vers_tok = strtok(file_vers, ".\"\n\r"); - if (NULL != vers_tok) { - file_major_vers = (uint16_t)atoi(vers_tok); - vers_tok = strtok(NULL, ".\"\n\r"); - if (NULL != vers_tok) { - file_minor_vers = (uint16_t)atoi(vers_tok); - vers_tok = strtok(NULL, ".\"\n\r"); - if (NULL != vers_tok) { - file_patch_vers = (uint16_t)atoi(vers_tok); - } - } - } - - if (file_major_vers != 1 || file_minor_vers != 0 || file_patch_vers > 1) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: Unexpected manifest file version " - "(expected 1.0.0 or 1.0.1), may cause errors"); - } - cJSON_Free(file_vers); - - itemICD = cJSON_GetObjectItem(json, "ICD"); - if (itemICD != NULL) { - item = cJSON_GetObjectItem(itemICD, "library_path"); - if (item != NULL) { - char *temp = cJSON_Print(item); - if (!temp || strlen(temp) == 0) { - if (num_good_icds == 0) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - } - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: Failed retrieving ICD JSON %s" - " \'library_path\' field. Skipping ICD JSON.", - file_str); - cJSON_Free(temp); - cJSON_Delete(json); - json = NULL; - continue; - } - // strip out extra quotes - temp[strlen(temp) - 1] = '\0'; - char *library_path = loader_stack_alloc(strlen(temp) + 1); - if (NULL == library_path) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_icd_scan: Failed to allocate space for " - "ICD JSON %s \'library_path\' value. Skipping " - "ICD JSON.", - file_str); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - cJSON_Free(temp); - cJSON_Delete(json); - json = NULL; - goto out; - } - strcpy(library_path, &temp[1]); - cJSON_Free(temp); - if (strlen(library_path) == 0) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: ICD JSON %s \'library_path\'" - " field is empty. Skipping ICD JSON.", - file_str); - cJSON_Delete(json); - json = NULL; - continue; - } - char fullpath[MAX_STRING_SIZE]; - // Print out the paths being searched if debugging is enabled - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching for ICD drivers named %s, using default dir %s", - library_path, DEFAULT_VK_DRIVERS_PATH); - if (loader_platform_is_path(library_path)) { - // a relative or absolute path - char *name_copy = loader_stack_alloc(strlen(file_str) + 1); - char *rel_base; - strcpy(name_copy, file_str); - rel_base = loader_platform_dirname(name_copy); - loader_expand_path(library_path, rel_base, sizeof(fullpath), fullpath); - } else { - // a filename which is assumed in a system directory - loader_get_fullpath(library_path, DEFAULT_VK_DRIVERS_PATH, sizeof(fullpath), fullpath); - } - - uint32_t vers = 0; - item = cJSON_GetObjectItem(itemICD, "api_version"); - if (item != NULL) { - temp = cJSON_Print(item); - if (NULL == temp) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: Failed retrieving ICD JSON %s" - " \'api_version\' field. Skipping ICD JSON.", - file_str); - - // Only reason the print can fail is if there was an - // allocation issue - if (num_good_icds == 0) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - } - - cJSON_Free(temp); - cJSON_Delete(json); - json = NULL; - continue; - } - vers = loader_make_version(temp); - cJSON_Free(temp); - } else { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: ICD JSON %s does not have an" - " \'api_version\' field.", - file_str); - } - - res = loader_scanned_icd_add(inst, icd_tramp_list, fullpath, vers); - if (VK_SUCCESS != res) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_icd_scan: Failed to add ICD JSON %s. " - " Skipping ICD JSON.", - fullpath); - cJSON_Delete(json); - json = NULL; - continue; - } - num_good_icds++; - } else { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: Failed to find \'library_path\' " - "object in ICD JSON file %s. Skipping ICD JSON.", - file_str); - } - } else { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_icd_scan: Can not find \'ICD\' object in ICD JSON " - "file %s. Skipping ICD JSON", - file_str); - } - - cJSON_Delete(json); - json = NULL; - } - -out: - - if (NULL != json) { - cJSON_Delete(json); - } - - if (NULL != manifest_files.filename_list) { - for (uint32_t i = 0; i < manifest_files.count; i++) { - if (NULL != manifest_files.filename_list[i]) { - loader_instance_heap_free(inst, manifest_files.filename_list[i]); - } - } - loader_instance_heap_free(inst, manifest_files.filename_list); - } - if (lockedMutex) { - loader_platform_thread_unlock_mutex(&loader_json_lock); - } - - return res; -} - -void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers) { - char *file_str; - struct loader_manifest_files manifest_files[2]; // [0] = explicit, [1] = implicit - cJSON *json; - uint32_t implicit; - bool lockedMutex = false; - - memset(manifest_files, 0, sizeof(struct loader_manifest_files) * 2); - - // Get a list of manifest files for explicit layers - if (VK_SUCCESS != loader_get_manifest_files(inst, LAYERS_PATH_ENV, LAYERS_SOURCE_PATH, true, true, DEFAULT_VK_ELAYERS_INFO, - RELATIVE_VK_ELAYERS_INFO, &manifest_files[0])) { - goto out; - } - - // Get a list of manifest files for any implicit layers - // Pass NULL for environment variable override - implicit layers are not - // overridden by LAYERS_PATH_ENV - if (VK_SUCCESS != loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, RELATIVE_VK_ILAYERS_INFO, - &manifest_files[1])) { - goto out; - } - - // Make sure we have at least one layer, if not, go ahead and return - if (manifest_files[0].count == 0 && manifest_files[1].count == 0) { - goto out; - } - - // cleanup any previously scanned libraries - loader_delete_layer_properties(inst, instance_layers); - - loader_platform_thread_lock_mutex(&loader_json_lock); - lockedMutex = true; - for (implicit = 0; implicit < 2; implicit++) { - for (uint32_t i = 0; i < manifest_files[implicit].count; i++) { - file_str = manifest_files[implicit].filename_list[i]; - if (file_str == NULL) continue; - - // parse file into JSON struct - VkResult res = loader_get_json(inst, file_str, &json); - if (VK_ERROR_OUT_OF_HOST_MEMORY == res) { - break; - } else if (VK_SUCCESS != res || NULL == json) { - continue; - } - - VkResult local_res = loader_add_layer_properties(inst, instance_layers, json, (implicit == 1), file_str); - cJSON_Delete(json); - - // If the error is anything other than out of memory we still want to try to load the other layers - if (VK_ERROR_OUT_OF_HOST_MEMORY == local_res) { - goto out; - } - } - } - - // See if "VK_LAYER_LUNARG_standard_validation" already in list. - bool found_std_val = false; - for (uint32_t i = 0; i < instance_layers->count; i++) { - struct loader_layer_properties *props = &instance_layers->list[i]; - if (strcmp(props->info.layerName, std_validation_str) == 0) { - found_std_val = true; - break; - } - } - - // If we didn't find the VK_LAYER_LUNARG_standard_validation meta-layer in - // the list, then we need to add it manually. This is likely because we're - // dealing with a new loader, but an old layer folder. - if (!found_std_val && !loader_add_legacy_std_val_layer(inst, instance_layers)) { - goto out; - } - - // Verify any meta-layers in the list are valid and all the component layers are - // actually present in the available layer list - verify_all_meta_layers(inst, instance_layers); - -out: - - for (uint32_t manFile = 0; manFile < 2; manFile++) { - if (NULL != manifest_files[manFile].filename_list) { - for (uint32_t i = 0; i < manifest_files[manFile].count; i++) { - if (NULL != manifest_files[manFile].filename_list[i]) { - loader_instance_heap_free(inst, manifest_files[manFile].filename_list[i]); - } - } - loader_instance_heap_free(inst, manifest_files[manFile].filename_list); - } - } - if (lockedMutex) { - loader_platform_thread_unlock_mutex(&loader_json_lock); - } -} - -void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers) { - char *file_str; - struct loader_manifest_files manifest_files; - cJSON *json; - uint32_t i; - - // Pass NULL for environment variable override - implicit layers are not - // overridden by LAYERS_PATH_ENV - VkResult res = loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, RELATIVE_VK_ILAYERS_INFO, - &manifest_files); - if (VK_SUCCESS != res || manifest_files.count == 0) { - return; - } - - // Cleanup any previously scanned libraries - loader_delete_layer_properties(inst, instance_layers); - - loader_platform_thread_lock_mutex(&loader_json_lock); - - for (i = 0; i < manifest_files.count; i++) { - file_str = manifest_files.filename_list[i]; - if (file_str == NULL) { - continue; - } - - // parse file into JSON struct - res = loader_get_json(inst, file_str, &json); - if (VK_ERROR_OUT_OF_HOST_MEMORY == res) { - break; - } else if (VK_SUCCESS != res || NULL == json) { - continue; - } - - res = loader_add_layer_properties(inst, instance_layers, json, true, file_str); - - loader_instance_heap_free(inst, file_str); - cJSON_Delete(json); - - if (VK_ERROR_OUT_OF_HOST_MEMORY == res) { - break; - } - } - loader_instance_heap_free(inst, manifest_files.filename_list); - loader_platform_thread_unlock_mutex(&loader_json_lock); -} - -// Check if an implicit layer should be enabled. -bool loader_is_implicit_layer_enabled(const struct loader_instance *inst, const struct loader_layer_properties *prop) { - bool enable = false; - char *env_value = NULL; - - // if no enable_environment variable is specified, this implicit layer - // should always be enabled. Otherwise check if the variable is set - if (prop->enable_env_var.name[0] == 0) { - enable = true; - } else { - env_value = loader_secure_getenv(prop->enable_env_var.name, inst); - if (env_value && !strcmp(prop->enable_env_var.value, env_value)) enable = true; - loader_free_getenv(env_value, inst); - } - - // disable_environment has priority, i.e. if both enable and disable - // environment variables are set, the layer is disabled. Implicit - // layers are required to have a disable_environment variables - env_value = loader_secure_getenv(prop->disable_env_var.name, inst); - if (env_value && !strcmp(prop->disable_env_var.value, env_value)) enable = false; - loader_free_getenv(env_value, inst); - - return enable; -} - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpdpa_instance_internal(VkInstance inst, const char *pName) { - // inst is not wrapped - if (inst == VK_NULL_HANDLE) { - return NULL; - } - VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst; - void *addr; - - if (disp_table == NULL) return NULL; - - bool found_name; - addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name); - if (found_name) { - return addr; - } - - if (loader_phys_dev_ext_gpa(loader_get_instance(inst), pName, true, NULL, &addr)) return addr; - - // Don't call down the chain, this would be an infinite loop - loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpdpa_instance_internal() unrecognized name %s", pName); - return NULL; -} - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpdpa_instance_terminator(VkInstance inst, const char *pName) { - // inst is not wrapped - if (inst == VK_NULL_HANDLE) { - return NULL; - } - VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst; - void *addr; - - if (disp_table == NULL) return NULL; - - bool found_name; - addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name); - if (found_name) { - return addr; - } - - // Get the terminator, but don't perform checking since it should already - // have been setup if we get here. - if (loader_phys_dev_ext_gpa(loader_get_instance(inst), pName, false, NULL, &addr)) { - return addr; - } - - // Don't call down the chain, this would be an infinite loop - loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpdpa_instance_terminator() unrecognized name %s", pName); - return NULL; -} - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_instance_internal(VkInstance inst, const char *pName) { - if (!strcmp(pName, "vkGetInstanceProcAddr")) { - return (PFN_vkVoidFunction)loader_gpa_instance_internal; - } - if (!strcmp(pName, "vk_layerGetPhysicalDeviceProcAddr")) { - return (PFN_vkVoidFunction)loader_gpdpa_instance_terminator; - } - if (!strcmp(pName, "vkCreateInstance")) { - return (PFN_vkVoidFunction)terminator_CreateInstance; - } - if (!strcmp(pName, "vkCreateDevice")) { - return (PFN_vkVoidFunction)terminator_CreateDevice; - } - - // inst is not wrapped - if (inst == VK_NULL_HANDLE) { - return NULL; - } - VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst; - void *addr; - - if (disp_table == NULL) return NULL; - - bool found_name; - addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name); - if (found_name) { - return addr; - } - - // Don't call down the chain, this would be an infinite loop - loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpa_instance_internal() unrecognized name %s", pName); - return NULL; -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_device_internal(VkDevice device, const char *pName) { - struct loader_device *dev; - struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL); - - // Return this function if a layer above here is asking for the vkGetDeviceProcAddr. - // This is so we can properly intercept any device commands needing a terminator. - if (!strcmp(pName, "vkGetDeviceProcAddr")) { - return (PFN_vkVoidFunction)loader_gpa_device_internal; - } - - // NOTE: Device Funcs needing Trampoline/Terminator. - // Overrides for device functions needing a trampoline and - // a terminator because certain device entry-points still need to go - // through a terminator before hitting the ICD. This could be for - // several reasons, but the main one is currently unwrapping an - // object before passing the appropriate info along to the ICD. - // This is why we also have to override the direct ICD call to - // vkGetDeviceProcAddr to intercept those calls. - PFN_vkVoidFunction addr = get_extension_device_proc_terminator(dev, pName); - if (NULL != addr) { - return addr; - } - - return icd_term->dispatch.GetDeviceProcAddr(device, pName); -} - -// Initialize device_ext dispatch table entry as follows: -// If dev == NULL find all logical devices created within this instance and -// init the entry (given by idx) in the ext dispatch table. -// If dev != NULL only initialize the entry in the given dev's dispatch table. -// The initialization value is gotten by calling down the device chain with -// GDPA. -// If GDPA returns NULL then don't initialize the dispatch table entry. -static void loader_init_dispatch_dev_ext_entry(struct loader_instance *inst, struct loader_device *dev, uint32_t idx, - const char *funcName) - -{ - void *gdpa_value; - if (dev != NULL) { - gdpa_value = dev->loader_dispatch.core_dispatch.GetDeviceProcAddr(dev->chain_device, funcName); - if (gdpa_value != NULL) dev->loader_dispatch.ext_dispatch.dev_ext[idx] = (PFN_vkDevExt)gdpa_value; - } else { - for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next) { - struct loader_device *ldev = icd_term->logical_device_list; - while (ldev) { - gdpa_value = ldev->loader_dispatch.core_dispatch.GetDeviceProcAddr(ldev->chain_device, funcName); - if (gdpa_value != NULL) ldev->loader_dispatch.ext_dispatch.dev_ext[idx] = (PFN_vkDevExt)gdpa_value; - ldev = ldev->next; - } - } - } -} - -// Find all dev extension in the hash table and initialize the dispatch table -// for dev for each of those extension entrypoints found in hash table. -void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev) { - for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) { - if (inst->dev_ext_disp_hash[i].func_name != NULL) - loader_init_dispatch_dev_ext_entry(inst, dev, i, inst->dev_ext_disp_hash[i].func_name); - } -} - -static bool loader_check_icds_for_dev_ext_address(struct loader_instance *inst, const char *funcName) { - struct loader_icd_term *icd_term; - icd_term = inst->icd_terms; - while (NULL != icd_term) { - if (icd_term->scanned_icd->GetInstanceProcAddr(icd_term->instance, funcName)) - // this icd supports funcName - return true; - icd_term = icd_term->next; - } - - return false; -} - -static bool loader_check_layer_list_for_dev_ext_address(const struct loader_layer_list *const layers, const char *funcName) { - // Iterate over the layers. - for (uint32_t layer = 0; layer < layers->count; ++layer) { - // Iterate over the extensions. - const struct loader_device_extension_list *const extensions = &(layers->list[layer].device_extension_list); - for (uint32_t extension = 0; extension < extensions->count; ++extension) { - // Iterate over the entry points. - const struct loader_dev_ext_props *const property = &(extensions->list[extension]); - for (uint32_t entry = 0; entry < property->entrypoint_count; ++entry) { - if (strcmp(property->entrypoints[entry], funcName) == 0) { - return true; - } - } - } - } - - return false; -} - -static void loader_free_dev_ext_table(struct loader_instance *inst) { - for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) { - loader_instance_heap_free(inst, inst->dev_ext_disp_hash[i].func_name); - loader_instance_heap_free(inst, inst->dev_ext_disp_hash[i].list.index); - } - memset(inst->dev_ext_disp_hash, 0, sizeof(inst->dev_ext_disp_hash)); -} - -static bool loader_add_dev_ext_table(struct loader_instance *inst, uint32_t *ptr_idx, const char *funcName) { - uint32_t i; - uint32_t idx = *ptr_idx; - struct loader_dispatch_hash_list *list = &inst->dev_ext_disp_hash[idx].list; - - if (!inst->dev_ext_disp_hash[idx].func_name) { - // no entry here at this idx, so use it - assert(list->capacity == 0); - inst->dev_ext_disp_hash[idx].func_name = - (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (inst->dev_ext_disp_hash[idx].func_name == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_dev_ext_table: Failed to allocate memory " - "for func_name %s", - funcName); - return false; - } - strncpy(inst->dev_ext_disp_hash[idx].func_name, funcName, strlen(funcName) + 1); - return true; - } - - // check for enough capacity - if (list->capacity == 0) { - list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (list->index == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table: Failed to allocate memory for list index", - funcName); - return false; - } - list->capacity = 8 * sizeof(*(list->index)); - } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) { - void *new_ptr = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_ptr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_dev_ext_table: Failed to reallocate memory for list index", funcName); - return false; - } - list->index = new_ptr; - list->capacity *= 2; - } - - // find an unused index in the hash table and use it - i = (idx + 1) % MAX_NUM_UNKNOWN_EXTS; - do { - if (!inst->dev_ext_disp_hash[i].func_name) { - assert(inst->dev_ext_disp_hash[i].list.capacity == 0); - inst->dev_ext_disp_hash[i].func_name = - (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (inst->dev_ext_disp_hash[i].func_name == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_dev_ext_table: Failed to allocate memory " - "for func_name %s", - funcName); - return false; - } - strncpy(inst->dev_ext_disp_hash[i].func_name, funcName, strlen(funcName) + 1); - list->index[list->count] = i; - list->count++; - *ptr_idx = i; - return true; - } - i = (i + 1) % MAX_NUM_UNKNOWN_EXTS; - } while (i != idx); - - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_dev_ext_table: Could not insert into hash table; is " - "it full?"); - - return false; -} - -static bool loader_name_in_dev_ext_table(struct loader_instance *inst, uint32_t *idx, const char *funcName) { - uint32_t alt_idx; - if (inst->dev_ext_disp_hash[*idx].func_name && !strcmp(inst->dev_ext_disp_hash[*idx].func_name, funcName)) return true; - - // funcName wasn't at the primary spot in the hash table - // search the list of secondary locations (shallow search, not deep search) - for (uint32_t i = 0; i < inst->dev_ext_disp_hash[*idx].list.count; i++) { - alt_idx = inst->dev_ext_disp_hash[*idx].list.index[i]; - if (!strcmp(inst->dev_ext_disp_hash[*idx].func_name, funcName)) { - *idx = alt_idx; - return true; - } - } - - return false; -} - -// This function returns generic trampoline code address for unknown entry -// points. -// Presumably, these unknown entry points (as given by funcName) are device -// extension entrypoints. A hash table is used to keep a list of unknown entry -// points and their mapping to the device extension dispatch table -// (struct loader_dev_ext_dispatch_table). -// \returns -// For a given entry point string (funcName), if an existing mapping is found -// the -// trampoline address for that mapping is returned. Otherwise, this unknown -// entry point -// has not been seen yet. Next check if a layer or ICD supports it. If so then -// a -// new entry in the hash table is initialized and that trampoline address for -// the new entry is returned. Null is returned if the hash table is full or -// if no discovered layer or ICD returns a non-NULL GetProcAddr for it. -void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName) { - uint32_t idx; - uint32_t seed = 0; - - idx = murmurhash(funcName, strlen(funcName), seed) % MAX_NUM_UNKNOWN_EXTS; - - if (loader_name_in_dev_ext_table(inst, &idx, funcName)) - // found funcName already in hash - return loader_get_dev_ext_trampoline(idx); - - // Check if funcName is supported in either ICDs or a layer library - if (!loader_check_icds_for_dev_ext_address(inst, funcName) && - !loader_check_layer_list_for_dev_ext_address(&inst->app_activated_layer_list, funcName)) { - // if support found in layers continue on - return NULL; - } - - if (loader_add_dev_ext_table(inst, &idx, funcName)) { - // successfully added new table entry - // init any dev dispatch table entries as needed - loader_init_dispatch_dev_ext_entry(inst, NULL, idx, funcName); - return loader_get_dev_ext_trampoline(idx); - } - - return NULL; -} - -static bool loader_check_icds_for_phys_dev_ext_address(struct loader_instance *inst, const char *funcName) { - struct loader_icd_term *icd_term; - icd_term = inst->icd_terms; - while (NULL != icd_term) { - if (icd_term->scanned_icd->interface_version >= MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION && - icd_term->scanned_icd->GetPhysicalDeviceProcAddr(icd_term->instance, funcName)) - // this icd supports funcName - return true; - icd_term = icd_term->next; - } - - return false; -} - -static bool loader_check_layer_list_for_phys_dev_ext_address(struct loader_instance *inst, const char *funcName) { - struct loader_layer_properties *layer_prop_list = inst->expanded_activated_layer_list.list; - for (uint32_t layer = 0; layer < inst->expanded_activated_layer_list.count; ++layer) { - // If this layer supports the vk_layerGetPhysicalDeviceProcAddr, then call - // it and see if it returns a valid pointer for this function name. - if (layer_prop_list[layer].interface_version > 1) { - const struct loader_layer_functions *const functions = &(layer_prop_list[layer].functions); - if (NULL != functions->get_physical_device_proc_addr && - NULL != functions->get_physical_device_proc_addr((VkInstance)inst->instance, funcName)) { - return true; - } - } - } - - return false; -} - -static void loader_free_phys_dev_ext_table(struct loader_instance *inst) { - for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) { - loader_instance_heap_free(inst, inst->phys_dev_ext_disp_hash[i].func_name); - loader_instance_heap_free(inst, inst->phys_dev_ext_disp_hash[i].list.index); - } - memset(inst->phys_dev_ext_disp_hash, 0, sizeof(inst->phys_dev_ext_disp_hash)); -} - -static bool loader_add_phys_dev_ext_table(struct loader_instance *inst, uint32_t *ptr_idx, const char *funcName) { - uint32_t i; - uint32_t idx = *ptr_idx; - struct loader_dispatch_hash_list *list = &inst->phys_dev_ext_disp_hash[idx].list; - - if (!inst->phys_dev_ext_disp_hash[idx].func_name) { - // no entry here at this idx, so use it - assert(list->capacity == 0); - inst->phys_dev_ext_disp_hash[idx].func_name = - (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (inst->phys_dev_ext_disp_hash[idx].func_name == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_phys_dev_ext_table() can't allocate memory for " - "func_name"); - return false; - } - strncpy(inst->phys_dev_ext_disp_hash[idx].func_name, funcName, strlen(funcName) + 1); - return true; - } - - // check for enough capacity - if (list->capacity == 0) { - list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (list->index == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't allocate list memory"); - return false; - } - list->capacity = 8 * sizeof(*(list->index)); - } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) { - void *new_ptr = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_ptr) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't reallocate list memory"); - return false; - } - list->index = new_ptr; - list->capacity *= 2; - } - - // find an unused index in the hash table and use it - i = (idx + 1) % MAX_NUM_UNKNOWN_EXTS; - do { - if (!inst->phys_dev_ext_disp_hash[i].func_name) { - assert(inst->phys_dev_ext_disp_hash[i].list.capacity == 0); - inst->phys_dev_ext_disp_hash[i].func_name = - (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (inst->phys_dev_ext_disp_hash[i].func_name == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_dev_ext_table() can't reallocate " - "func_name memory"); - return false; - } - strncpy(inst->phys_dev_ext_disp_hash[i].func_name, funcName, strlen(funcName) + 1); - list->index[list->count] = i; - list->count++; - *ptr_idx = i; - return true; - } - i = (i + 1) % MAX_NUM_UNKNOWN_EXTS; - } while (i != idx); - - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_phys_dev_ext_table() couldn't insert into hash table; is " - "it full?"); - return false; -} - -static bool loader_name_in_phys_dev_ext_table(struct loader_instance *inst, uint32_t *idx, const char *funcName) { - uint32_t alt_idx; - if (inst->phys_dev_ext_disp_hash[*idx].func_name && !strcmp(inst->phys_dev_ext_disp_hash[*idx].func_name, funcName)) - return true; - - // funcName wasn't at the primary spot in the hash table - // search the list of secondary locations (shallow search, not deep search) - for (uint32_t i = 0; i < inst->phys_dev_ext_disp_hash[*idx].list.count; i++) { - alt_idx = inst->phys_dev_ext_disp_hash[*idx].list.index[i]; - if (!strcmp(inst->phys_dev_ext_disp_hash[*idx].func_name, funcName)) { - *idx = alt_idx; - return true; - } - } - - return false; -} - -// This function returns a generic trampoline and/or terminator function -// address for any unknown physical device extension commands. A hash -// table is used to keep a list of unknown entry points and their -// mapping to the physical device extension dispatch table (struct -// loader_phys_dev_ext_dispatch_table). -// For a given entry point string (funcName), if an existing mapping is -// found, then the trampoline address for that mapping is returned in -// tramp_addr (if it is not NULL) and the terminator address for that -// mapping is returned in term_addr (if it is not NULL). Otherwise, -// this unknown entry point has not been seen yet. -// If it has not been seen before, and perform_checking is 'true', -// check if a layer or and ICD supports it. If so then a new entry in -// the hash table is initialized and the trampoline and/or terminator -// addresses are returned. -// Null is returned if the hash table is full or if no discovered layer or -// ICD returns a non-NULL GetProcAddr for it. -bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr, - void **term_addr) { - uint32_t idx; - uint32_t seed = 0; - bool success = false; - - if (inst == NULL) { - goto out; - } - - if (NULL != tramp_addr) { - *tramp_addr = NULL; - } - if (NULL != term_addr) { - *term_addr = NULL; - } - - // We should always check to see if any ICD supports it. - if (!loader_check_icds_for_phys_dev_ext_address(inst, funcName)) { - // If we're not checking layers, or we are and it's not in a layer, just - // return - if (!perform_checking || !loader_check_layer_list_for_phys_dev_ext_address(inst, funcName)) { - goto out; - } - } - - idx = murmurhash(funcName, strlen(funcName), seed) % MAX_NUM_UNKNOWN_EXTS; - if (perform_checking && !loader_name_in_phys_dev_ext_table(inst, &idx, funcName)) { - uint32_t i; - bool added = false; - - // Only need to add first one to get index in Instance. Others will use - // the same index. - if (!added && loader_add_phys_dev_ext_table(inst, &idx, funcName)) { - added = true; - } - - // Setup the ICD function pointers - struct loader_icd_term *icd_term = inst->icd_terms; - while (NULL != icd_term) { - if (MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION <= icd_term->scanned_icd->interface_version && - NULL != icd_term->scanned_icd->GetPhysicalDeviceProcAddr) { - icd_term->phys_dev_ext[idx] = - (PFN_PhysDevExt)icd_term->scanned_icd->GetPhysicalDeviceProcAddr(icd_term->instance, funcName); - - // Make sure we set the instance dispatch to point to the - // loader's terminator now since we can at least handle it - // in one ICD. - inst->disp->phys_dev_ext[idx] = loader_get_phys_dev_ext_termin(idx); - } else { - icd_term->phys_dev_ext[idx] = NULL; - } - - icd_term = icd_term->next; - } - - // Now, search for the first layer attached and query using it to get - // the first entry point. - for (i = 0; i < inst->expanded_activated_layer_list.count; i++) { - struct loader_layer_properties *layer_prop = &inst->expanded_activated_layer_list.list[i]; - if (layer_prop->interface_version > 1 && NULL != layer_prop->functions.get_physical_device_proc_addr) { - inst->disp->phys_dev_ext[idx] = - (PFN_PhysDevExt)layer_prop->functions.get_physical_device_proc_addr((VkInstance)inst->instance, funcName); - if (NULL != inst->disp->phys_dev_ext[idx]) { - break; - } - } - } - } - - if (NULL != tramp_addr) { - *tramp_addr = loader_get_phys_dev_ext_tramp(idx); - } - - if (NULL != term_addr) { - *term_addr = loader_get_phys_dev_ext_termin(idx); - } - - success = true; - -out: - return success; -} - -struct loader_instance *loader_get_instance(const VkInstance instance) { - // look up the loader_instance in our list by comparing dispatch tables, as - // there is no guarantee the instance is still a loader_instance* after any - // layers which wrap the instance object. - const VkLayerInstanceDispatchTable *disp; - struct loader_instance *ptr_instance = NULL; - disp = loader_get_instance_layer_dispatch(instance); - for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) { - if (&inst->disp->layer_inst_disp == disp) { - ptr_instance = inst; - break; - } - } - return ptr_instance; -} - -static loader_platform_dl_handle loader_open_layer_lib(const struct loader_instance *inst, const char *chain_type, - struct loader_layer_properties *prop) { - if ((prop->lib_handle = loader_platform_open_library(prop->lib_name)) == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, loader_platform_open_library_error(prop->lib_name)); - } else { - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Loading layer library %s", prop->lib_name); - } - - return prop->lib_handle; -} - -static void loader_close_layer_lib(const struct loader_instance *inst, struct loader_layer_properties *prop) { - if (prop->lib_handle) { - loader_platform_close_library(prop->lib_handle); - loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Unloading layer library %s", prop->lib_name); - prop->lib_handle = NULL; - } -} - -void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device, - struct loader_layer_list *list) { - // Delete instance list of enabled layers and close any layer libraries - for (uint32_t i = 0; i < list->count; i++) { - struct loader_layer_properties *layer_prop = &list->list[i]; - - loader_close_layer_lib(instance, layer_prop); - } - loader_destroy_layer_list(instance, device, list); -} - -// Go through the search_list and find any layers which match type. If layer -// type match is found in then add it to ext_list. -static void loader_add_implicit_layers(const struct loader_instance *inst, struct loader_layer_list *target_list, - struct loader_layer_list *expanded_target_list, - const struct loader_layer_list *source_list) { - for (uint32_t src_layer = 0; src_layer < source_list->count; src_layer++) { - const struct loader_layer_properties *prop = &source_list->list[src_layer]; - if (0 == (prop->type_flags & VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER)) { - loader_add_implicit_layer(inst, prop, target_list, expanded_target_list, source_list); - } - } -} - -// Get the layer name(s) from the env_name environment variable. If layer is found in -// search_list then add it to layer_list. But only add it to layer_list if type_flags matches. -static void loader_add_env_layers(const struct loader_instance *inst, const enum layer_type_flags type_flags, const char *env_name, - struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, - const struct loader_layer_list *source_list) { - char *next, *name; - char *layer_env = loader_secure_getenv(env_name, inst); - if (layer_env == NULL) { - goto out; - } - name = loader_stack_alloc(strlen(layer_env) + 1); - if (name == NULL) { - goto out; - } - strcpy(name, layer_env); - - while (name && *name) { - next = loader_get_next_path(name); - loader_find_layer_name_add_list(inst, name, type_flags, source_list, target_list, expanded_target_list); - name = next; - } - -out: - - if (layer_env != NULL) { - loader_free_getenv(layer_env, inst); - } - - return; -} - -VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo, - const struct loader_layer_list *instance_layers) { - VkResult err; - uint16_t layer_api_major_version; - uint16_t layer_api_minor_version; - uint32_t i; - struct loader_layer_properties *prop; - - assert(inst && "Cannot have null instance"); - - if (!loader_init_layer_list(inst, &inst->app_activated_layer_list)) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_enable_instance_layers: Failed to initialize" - " application version of the layer list"); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - if (!loader_init_layer_list(inst, &inst->expanded_activated_layer_list)) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_enable_instance_layers: Failed to initialize" - " expanded version of the layer list"); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - // Add any implicit layers first - loader_add_implicit_layers(inst, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list, instance_layers); - - // Add any layers specified via environment variable next - loader_add_env_layers(inst, VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER, ENABLED_LAYERS_ENV, &inst->app_activated_layer_list, - &inst->expanded_activated_layer_list, instance_layers); - - // Add layers specified by the application - err = loader_add_layer_names_to_list(inst, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list, - pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, instance_layers); - - for (i = 0; i < inst->expanded_activated_layer_list.count; i++) { - // Verify that the layer api version is at least that of the application's request, if not, throw a warning since - // undefined behavior could occur. - prop = inst->expanded_activated_layer_list.list + i; - layer_api_major_version = VK_VERSION_MAJOR(prop->info.specVersion); - layer_api_minor_version = VK_VERSION_MINOR(prop->info.specVersion); - if (inst->app_api_major_version > layer_api_major_version || - (inst->app_api_major_version == layer_api_major_version && inst->app_api_minor_version > layer_api_minor_version)) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_add_to_layer_list: Explicit layer %s is using an old API version %" PRIu16 ".%" PRIu16 - " versus application requested %" PRIu16 ".%" PRIu16, - prop->info.layerName, layer_api_major_version, layer_api_minor_version, inst->app_api_major_version, - inst->app_api_minor_version); - } - } - - return err; -} - -// Determine the layer interface version to use. -bool loader_get_layer_interface_version(PFN_vkNegotiateLoaderLayerInterfaceVersion fp_negotiate_layer_version, - VkNegotiateLayerInterface *interface_struct) { - memset(interface_struct, 0, sizeof(VkNegotiateLayerInterface)); - interface_struct->sType = LAYER_NEGOTIATE_INTERFACE_STRUCT; - interface_struct->loaderLayerInterfaceVersion = 1; - - if (fp_negotiate_layer_version != NULL) { - // Layer supports the negotiation API, so call it with the loader's - // latest version supported - interface_struct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION; - VkResult result = fp_negotiate_layer_version(interface_struct); - - if (result != VK_SUCCESS) { - // Layer no longer supports the loader's latest interface version so - // fail loading the Layer - return false; - } - } - - if (interface_struct->loaderLayerInterfaceVersion < MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION) { - // Loader no longer supports the layer's latest interface version so - // fail loading the layer - return false; - } - - return true; -} - -// Given the list of layers to activate in the loader_instance -// structure. This function will add a VkLayerInstanceCreateInfo -// structure to the VkInstanceCreateInfo.pNext pointer. -// Each activated layer will have it's own VkLayerInstanceLink -// structure that tells the layer what Get*ProcAddr to call to -// get function pointers to the next layer down. -// Once the chain info has been created this function will -// execute the CreateInstance call chain. Each layer will -// then have an opportunity in it's CreateInstance function -// to setup it's dispatch table when the lower layer returns -// successfully. -// Each layer can wrap or not-wrap the returned VkInstance object -// as it sees fit. -// The instance chain is terminated by a loader function -// that will call CreateInstance on all available ICD's and -// cache those VkInstance objects for future use. -VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - struct loader_instance *inst, VkInstance *created_instance) { - uint32_t activated_layers = 0; - VkLayerInstanceCreateInfo chain_info; - VkLayerInstanceLink *layer_instance_link_info = NULL; - VkInstanceCreateInfo loader_create_info; - VkResult res; - - PFN_vkGetInstanceProcAddr next_gipa = loader_gpa_instance_internal; - PFN_vkGetInstanceProcAddr cur_gipa = loader_gpa_instance_internal; - PFN_GetPhysicalDeviceProcAddr next_gpdpa = loader_gpdpa_instance_internal; - PFN_GetPhysicalDeviceProcAddr cur_gpdpa = loader_gpdpa_instance_internal; - - memcpy(&loader_create_info, pCreateInfo, sizeof(VkInstanceCreateInfo)); - - if (inst->expanded_activated_layer_list.count > 0) { - chain_info.u.pLayerInfo = NULL; - chain_info.pNext = pCreateInfo->pNext; - chain_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO; - chain_info.function = VK_LAYER_LINK_INFO; - loader_create_info.pNext = &chain_info; - - layer_instance_link_info = loader_stack_alloc(sizeof(VkLayerInstanceLink) * inst->expanded_activated_layer_list.count); - if (!layer_instance_link_info) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_create_instance_chain: Failed to alloc Instance" - " objects for layer"); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - // Create instance chain of enabled layers - for (int32_t i = inst->expanded_activated_layer_list.count - 1; i >= 0; i--) { - struct loader_layer_properties *layer_prop = &inst->expanded_activated_layer_list.list[i]; - loader_platform_dl_handle lib_handle; - - lib_handle = loader_open_layer_lib(inst, "instance", layer_prop); - if (!lib_handle) { - continue; - } - - if (NULL == layer_prop->functions.negotiate_layer_interface) { - PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface = NULL; - bool functions_in_interface = false; - if (strlen(layer_prop->functions.str_negotiate_interface) == 0) { - negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address( - lib_handle, "vkNegotiateLoaderLayerInterfaceVersion"); - } else { - negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address( - lib_handle, layer_prop->functions.str_negotiate_interface); - } - - // If we can negotiate an interface version, then we can also - // get everything we need from the one function call, so try - // that first, and see if we can get all the function pointers - // necessary from that one call. - if (NULL != negotiate_interface) { - layer_prop->functions.negotiate_layer_interface = negotiate_interface; - - VkNegotiateLayerInterface interface_struct; - - if (loader_get_layer_interface_version(negotiate_interface, &interface_struct)) { - // Go ahead and set the properties version to the - // correct value. - layer_prop->interface_version = interface_struct.loaderLayerInterfaceVersion; - - // If the interface is 2 or newer, we have access to the - // new GetPhysicalDeviceProcAddr function, so grab it, - // and the other necessary functions, from the - // structure. - if (interface_struct.loaderLayerInterfaceVersion > 1) { - cur_gipa = interface_struct.pfnGetInstanceProcAddr; - cur_gpdpa = interface_struct.pfnGetPhysicalDeviceProcAddr; - if (cur_gipa != NULL) { - // We've set the functions, so make sure we - // don't do the unnecessary calls later. - functions_in_interface = true; - } - } - } - } - - if (!functions_in_interface) { - if ((cur_gipa = layer_prop->functions.get_instance_proc_addr) == NULL) { - if (strlen(layer_prop->functions.str_gipa) == 0) { - cur_gipa = - (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetInstanceProcAddr"); - layer_prop->functions.get_instance_proc_addr = cur_gipa; - } else { - cur_gipa = (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, - layer_prop->functions.str_gipa); - } - - if (NULL == cur_gipa) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_create_instance_chain: Failed to" - " find \'vkGetInstanceProcAddr\' in " - "layer %s", - layer_prop->lib_name); - continue; - } - } - } - } - - layer_instance_link_info[activated_layers].pNext = chain_info.u.pLayerInfo; - layer_instance_link_info[activated_layers].pfnNextGetInstanceProcAddr = next_gipa; - layer_instance_link_info[activated_layers].pfnNextGetPhysicalDeviceProcAddr = next_gpdpa; - next_gipa = cur_gipa; - if (layer_prop->interface_version > 1 && cur_gpdpa != NULL) { - layer_prop->functions.get_physical_device_proc_addr = cur_gpdpa; - next_gpdpa = cur_gpdpa; - } - - chain_info.u.pLayerInfo = &layer_instance_link_info[activated_layers]; - - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Insert instance layer %s (%s)", layer_prop->info.layerName, - layer_prop->lib_name); - - activated_layers++; - } - } - - PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)next_gipa(*created_instance, "vkCreateInstance"); - if (fpCreateInstance) { - VkLayerInstanceCreateInfo create_info_disp; - - create_info_disp.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO; - create_info_disp.function = VK_LOADER_DATA_CALLBACK; - - create_info_disp.u.pfnSetInstanceLoaderData = vkSetInstanceDispatch; - - create_info_disp.pNext = loader_create_info.pNext; - loader_create_info.pNext = &create_info_disp; - res = fpCreateInstance(&loader_create_info, pAllocator, created_instance); - } else { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_create_instance_chain: Failed to find " - "\'vkCreateInstance\'"); - // Couldn't find CreateInstance function! - res = VK_ERROR_INITIALIZATION_FAILED; - } - - if (res == VK_SUCCESS) { - loader_init_instance_core_dispatch_table(&inst->disp->layer_inst_disp, next_gipa, *created_instance); - inst->instance = *created_instance; - } - - return res; -} - -void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst) { - loader_init_instance_extension_dispatch_table(&inst->disp->layer_inst_disp, inst->disp->layer_inst_disp.GetInstanceProcAddr, - created_inst); -} - -VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst, - struct loader_device *dev) { - uint32_t activated_layers = 0; - VkLayerDeviceLink *layer_device_link_info; - VkLayerDeviceCreateInfo chain_info; - VkDeviceCreateInfo loader_create_info; - VkResult res; - - PFN_vkGetDeviceProcAddr fpGDPA = NULL, nextGDPA = loader_gpa_device_internal; - PFN_vkGetInstanceProcAddr fpGIPA = NULL, nextGIPA = loader_gpa_instance_internal; - - memcpy(&loader_create_info, pCreateInfo, sizeof(VkDeviceCreateInfo)); - - // Before we continue, we need to find out if the KHR_device_group extension is in the enabled list. If it is, we then - // need to look for the corresponding VkDeviceGroupDeviceCreateInfoKHR struct in the device list. This is because we - // need to replace all the incoming physical device values (which are really loader trampoline physical device values) - // with the layer/ICD version. - { - struct VkStructureHeader *pNext = (struct VkStructureHeader *)loader_create_info.pNext; - struct VkStructureHeader *pPrev = (struct VkStructureHeader *)&loader_create_info; - while (NULL != pNext) { - if (VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO == pNext->sType) { - VkDeviceGroupDeviceCreateInfoKHR *cur_struct = (VkDeviceGroupDeviceCreateInfoKHR *)pNext; - if (0 < cur_struct->physicalDeviceCount && NULL != cur_struct->pPhysicalDevices) { - VkDeviceGroupDeviceCreateInfoKHR *temp_struct = loader_stack_alloc(sizeof(VkDeviceGroupDeviceCreateInfoKHR)); - VkPhysicalDevice *phys_dev_array = NULL; - if (NULL == temp_struct) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memcpy(temp_struct, cur_struct, sizeof(VkDeviceGroupDeviceCreateInfoKHR)); - phys_dev_array = loader_stack_alloc(sizeof(VkPhysicalDevice) * cur_struct->physicalDeviceCount); - if (NULL == phys_dev_array) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - // Before calling down, replace the incoming physical device values (which are really loader trampoline - // physical devices) with the next layer (or possibly even the terminator) physical device values. - struct loader_physical_device_tramp *cur_tramp; - for (uint32_t phys_dev = 0; phys_dev < cur_struct->physicalDeviceCount; phys_dev++) { - cur_tramp = (struct loader_physical_device_tramp *)cur_struct->pPhysicalDevices[phys_dev]; - phys_dev_array[phys_dev] = cur_tramp->phys_dev; - } - temp_struct->pPhysicalDevices = phys_dev_array; - - // Replace the old struct in the pNext chain with this one. - pPrev->pNext = (const void *)temp_struct; - pNext = (struct VkStructureHeader *)(temp_struct); - } - break; - } - - pPrev = pNext; - pNext = (struct VkStructureHeader *)(pPrev->pNext); - } - } - - layer_device_link_info = loader_stack_alloc(sizeof(VkLayerDeviceLink) * dev->expanded_activated_layer_list.count); - if (!layer_device_link_info) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_create_device_chain: Failed to alloc Device objects" - " for layer. Skipping Layer."); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - if (dev->expanded_activated_layer_list.count > 0) { - chain_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO; - chain_info.function = VK_LAYER_LINK_INFO; - chain_info.u.pLayerInfo = NULL; - chain_info.pNext = loader_create_info.pNext; - loader_create_info.pNext = &chain_info; - - // Create instance chain of enabled layers - for (int32_t i = dev->expanded_activated_layer_list.count - 1; i >= 0; i--) { - struct loader_layer_properties *layer_prop = &dev->expanded_activated_layer_list.list[i]; - loader_platform_dl_handle lib_handle; - bool functions_in_interface = false; - - lib_handle = loader_open_layer_lib(inst, "device", layer_prop); - if (!lib_handle) { - continue; - } - - // If we can negotiate an interface version, then we can also get everything we need from the one function - // call, so try that first, and see if we can get all the function pointers necessary from that one call. - if (NULL == layer_prop->functions.negotiate_layer_interface) { - PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface = NULL; - if (strlen(layer_prop->functions.str_negotiate_interface) == 0) { - negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address( - lib_handle, "vkNegotiateLoaderLayerInterfaceVersion"); - } else { - negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address( - lib_handle, layer_prop->functions.str_negotiate_interface); - } - - if (NULL != negotiate_interface) { - layer_prop->functions.negotiate_layer_interface = negotiate_interface; - - VkNegotiateLayerInterface interface_struct; - - if (loader_get_layer_interface_version(negotiate_interface, &interface_struct)) { - // Go ahead and set the properties version to the correct value. - layer_prop->interface_version = interface_struct.loaderLayerInterfaceVersion; - - // If the interface is 2 or newer, we have access to the new GetPhysicalDeviceProcAddr - // function, so grab it, and the other necessary functions, from the structure. - if (interface_struct.loaderLayerInterfaceVersion > 1) { - fpGIPA = interface_struct.pfnGetInstanceProcAddr; - fpGDPA = interface_struct.pfnGetDeviceProcAddr; - if (fpGIPA != NULL && fpGDPA) { - // We've set the functions, so make sure we - // don't do the unnecessary calls later. - functions_in_interface = true; - } - } - } - } - } - - if (!functions_in_interface) { - if ((fpGIPA = layer_prop->functions.get_instance_proc_addr) == NULL) { - if (strlen(layer_prop->functions.str_gipa) == 0) { - fpGIPA = (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetInstanceProcAddr"); - layer_prop->functions.get_instance_proc_addr = fpGIPA; - } else - fpGIPA = - (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gipa); - if (!fpGIPA) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_create_device_chain: Failed to find " - "\'vkGetInstanceProcAddr\' in layer %s. Skipping" - " layer.", - layer_prop->lib_name); - continue; - } - } - if ((fpGDPA = layer_prop->functions.get_device_proc_addr) == NULL) { - if (strlen(layer_prop->functions.str_gdpa) == 0) { - fpGDPA = (PFN_vkGetDeviceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetDeviceProcAddr"); - layer_prop->functions.get_device_proc_addr = fpGDPA; - } else - fpGDPA = - (PFN_vkGetDeviceProcAddr)loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gdpa); - if (!fpGDPA) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Failed to find vkGetDeviceProcAddr in layer %s", - layer_prop->lib_name); - continue; - } - } - } - layer_device_link_info[activated_layers].pNext = chain_info.u.pLayerInfo; - layer_device_link_info[activated_layers].pfnNextGetInstanceProcAddr = nextGIPA; - layer_device_link_info[activated_layers].pfnNextGetDeviceProcAddr = nextGDPA; - chain_info.u.pLayerInfo = &layer_device_link_info[activated_layers]; - nextGIPA = fpGIPA; - nextGDPA = fpGDPA; - - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Inserted device layer %s (%s)", layer_prop->info.layerName, - layer_prop->lib_name); - - activated_layers++; - } - } - - VkDevice created_device = (VkDevice)dev; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)nextGIPA(inst->instance, "vkCreateDevice"); - if (fpCreateDevice) { - VkLayerDeviceCreateInfo create_info_disp; - - create_info_disp.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO; - create_info_disp.function = VK_LOADER_DATA_CALLBACK; - - create_info_disp.u.pfnSetDeviceLoaderData = vkSetDeviceDispatch; - - create_info_disp.pNext = loader_create_info.pNext; - loader_create_info.pNext = &create_info_disp; - res = fpCreateDevice(pd->phys_dev, &loader_create_info, pAllocator, &created_device); - if (res != VK_SUCCESS) { - return res; - } - dev->chain_device = created_device; - } else { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_create_device_chain: Failed to find \'vkCreateDevice\' " - "in layer %s"); - // Couldn't find CreateDevice function! - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Initialize device dispatch table - loader_init_device_dispatch_table(&dev->loader_dispatch, nextGDPA, dev->chain_device); - - return res; -} - -VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count, - const char *const *ppEnabledLayerNames, const struct loader_layer_list *list) { - struct loader_layer_properties *prop; - - for (uint32_t i = 0; i < layer_count; i++) { - VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, ppEnabledLayerNames[i]); - if (result != VK_STRING_ERROR_NONE) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_layers: Device ppEnabledLayerNames " - "contains string that is too long or is badly formed"); - return VK_ERROR_LAYER_NOT_PRESENT; - } - - prop = loader_get_layer_property(ppEnabledLayerNames[i], list); - if (NULL == prop) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_layers: Layer %d does not exist in the list of available layers", i); - return VK_ERROR_LAYER_NOT_PRESENT; - } - } - return VK_SUCCESS; -} - -VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts, - const struct loader_layer_list *instance_layers, - const VkInstanceCreateInfo *pCreateInfo) { - VkExtensionProperties *extension_prop; - char *env_value; - bool check_if_known = true; - VkResult res = VK_SUCCESS; - - struct loader_layer_list active_layers; - struct loader_layer_list expanded_layers; - memset(&active_layers, 0, sizeof(active_layers)); - memset(&expanded_layers, 0, sizeof(expanded_layers)); - if (!loader_init_layer_list(inst, &active_layers)) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - if (!loader_init_layer_list(inst, &expanded_layers)) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - // Build the lists of active layers (including metalayers) and expanded layers (with metalayers resolved to their components) - loader_add_implicit_layers(inst, &active_layers, &expanded_layers, instance_layers); - loader_add_env_layers(inst, VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER, ENABLED_LAYERS_ENV, &active_layers, &expanded_layers, - instance_layers); - res = loader_add_layer_names_to_list(inst, &active_layers, &expanded_layers, pCreateInfo->enabledLayerCount, - pCreateInfo->ppEnabledLayerNames, instance_layers); - if (VK_SUCCESS != res) { - goto out; - } - - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]); - if (result != VK_STRING_ERROR_NONE) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_instance_extensions: Instance ppEnabledExtensionNames contains " - "string that is too long or is badly formed"); - res = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Check if a user wants to disable the instance extension filtering behavior - env_value = loader_getenv("VK_LOADER_DISABLE_INST_EXT_FILTER", inst); - if (NULL != env_value && atoi(env_value) != 0) { - check_if_known = false; - } - loader_free_getenv(env_value, inst); - - if (check_if_known) { - // See if the extension is in the list of supported extensions - bool found = false; - for (uint32_t j = 0; LOADER_INSTANCE_EXTENSIONS[j] != NULL; j++) { - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], LOADER_INSTANCE_EXTENSIONS[j]) == 0) { - found = true; - break; - } - } - - // If it isn't in the list, return an error - if (!found) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_instance_extensions: Extension %s not found in list of known instance extensions.", - pCreateInfo->ppEnabledExtensionNames[i]); - res = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - } - - extension_prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[i], icd_exts); - - if (extension_prop) { - continue; - } - - extension_prop = NULL; - - // Not in global list, search expanded layer extension list - for (uint32_t j = 0; NULL == extension_prop && j < expanded_layers.count; ++j) { - extension_prop = - get_extension_property(pCreateInfo->ppEnabledExtensionNames[i], &expanded_layers.list[j].instance_extension_list); - } - - if (!extension_prop) { - // Didn't find extension name in any of the global layers, error out - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_instance_extensions: Instance extension %s not supported by available ICDs or enabled " - "layers.", - pCreateInfo->ppEnabledExtensionNames[i]); - res = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - } - -out: - loader_destroy_layer_list(inst, NULL, &active_layers); - loader_destroy_layer_list(inst, NULL, &expanded_layers); - return res; -} - -VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev, - const struct loader_layer_list *activated_device_layers, - const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo) { - VkExtensionProperties *extension_prop; - struct loader_layer_properties *layer_prop; - - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]); - if (result != VK_STRING_ERROR_NONE) { - loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_device_extensions: Device ppEnabledExtensionNames contains " - "string that is too long or is badly formed"); - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - - const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i]; - extension_prop = get_extension_property(extension_name, icd_exts); - - if (extension_prop) { - continue; - } - - // Not in global list, search activated layer extension lists - for (uint32_t j = 0; j < activated_device_layers->count; j++) { - layer_prop = &activated_device_layers->list[j]; - - extension_prop = get_dev_extension_property(extension_name, &layer_prop->device_extension_list); - if (extension_prop) { - // Found the extension in one of the layers enabled by the app. - break; - } - } - - if (!extension_prop) { - // Didn't find extension name in any of the device layers, error out - loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_device_extensions: Device extension %s not supported by selected physical device " - "or enabled layers.", - pCreateInfo->ppEnabledExtensionNames[i]); - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - } - return VK_SUCCESS; -} - -// Terminator functions for the Instance chain -// All named terminator_ -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(const VkInstanceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) { - struct loader_icd_term *icd_term; - VkExtensionProperties *prop; - char **filtered_extension_names = NULL; - VkInstanceCreateInfo icd_create_info; - VkResult res = VK_SUCCESS; - bool one_icd_successful = false; - - struct loader_instance *ptr_instance = (struct loader_instance *)*pInstance; - memcpy(&icd_create_info, pCreateInfo, sizeof(icd_create_info)); - - icd_create_info.enabledLayerCount = 0; - icd_create_info.ppEnabledLayerNames = NULL; - - // NOTE: Need to filter the extensions to only those supported by the ICD. - // No ICD will advertise support for layers. An ICD library could - // support a layer, but it would be independent of the actual ICD, - // just in the same library. - filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *)); - if (!filtered_extension_names) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "terminator_CreateInstance: Failed create extension name array for %d extensions", - pCreateInfo->enabledExtensionCount); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - icd_create_info.ppEnabledExtensionNames = (const char *const *)filtered_extension_names; - - for (uint32_t i = 0; i < ptr_instance->icd_tramp_list.count; i++) { - icd_term = loader_icd_add(ptr_instance, &ptr_instance->icd_tramp_list.scanned_list[i]); - if (NULL == icd_term) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "terminator_CreateInstance: Failed to add ICD %d to ICD trampoline list.", i); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - // If any error happens after here, we need to remove the ICD from the list, - // because we've already added it, but haven't validated it - - // Make sure that we reset the pApplicationInfo so we don't get an old pointer - icd_create_info.pApplicationInfo = pCreateInfo->pApplicationInfo; - icd_create_info.enabledExtensionCount = 0; - struct loader_extension_list icd_exts; - - loader_log(ptr_instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Build ICD instance extension list"); - // traverse scanned icd list adding non-duplicate extensions to the list - res = loader_init_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties)); - if (VK_ERROR_OUT_OF_HOST_MEMORY == res) { - // If out of memory, bail immediately. - goto out; - } else if (VK_SUCCESS != res) { - // Something bad happened with this ICD, so free it and try the - // next. - ptr_instance->icd_terms = icd_term->next; - icd_term->next = NULL; - loader_icd_destroy(ptr_instance, icd_term, pAllocator); - continue; - } - - res = loader_add_instance_extensions(ptr_instance, icd_term->scanned_icd->EnumerateInstanceExtensionProperties, - icd_term->scanned_icd->lib_name, &icd_exts); - if (VK_SUCCESS != res) { - loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts); - if (VK_ERROR_OUT_OF_HOST_MEMORY == res) { - // If out of memory, bail immediately. - goto out; - } else { - // Something bad happened with this ICD, so free it and try the next. - ptr_instance->icd_terms = icd_term->next; - icd_term->next = NULL; - loader_icd_destroy(ptr_instance, icd_term, pAllocator); - continue; - } - } - - for (uint32_t j = 0; j < pCreateInfo->enabledExtensionCount; j++) { - prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[j], &icd_exts); - if (prop) { - filtered_extension_names[icd_create_info.enabledExtensionCount] = (char *)pCreateInfo->ppEnabledExtensionNames[j]; - icd_create_info.enabledExtensionCount++; - } - } - - loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts); - - // Get the driver version from vkEnumerateInstanceVersion - uint32_t icd_version = VK_API_VERSION_1_0; - PFN_vkEnumerateInstanceVersion icd_enumerate_instance_version = (PFN_vkEnumerateInstanceVersion) - icd_term->scanned_icd->GetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion"); - VkResult icd_result = VK_SUCCESS; - if (icd_enumerate_instance_version != NULL) { - icd_result = icd_enumerate_instance_version(&icd_version); - if (icd_result != VK_SUCCESS) { - icd_version = VK_API_VERSION_1_0; - loader_log(ptr_instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "terminator_CreateInstance: ICD \"%s\" " - "vkEnumerateInstanceVersion returned error. The ICD will be treated as a 1.0 ICD", - icd_term->scanned_icd->lib_name); - } - } - - // Create an instance, substituting the version to 1.0 if necessary - VkApplicationInfo icd_app_info; - uint32_t icd_version_nopatch = VK_MAKE_VERSION(VK_VERSION_MAJOR(icd_version), VK_VERSION_MINOR(icd_version), 0); - uint32_t requested_version = pCreateInfo == NULL || pCreateInfo->pApplicationInfo == NULL ? VK_API_VERSION_1_0 : pCreateInfo->pApplicationInfo->apiVersion; - if ((requested_version != 0) && (icd_version_nopatch == VK_API_VERSION_1_0)) { - if (icd_create_info.pApplicationInfo == NULL) { - memset(&icd_app_info, 0, sizeof(icd_app_info)); - } else { - memcpy(&icd_app_info, icd_create_info.pApplicationInfo, sizeof(icd_app_info)); - } - icd_app_info.apiVersion = icd_version; - icd_create_info.pApplicationInfo = &icd_app_info; - } - icd_result = ptr_instance->icd_tramp_list.scanned_list[i].CreateInstance(&icd_create_info, pAllocator, &(icd_term->instance)); - if (VK_ERROR_OUT_OF_HOST_MEMORY == icd_result) { - // If out of memory, bail immediately. - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } else if (VK_SUCCESS != icd_result) { - loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "terminator_CreateInstance: Failed to CreateInstance in " - "ICD %d. Skipping ICD.", - i); - ptr_instance->icd_terms = icd_term->next; - icd_term->next = NULL; - loader_icd_destroy(ptr_instance, icd_term, pAllocator); - continue; - } - - if (!loader_icd_init_entries(icd_term, icd_term->instance, - ptr_instance->icd_tramp_list.scanned_list[i].GetInstanceProcAddr)) { - loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "terminator_CreateInstance: Failed to CreateInstance and find " - "entrypoints with ICD. Skipping ICD."); - ptr_instance->icd_terms = icd_term->next; - icd_term->next = NULL; - loader_icd_destroy(ptr_instance, icd_term, pAllocator); - continue; - } - - // If we made it this far, at least one ICD was successful - one_icd_successful = true; - } - - // If no ICDs were added to instance list and res is unchanged from it's initial value, the loader was unable to - // find a suitable ICD. - if (VK_SUCCESS == res && (ptr_instance->icd_terms == NULL || !one_icd_successful)) { - res = VK_ERROR_INCOMPATIBLE_DRIVER; - } - -out: - - if (VK_SUCCESS != res) { - while (NULL != ptr_instance->icd_terms) { - icd_term = ptr_instance->icd_terms; - ptr_instance->icd_terms = icd_term->next; - if (NULL != icd_term->instance) { - icd_term->dispatch.DestroyInstance(icd_term->instance, pAllocator); - } - loader_icd_destroy(ptr_instance, icd_term, pAllocator); - } - } - - return res; -} - -VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - struct loader_instance *ptr_instance = loader_instance(instance); - if (NULL == ptr_instance) { - return; - } - struct loader_icd_term *icd_terms = ptr_instance->icd_terms; - struct loader_icd_term *next_icd_term; - - // Remove this instance from the list of instances: - struct loader_instance *prev = NULL; - struct loader_instance *next = loader.instances; - while (next != NULL) { - if (next == ptr_instance) { - // Remove this instance from the list: - if (prev) - prev->next = next->next; - else - loader.instances = next->next; - break; - } - prev = next; - next = next->next; - } - - while (NULL != icd_terms) { - if (icd_terms->instance) { - icd_terms->dispatch.DestroyInstance(icd_terms->instance, pAllocator); - } - next_icd_term = icd_terms->next; - icd_terms->instance = VK_NULL_HANDLE; - loader_icd_destroy(ptr_instance, icd_terms, pAllocator); - - icd_terms = next_icd_term; - } - - loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list); - loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list); - loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list); - if (NULL != ptr_instance->phys_devs_term) { - for (uint32_t i = 0; i < ptr_instance->phys_dev_count_term; i++) { - loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_term[i]); - } - loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_term); - } - if (NULL != ptr_instance->phys_dev_groups_term) { - for (uint32_t i = 0; i < ptr_instance->phys_dev_group_count_term; i++) { - loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_term[i]); - } - loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_term); - } - loader_free_dev_ext_table(ptr_instance); - loader_free_phys_dev_ext_table(ptr_instance); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - VkResult res = VK_SUCCESS; - struct loader_physical_device_term *phys_dev_term; - phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - - struct loader_device *dev = (struct loader_device *)*pDevice; - PFN_vkCreateDevice fpCreateDevice = icd_term->dispatch.CreateDevice; - struct loader_extension_list icd_exts; - - struct VkStructureHeader *caller_dgci_container = NULL; - VkDeviceGroupDeviceCreateInfoKHR *caller_dgci = NULL; - - dev->phys_dev_term = phys_dev_term; - - icd_exts.list = NULL; - - if (fpCreateDevice == NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "terminator_CreateDevice: No vkCreateDevice command exposed " - "by ICD %s", - icd_term->scanned_icd->lib_name); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - VkDeviceCreateInfo localCreateInfo; - memcpy(&localCreateInfo, pCreateInfo, sizeof(localCreateInfo)); - - // NOTE: Need to filter the extensions to only those supported by the ICD. - // No ICD will advertise support for layers. An ICD library could support a layer, - // but it would be independent of the actual ICD, just in the same library. - char **filtered_extension_names = NULL; - if (0 < pCreateInfo->enabledExtensionCount) { - filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *)); - if (NULL == filtered_extension_names) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "terminator_CreateDevice: Failed to create extension name " - "storage for %d extensions %d", - pCreateInfo->enabledExtensionCount); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - } - - localCreateInfo.enabledLayerCount = 0; - localCreateInfo.ppEnabledLayerNames = NULL; - - localCreateInfo.enabledExtensionCount = 0; - localCreateInfo.ppEnabledExtensionNames = (const char *const *)filtered_extension_names; - - // Get the physical device (ICD) extensions - res = loader_init_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties)); - if (VK_SUCCESS != res) { - goto out; - } - - res = loader_add_device_extensions(icd_term->this_instance, icd_term->dispatch.EnumerateDeviceExtensionProperties, - phys_dev_term->phys_dev, icd_term->scanned_icd->lib_name, &icd_exts); - if (res != VK_SUCCESS) { - goto out; - } - - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i]; - VkExtensionProperties *prop = get_extension_property(extension_name, &icd_exts); - if (prop) { - filtered_extension_names[localCreateInfo.enabledExtensionCount] = (char *)extension_name; - localCreateInfo.enabledExtensionCount++; - } else { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, - "vkCreateDevice extension %s not available for " - "devices associated with ICD %s", - extension_name, icd_term->scanned_icd->lib_name); - } - } - - // Before we continue, If KHX_device_group is the list of enabled and viable extensions, then we then need to look for the - // corresponding VkDeviceGroupDeviceCreateInfo struct in the device list and replace all the physical device values (which - // are really loader physical device terminator values) with the ICD versions. - //if (icd_term->this_instance->enabled_known_extensions.khr_device_group_creation == 1) { - { - struct VkStructureHeader *pNext = (struct VkStructureHeader *)localCreateInfo.pNext; - struct VkStructureHeader *pPrev = (struct VkStructureHeader *)&localCreateInfo; - while (NULL != pNext) { - if (VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO == pNext->sType) { - VkDeviceGroupDeviceCreateInfo *cur_struct = (VkDeviceGroupDeviceCreateInfo *)pNext; - if (0 < cur_struct->physicalDeviceCount && NULL != cur_struct->pPhysicalDevices) { - VkDeviceGroupDeviceCreateInfo *temp_struct = loader_stack_alloc(sizeof(VkDeviceGroupDeviceCreateInfo)); - VkPhysicalDevice *phys_dev_array = NULL; - if (NULL == temp_struct) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memcpy(temp_struct, cur_struct, sizeof(VkDeviceGroupDeviceCreateInfo)); - phys_dev_array = loader_stack_alloc(sizeof(VkPhysicalDevice) * cur_struct->physicalDeviceCount); - if (NULL == phys_dev_array) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - // Before calling down, replace the incoming physical device values (which are really loader terminator - // physical devices) with the ICDs physical device values. - struct loader_physical_device_term *cur_term; - for (uint32_t phys_dev = 0; phys_dev < cur_struct->physicalDeviceCount; phys_dev++) { - cur_term = (struct loader_physical_device_term *)cur_struct->pPhysicalDevices[phys_dev]; - phys_dev_array[phys_dev] = cur_term->phys_dev; - } - temp_struct->pPhysicalDevices = phys_dev_array; - - // Keep track of pointers to restore pNext chain before returning - caller_dgci_container = pPrev; - caller_dgci = cur_struct; - - // Replace the old struct in the pNext chain with this one. - pPrev->pNext = (const void *)temp_struct; - pNext = (struct VkStructureHeader *)(temp_struct); - } - break; - } - - pPrev = pNext; - pNext = (struct VkStructureHeader *)(pPrev->pNext); - } - } - - // Handle loader emulation for structs that are not supported by the ICD: - // Presently, the emulation leaves the pNext chain alone. This means that the ICD will receive items in the chain which - // are not recognized by the ICD. If this causes the ICD to fail, then the items would have to be removed here. The current - // implementation does not remove them because copying the pNext chain would be impossible if the loader does not recognize - // the any of the struct types, as the loader would not know the size to allocate and copy. - //if (icd_term->dispatch.GetPhysicalDeviceFeatures2 == NULL && icd_term->dispatch.GetPhysicalDeviceFeatures2KHR == NULL) { - { - const void *pNext = localCreateInfo.pNext; - while (pNext != NULL) { - switch (*(VkStructureType *)pNext) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: { - const VkPhysicalDeviceFeatures2KHR *features = pNext; - - if (icd_term->dispatch.GetPhysicalDeviceFeatures2 == NULL && icd_term->dispatch.GetPhysicalDeviceFeatures2KHR == NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkCreateDevice: Emulating handling of VkPhysicalDeviceFeatures2 in pNext chain for ICD \"%s\"", - icd_term->scanned_icd->lib_name); - - // Verify that VK_KHR_get_physical_device_properties2 is enabled - if (icd_term->this_instance->enabled_known_extensions.khr_get_physical_device_properties2) { - localCreateInfo.pEnabledFeatures = &features->features; - } - } - - // Leave this item in the pNext chain for now - - pNext = features->pNext; - break; - } - - case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: { - const VkDeviceGroupDeviceCreateInfoKHR *group_info = pNext; - - if (icd_term->dispatch.EnumeratePhysicalDeviceGroups == NULL && icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHR == NULL) { - loader_log( - icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkCreateDevice: Emulating handling of VkPhysicalDeviceGroupProperties in pNext chain for ICD \"%s\"", - icd_term->scanned_icd->lib_name); - - // The group must contain only this one device, since physical device groups aren't actually supported - if (group_info->physicalDeviceCount != 1) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkCreateDevice: Emulation failed to create device from device group info"); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - } - - // Nothing needs to be done here because we're leaving the item in the pNext chain and because the spec states - // that the physicalDevice argument must be included in the device group, and we've already checked that it is - - pNext = group_info->pNext; - break; - } - - // Multiview properties are also allowed, but since VK_KHX_multiview is a device extension, we'll just let the ICD - // handle that error when the user enables the extension here - default: { - const struct VkStructureHeader *header = pNext; - pNext = header->pNext; - break; - } - } - } - } - - // Every extension that has a loader-defined terminator needs to be marked as enabled or disabled so that we know whether or - // not to return that terminator when vkGetDeviceProcAddr is called - for (uint32_t i = 0; i < localCreateInfo.enabledExtensionCount; ++i) { - if (!strcmp(localCreateInfo.ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME)) { - dev->extensions.khr_swapchain_enabled = true; - } else if (!strcmp(localCreateInfo.ppEnabledExtensionNames[i], VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME)) { - dev->extensions.khr_display_swapchain_enabled = true; - } else if (!strcmp(localCreateInfo.ppEnabledExtensionNames[i], VK_EXT_DEBUG_MARKER_EXTENSION_NAME)) { - dev->extensions.ext_debug_marker_enabled = true; - } - dev->extensions.ext_debug_utils_enabled = icd_term->this_instance->enabled_known_extensions.ext_debug_utils; - } - - res = fpCreateDevice(phys_dev_term->phys_dev, &localCreateInfo, pAllocator, &dev->icd_device); - if (res != VK_SUCCESS) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "terminator_CreateDevice: Failed in ICD %s vkCreateDevice" - "call", - icd_term->scanned_icd->lib_name); - goto out; - } - - *pDevice = dev->icd_device; - loader_add_logical_device(icd_term->this_instance, icd_term, dev); - - // Init dispatch pointer in new device object - loader_init_dispatch(*pDevice, &dev->loader_dispatch); - -out: - if (NULL != icd_exts.list) { - loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts); - } - - // Restore pNext pointer to old VkDeviceGroupDeviceCreateInfoKHX - // in the chain to maintain consistency for the caller. - if (caller_dgci_container != NULL) { - caller_dgci_container->pNext = caller_dgci; - } - - return res; -} - -VkResult setupLoaderTrampPhysDevs(VkInstance instance) { - VkResult res = VK_SUCCESS; - VkPhysicalDevice *local_phys_devs = NULL; - struct loader_instance *inst; - uint32_t total_count = 0; - struct loader_physical_device_tramp **new_phys_devs = NULL; - - inst = loader_get_instance(instance); - if (NULL == inst) { - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - // Query how many GPUs there - res = inst->disp->layer_inst_disp.EnumeratePhysicalDevices(instance, &total_count, NULL); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevs: Failed during dispatch call " - "of \'vkEnumeratePhysicalDevices\' to lower layers or " - "loader to get count."); - goto out; - } - - // Really use what the total GPU count is since Optimus and other layers may mess - // the count up. - total_count = inst->total_gpu_count; - - // Create an array for the new physical devices, which will be stored - // in the instance for the trampoline code. - new_phys_devs = (struct loader_physical_device_tramp **)loader_instance_heap_alloc( - inst, total_count * sizeof(struct loader_physical_device_tramp *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_devs) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevs: Failed to allocate new physical device" - " array of size %d", - total_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(new_phys_devs, 0, total_count * sizeof(struct loader_physical_device_tramp *)); - - // Create a temporary array (on the stack) to keep track of the - // returned VkPhysicalDevice values. - local_phys_devs = loader_stack_alloc(sizeof(VkPhysicalDevice) * total_count); - if (NULL == local_phys_devs) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevs: Failed to allocate local " - "physical device array of size %d", - total_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(local_phys_devs, 0, sizeof(VkPhysicalDevice) * total_count); - - res = inst->disp->layer_inst_disp.EnumeratePhysicalDevices(instance, &total_count, local_phys_devs); - if (VK_SUCCESS != res) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevs: Failed during dispatch call " - "of \'vkEnumeratePhysicalDevices\' to lower layers or " - "loader to get content."); - goto out; - } - - // Copy or create everything to fill the new array of physical devices - for (uint32_t new_idx = 0; new_idx < total_count; new_idx++) { - // Check if this physical device is already in the old buffer - for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_tramp; old_idx++) { - if (local_phys_devs[new_idx] == inst->phys_devs_tramp[old_idx]->phys_dev) { - new_phys_devs[new_idx] = inst->phys_devs_tramp[old_idx]; - break; - } - } - - // If this physical device isn't in the old buffer, create it - if (NULL == new_phys_devs[new_idx]) { - new_phys_devs[new_idx] = (struct loader_physical_device_tramp *)loader_instance_heap_alloc( - inst, sizeof(struct loader_physical_device_tramp), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_devs[new_idx]) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevs: Failed to allocate " - "physical device trampoline object %d", - new_idx); - total_count = new_idx; - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - // Initialize the new physicalDevice object - loader_set_dispatch((void *)new_phys_devs[new_idx], inst->disp); - new_phys_devs[new_idx]->this_instance = inst; - new_phys_devs[new_idx]->phys_dev = local_phys_devs[new_idx]; - } - } - -out: - - if (VK_SUCCESS != res) { - if (NULL != new_phys_devs) { - for (uint32_t i = 0; i < total_count; i++) { - loader_instance_heap_free(inst, new_phys_devs[i]); - } - loader_instance_heap_free(inst, new_phys_devs); - } - total_count = 0; - } else { - // Free everything that didn't carry over to the new array of - // physical devices - if (NULL != inst->phys_devs_tramp) { - for (uint32_t i = 0; i < inst->phys_dev_count_tramp; i++) { - bool found = false; - for (uint32_t j = 0; j < total_count; j++) { - if (inst->phys_devs_tramp[i] == new_phys_devs[j]) { - found = true; - break; - } - } - if (!found) { - loader_instance_heap_free(inst, inst->phys_devs_tramp[i]); - } - } - loader_instance_heap_free(inst, inst->phys_devs_tramp); - } - - // Swap in the new physical device list - inst->phys_dev_count_tramp = total_count; - inst->phys_devs_tramp = new_phys_devs; - } - - return res; -} - -VkResult setupLoaderTermPhysDevs(struct loader_instance *inst) { - VkResult res = VK_SUCCESS; - struct loader_icd_term *icd_term; - struct loader_phys_dev_per_icd *icd_phys_dev_array = NULL; - struct loader_physical_device_term **new_phys_devs = NULL; - - inst->total_gpu_count = 0; - - // Allocate something to store the physical device characteristics - // that we read from each ICD. - icd_phys_dev_array = - (struct loader_phys_dev_per_icd *)loader_stack_alloc(sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count); - if (NULL == icd_phys_dev_array) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevs: Failed to allocate temporary " - "ICD Physical device info array of size %d", - inst->total_gpu_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(icd_phys_dev_array, 0, sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count); - icd_term = inst->icd_terms; - - // For each ICD, query the number of physical devices, and then get an - // internal value for those physical devices. - for (uint32_t icd_idx = 0; NULL != icd_term; icd_term = icd_term->next, icd_idx++) { - res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &icd_phys_dev_array[icd_idx].count, NULL); - if (VK_SUCCESS != res) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevs: Call to " - "ICD %d's \'vkEnumeratePhysicalDevices\' failed with" - " error 0x%08x", - icd_idx, res); - goto out; - } - - icd_phys_dev_array[icd_idx].phys_devs = - (VkPhysicalDevice *)loader_stack_alloc(icd_phys_dev_array[icd_idx].count * sizeof(VkPhysicalDevice)); - if (NULL == icd_phys_dev_array[icd_idx].phys_devs) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevs: Failed to allocate temporary " - "ICD Physical device array for ICD %d of size %d", - icd_idx, inst->total_gpu_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &(icd_phys_dev_array[icd_idx].count), - icd_phys_dev_array[icd_idx].phys_devs); - if (VK_SUCCESS != res) { - goto out; - } - inst->total_gpu_count += icd_phys_dev_array[icd_idx].count; - icd_phys_dev_array[icd_idx].this_icd_term = icd_term; - } - - if (0 == inst->total_gpu_count) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevs: Failed to detect any valid" - " GPUs in the current config"); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - new_phys_devs = loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term *) * inst->total_gpu_count, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_devs) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevs: Failed to allocate new physical" - " device array of size %d", - inst->total_gpu_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(new_phys_devs, 0, sizeof(struct loader_physical_device_term *) * inst->total_gpu_count); - - // Copy or create everything to fill the new array of physical devices - uint32_t idx = 0; - for (uint32_t icd_idx = 0; icd_idx < inst->total_icd_count; icd_idx++) { - for (uint32_t pd_idx = 0; pd_idx < icd_phys_dev_array[icd_idx].count; pd_idx++) { - // Check if this physical device is already in the old buffer - if (NULL != inst->phys_devs_term) { - for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_term; old_idx++) { - if (icd_phys_dev_array[icd_idx].phys_devs[pd_idx] == inst->phys_devs_term[old_idx]->phys_dev) { - new_phys_devs[idx] = inst->phys_devs_term[old_idx]; - break; - } - } - } - // If this physical device isn't in the old buffer, then we - // need to create it. - if (NULL == new_phys_devs[idx]) { - new_phys_devs[idx] = loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term), - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_devs[idx]) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevs: Failed to allocate " - "physical device terminator object %d", - idx); - inst->total_gpu_count = idx; - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - loader_set_dispatch((void *)new_phys_devs[idx], inst->disp); - new_phys_devs[idx]->this_icd_term = icd_phys_dev_array[icd_idx].this_icd_term; - new_phys_devs[idx]->icd_index = (uint8_t)(icd_idx); - new_phys_devs[idx]->phys_dev = icd_phys_dev_array[icd_idx].phys_devs[pd_idx]; - } - idx++; - } - } - -out: - - if (VK_SUCCESS != res) { - if (NULL != new_phys_devs) { - // We've encountered an error, so we should free the new buffers. - for (uint32_t i = 0; i < inst->total_gpu_count; i++) { - loader_instance_heap_free(inst, new_phys_devs[i]); - } - loader_instance_heap_free(inst, new_phys_devs); - } - inst->total_gpu_count = 0; - } else { - // Free everything that didn't carry over to the new array of - // physical devices. Everything else will have been copied over - // to the new array. - if (NULL != inst->phys_devs_term) { - for (uint32_t cur_pd = 0; cur_pd < inst->phys_dev_count_term; cur_pd++) { - bool found = false; - for (uint32_t new_pd_idx = 0; new_pd_idx < inst->total_gpu_count; new_pd_idx++) { - if (inst->phys_devs_term[cur_pd] == new_phys_devs[new_pd_idx]) { - found = true; - break; - } - } - if (!found) { - loader_instance_heap_free(inst, inst->phys_devs_term[cur_pd]); - } - } - loader_instance_heap_free(inst, inst->phys_devs_term); - } - - // Swap out old and new devices list - inst->phys_dev_count_term = inst->total_gpu_count; - inst->phys_devs_term = new_phys_devs; - } - - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, - VkPhysicalDevice *pPhysicalDevices) { - struct loader_instance *inst = (struct loader_instance *)instance; - VkResult res = VK_SUCCESS; - - // Always call the setup loader terminator physical devices because they may - // have changed at any point. - res = setupLoaderTermPhysDevs(inst); - if (VK_SUCCESS != res) { - goto out; - } - - uint32_t copy_count = inst->total_gpu_count; - if (NULL != pPhysicalDevices) { - if (copy_count > *pPhysicalDeviceCount) { - copy_count = *pPhysicalDeviceCount; - res = VK_INCOMPLETE; - } - - for (uint32_t i = 0; i < copy_count; i++) { - pPhysicalDevices[i] = (VkPhysicalDevice)inst->phys_devs_term[i]; - } - } - - *pPhysicalDeviceCount = copy_count; - -out: - - return res; -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties *pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL != icd_term->dispatch.GetPhysicalDeviceProperties) { - icd_term->dispatch.GetPhysicalDeviceProperties(phys_dev_term->phys_dev, pProperties); - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties *pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL != icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties) { - icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, pProperties); - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties *pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL != icd_term->dispatch.GetPhysicalDeviceMemoryProperties) { - icd_term->dispatch.GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev, pProperties); - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures *pFeatures) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL != icd_term->dispatch.GetPhysicalDeviceFeatures) { - icd_term->dispatch.GetPhysicalDeviceFeatures(phys_dev_term->phys_dev, pFeatures); - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, - VkFormatProperties *pFormatInfo) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL != icd_term->dispatch.GetPhysicalDeviceFormatProperties) { - icd_term->dispatch.GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev, format, pFormatInfo); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, - VkImageType type, VkImageTiling tiling, - VkImageUsageFlags usage, VkImageCreateFlags flags, - VkImageFormatProperties *pImageFormatProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceImageFormatProperties) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "Encountered the vkEnumerateDeviceLayerProperties " - "terminator. This means a layer improperly continued."); - return VK_ERROR_INITIALIZATION_FAILED; - } - return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties(phys_dev_term->phys_dev, format, type, tiling, usage, flags, - pImageFormatProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, - VkImageType type, VkSampleCountFlagBits samples, - VkImageUsageFlags usage, VkImageTiling tiling, - uint32_t *pNumProperties, - VkSparseImageFormatProperties *pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL != icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties) { - icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties(phys_dev_term->phys_dev, format, type, samples, usage, - tiling, pNumProperties, pProperties); - } -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pPropertyCount, - VkExtensionProperties *pProperties) { - struct loader_physical_device_term *phys_dev_term; - - struct loader_layer_list implicit_layer_list = {0}; - struct loader_extension_list all_exts = {0}; - struct loader_extension_list icd_exts = {0}; - - assert(pLayerName == NULL || strlen(pLayerName) == 0); - - // Any layer or trampoline wrapping should be removed at this point in time can just cast to the expected - // type for VkPhysicalDevice. - phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - - // This case is during the call down the instance chain with pLayerName == NULL - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - uint32_t icd_ext_count = *pPropertyCount; - VkResult res; - - // Get the available device extensions - res = icd_term->dispatch.EnumerateDeviceExtensionProperties(phys_dev_term->phys_dev, NULL, &icd_ext_count, pProperties); - if (res != VK_SUCCESS) { - goto out; - } - - if (!loader_init_layer_list(icd_term->this_instance, &implicit_layer_list)) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - loader_add_implicit_layers(icd_term->this_instance, &implicit_layer_list, NULL, &icd_term->this_instance->instance_layer_list); - // We need to determine which implicit layers are active, and then add their extensions. This can't be cached as - // it depends on results of environment variables (which can change). - if (pProperties != NULL) { - // Initialize dev_extension list within the physicalDevice object - res = loader_init_device_extensions(icd_term->this_instance, phys_dev_term, icd_ext_count, pProperties, &icd_exts); - if (res != VK_SUCCESS) { - goto out; - } - - // We need to determine which implicit layers are active, and then add their extensions. This can't be cached as - // it depends on results of environment variables (which can change). - res = loader_add_to_ext_list(icd_term->this_instance, &all_exts, icd_exts.count, icd_exts.list); - if (res != VK_SUCCESS) { - goto out; - } - - loader_add_implicit_layers(icd_term->this_instance, &implicit_layer_list, NULL, - &icd_term->this_instance->instance_layer_list); - - for (uint32_t i = 0; i < implicit_layer_list.count; i++) { - for (uint32_t j = 0; j < implicit_layer_list.list[i].device_extension_list.count; j++) { - res = loader_add_to_ext_list(icd_term->this_instance, &all_exts, 1, - &implicit_layer_list.list[i].device_extension_list.list[j].props); - if (res != VK_SUCCESS) { - goto out; - } - } - } - uint32_t capacity = *pPropertyCount; - VkExtensionProperties *props = pProperties; - - for (uint32_t i = 0; i < all_exts.count && i < capacity; i++) { - props[i] = all_exts.list[i]; - } - - // Wasn't enough space for the extensions, we did partial copy now return VK_INCOMPLETE - if (capacity < all_exts.count) { - res = VK_INCOMPLETE; - } else { - *pPropertyCount = all_exts.count; - } - } else { - // Just return the count; need to add in the count of implicit layer extensions - // don't worry about duplicates being added in the count - *pPropertyCount = icd_ext_count; - - for (uint32_t i = 0; i < implicit_layer_list.count; i++) { - *pPropertyCount += implicit_layer_list.list[i].device_extension_list.count; - } - res = VK_SUCCESS; - } - -out: - - if (NULL != implicit_layer_list.list) { - loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&implicit_layer_list); - } - if (NULL != all_exts.list) { - loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&all_exts); - } - if (NULL != icd_exts.list) { - loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts); - } - - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, - VkLayerProperties *pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "Encountered the vkEnumerateDeviceLayerProperties " - "terminator. This means a layer improperly continued."); - // Should never get here this call isn't dispatched down the chain - return VK_ERROR_INITIALIZATION_FAILED; -} - -VkStringErrorFlags vk_string_validate(const int max_length, const char *utf8) { - VkStringErrorFlags result = VK_STRING_ERROR_NONE; - int num_char_bytes = 0; - int i, j; - - for (i = 0; i <= max_length; i++) { - if (utf8[i] == 0) { - break; - } else if (i == max_length) { - result |= VK_STRING_ERROR_LENGTH; - break; - } else if ((utf8[i] >= 0x20) && (utf8[i] < 0x7f)) { - num_char_bytes = 0; - } else if ((utf8[i] & UTF8_ONE_BYTE_MASK) == UTF8_ONE_BYTE_CODE) { - num_char_bytes = 1; - } else if ((utf8[i] & UTF8_TWO_BYTE_MASK) == UTF8_TWO_BYTE_CODE) { - num_char_bytes = 2; - } else if ((utf8[i] & UTF8_THREE_BYTE_MASK) == UTF8_THREE_BYTE_CODE) { - num_char_bytes = 3; - } else { - result = VK_STRING_ERROR_BAD_DATA; - } - - // Validate the following num_char_bytes of data - for (j = 0; (j < num_char_bytes) && (i < max_length); j++) { - if (++i == max_length) { - result |= VK_STRING_ERROR_LENGTH; - break; - } - if ((utf8[i] & UTF8_DATA_BYTE_MASK) != UTF8_DATA_BYTE_CODE) { - result |= VK_STRING_ERROR_BAD_DATA; - } - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL -terminator_EnumerateInstanceVersion(const VkEnumerateInstanceVersionChain *chain, uint32_t* pApiVersion) { - // NOTE: The Vulkan WG doesn't want us checking pApiVersion for NULL, but instead - // prefers us crashing. - *pApiVersion = VK_MAKE_VERSION(loader_major_version, loader_minor_version, 0); - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL -terminator_EnumerateInstanceExtensionProperties(const VkEnumerateInstanceExtensionPropertiesChain *chain, const char *pLayerName, - uint32_t *pPropertyCount, VkExtensionProperties *pProperties) { - struct loader_extension_list *global_ext_list = NULL; - struct loader_layer_list instance_layers; - struct loader_extension_list local_ext_list; - struct loader_icd_tramp_list icd_tramp_list; - uint32_t copy_size; - VkResult res = VK_SUCCESS; - - // tls_instance = NULL; - memset(&local_ext_list, 0, sizeof(local_ext_list)); - memset(&instance_layers, 0, sizeof(instance_layers)); - - // Get layer libraries if needed - if (pLayerName && strlen(pLayerName) != 0) { - if (vk_string_validate(MaxLoaderStringLength, pLayerName) != VK_STRING_ERROR_NONE) { - assert(VK_FALSE && - "vkEnumerateInstanceExtensionProperties: " - "pLayerName is too long or is badly formed"); - res = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - loader_layer_scan(NULL, &instance_layers); - for (uint32_t i = 0; i < instance_layers.count; i++) { - struct loader_layer_properties *props = &instance_layers.list[i]; - if (strcmp(props->info.layerName, pLayerName) == 0) { - global_ext_list = &props->instance_extension_list; - break; - } - } - } else { - // Scan/discover all ICD libraries - memset(&icd_tramp_list, 0, sizeof(icd_tramp_list)); - res = loader_icd_scan(NULL, &icd_tramp_list); - if (VK_SUCCESS != res) { - goto out; - } - // Get extensions from all ICD's, merge so no duplicates - res = loader_get_icd_loader_instance_extensions(NULL, &icd_tramp_list, &local_ext_list); - if (VK_SUCCESS != res) { - goto out; - } - loader_scanned_icd_clear(NULL, &icd_tramp_list); - - // Append enabled implicit layers. - loader_implicit_layer_scan(NULL, &instance_layers); - for (uint32_t i = 0; i < instance_layers.count; i++) { - if (!loader_is_implicit_layer_enabled(NULL, &instance_layers.list[i])) { - continue; - } - struct loader_extension_list *ext_list = &instance_layers.list[i].instance_extension_list; - loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count, ext_list->list); - } - - global_ext_list = &local_ext_list; - } - - if (global_ext_list == NULL) { - res = VK_ERROR_LAYER_NOT_PRESENT; - goto out; - } - - if (pProperties == NULL) { - *pPropertyCount = global_ext_list->count; - goto out; - } - - copy_size = *pPropertyCount < global_ext_list->count ? *pPropertyCount : global_ext_list->count; - for (uint32_t i = 0; i < copy_size; i++) { - memcpy(&pProperties[i], &global_ext_list->list[i], sizeof(VkExtensionProperties)); - } - *pPropertyCount = copy_size; - - if (copy_size < global_ext_list->count) { - res = VK_INCOMPLETE; - goto out; - } - -out: - - loader_destroy_generic_list(NULL, (struct loader_generic_list *)&local_ext_list); - loader_delete_layer_properties(NULL, &instance_layers); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateInstanceLayerProperties(const VkEnumerateInstanceLayerPropertiesChain *chain, - uint32_t *pPropertyCount, - VkLayerProperties *pProperties) { - VkResult result = VK_SUCCESS; - struct loader_layer_list instance_layer_list; - tls_instance = NULL; - - LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize); - - uint32_t copy_size; - - // Get layer libraries - memset(&instance_layer_list, 0, sizeof(instance_layer_list)); - loader_layer_scan(NULL, &instance_layer_list); - - if (pProperties == NULL) { - *pPropertyCount = instance_layer_list.count; - goto out; - } - - copy_size = (*pPropertyCount < instance_layer_list.count) ? *pPropertyCount : instance_layer_list.count; - for (uint32_t i = 0; i < copy_size; i++) { - memcpy(&pProperties[i], &instance_layer_list.list[i].info, sizeof(VkLayerProperties)); - } - - *pPropertyCount = copy_size; - - if (copy_size < instance_layer_list.count) { - result = VK_INCOMPLETE; - goto out; - } - -out: - - loader_delete_layer_properties(NULL, &instance_layer_list); - return result; -} - -#if defined(_WIN32) && defined(LOADER_DYNAMIC_LIB) -BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) { - switch (reason) { - case DLL_PROCESS_ATTACH: - loader_initialize(); - break; - case DLL_PROCESS_DETACH: - if (NULL == reserved) { - loader_release(); - } - break; - default: - // Do nothing - break; - } - return TRUE; -} -#elif !defined(_WIN32) -__attribute__((constructor)) void loader_init_library() { loader_initialize(); } - -__attribute__((destructor)) void loader_free_library() { loader_release(); } -#endif - -// ---- Vulkan Core 1.1 terminators - -VkResult setupLoaderTermPhysDevGroups(struct loader_instance *inst) { - VkResult res = VK_SUCCESS; - struct loader_icd_term *icd_term; - uint32_t total_count = 0; - uint32_t cur_icd_group_count = 0; - VkPhysicalDeviceGroupPropertiesKHR **new_phys_dev_groups = NULL; - VkPhysicalDeviceGroupPropertiesKHR *local_phys_dev_groups = NULL; - PFN_vkEnumeratePhysicalDeviceGroups fpEnumeratePhysicalDeviceGroups = NULL; - - if (0 == inst->phys_dev_count_term) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Loader failed to setup physical " - "device terminator info before calling \'EnumeratePhysicalDeviceGroups\'."); - assert(false); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - // For each ICD, query the number of physical device groups, and then get an - // internal value for those physical devices. - icd_term = inst->icd_terms; - for (uint32_t icd_idx = 0; NULL != icd_term; icd_term = icd_term->next, icd_idx++) { - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - if (inst->enabled_known_extensions.khr_device_group_creation) { - fpEnumeratePhysicalDeviceGroups = icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHR; - } else { - fpEnumeratePhysicalDeviceGroups = icd_term->dispatch.EnumeratePhysicalDeviceGroups; - } - - cur_icd_group_count = 0; - if (NULL == fpEnumeratePhysicalDeviceGroups) { - // Treat each ICD's GPU as it's own group if the extension isn't supported - res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &cur_icd_group_count, NULL); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed during dispatch call of " - "\'EnumeratePhysicalDevices\' to ICD %d to get plain phys dev count.", - icd_idx); - goto out; - } - } else { - // Query the actual group info - res = fpEnumeratePhysicalDeviceGroups(icd_term->instance, &cur_icd_group_count, NULL); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed during dispatch call of " - "\'EnumeratePhysicalDeviceGroups\' to ICD %d to get count.", - icd_idx); - goto out; - } - } - total_count += cur_icd_group_count; - } - - // Create an array for the new physical device groups, which will be stored - // in the instance for the Terminator code. - new_phys_dev_groups = (VkPhysicalDeviceGroupProperties **)loader_instance_heap_alloc( - inst, total_count * sizeof(VkPhysicalDeviceGroupProperties *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_dev_groups) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed to allocate new physical device" - " group array of size %d", - total_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(new_phys_dev_groups, 0, total_count * sizeof(VkPhysicalDeviceGroupProperties *)); - - // Create a temporary array (on the stack) to keep track of the - // returned VkPhysicalDevice values. - local_phys_dev_groups = loader_stack_alloc(sizeof(VkPhysicalDeviceGroupProperties) * total_count); - if (NULL == local_phys_dev_groups) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed to allocate local " - "physical device group array of size %d", - total_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - // Initialize the memory to something valid - memset(local_phys_dev_groups, 0, sizeof(VkPhysicalDeviceGroupProperties) * total_count); - for (uint32_t group = 0; group < total_count; group++) { - local_phys_dev_groups[group].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR; - local_phys_dev_groups[group].pNext = NULL; - local_phys_dev_groups[group].subsetAllocation = false; - } - - cur_icd_group_count = 0; - icd_term = inst->icd_terms; - for (uint32_t icd_idx = 0; NULL != icd_term; icd_term = icd_term->next, icd_idx++) { - uint32_t count_this_time = total_count - cur_icd_group_count; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - if (inst->enabled_known_extensions.khr_device_group_creation) { - fpEnumeratePhysicalDeviceGroups = icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHR; - } else { - fpEnumeratePhysicalDeviceGroups = icd_term->dispatch.EnumeratePhysicalDeviceGroups; - } - - if (NULL == fpEnumeratePhysicalDeviceGroups) { - VkPhysicalDevice* phys_dev_array = loader_stack_alloc(sizeof(VkPhysicalDevice) * count_this_time); - if (NULL == phys_dev_array) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed to allocate local " - "physical device array of size %d", - count_this_time); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &count_this_time, phys_dev_array); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed during dispatch call of " - "\'EnumeratePhysicalDevices\' to ICD %d to get plain phys dev count.", - icd_idx); - goto out; - } - - // Add each GPU as it's own group - for (uint32_t indiv_gpu = 0; indiv_gpu < count_this_time; indiv_gpu++) { - local_phys_dev_groups[indiv_gpu + cur_icd_group_count].physicalDeviceCount = 1; - local_phys_dev_groups[indiv_gpu + cur_icd_group_count].physicalDevices[0] = phys_dev_array[indiv_gpu]; - } - - } else { - res = fpEnumeratePhysicalDeviceGroups(icd_term->instance, &count_this_time, &local_phys_dev_groups[cur_icd_group_count]); - if (VK_SUCCESS != res) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed during dispatch call of " - "\'EnumeratePhysicalDeviceGroups\' to ICD %d to get content.", - icd_idx); - goto out; - } - } - - cur_icd_group_count += count_this_time; - } - - // Replace all the physical device IDs with the proper loader values - for (uint32_t group = 0; group < total_count; group++) { - for (uint32_t group_gpu = 0; group_gpu < local_phys_dev_groups[group].physicalDeviceCount; group_gpu++) { - bool found = false; - for (uint32_t term_gpu = 0; term_gpu < inst->phys_dev_count_term; term_gpu++) { - if (local_phys_dev_groups[group].physicalDevices[group_gpu] == inst->phys_devs_term[term_gpu]->phys_dev) { - local_phys_dev_groups[group].physicalDevices[group_gpu] = (VkPhysicalDevice)inst->phys_devs_term[term_gpu]; - found = true; - break; - } - } - if (!found) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed to find GPU %d in group %d" - " returned by \'EnumeratePhysicalDeviceGroups\' in list returned" - " by \'EnumeratePhysicalDevices\'", group_gpu, group); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - } - } - - // Copy or create everything to fill the new array of physical device groups - for (uint32_t new_idx = 0; new_idx < total_count; new_idx++) { - // Check if this physical device group with the same contents is already in the old buffer - for (uint32_t old_idx = 0; old_idx < inst->phys_dev_group_count_term; old_idx++) { - if (local_phys_dev_groups[new_idx].physicalDeviceCount == inst->phys_dev_groups_term[old_idx]->physicalDeviceCount) { - bool found_all_gpus = true; - for (uint32_t old_gpu = 0; old_gpu < inst->phys_dev_groups_term[old_idx]->physicalDeviceCount; old_gpu++) { - bool found_gpu = false; - for (uint32_t new_gpu = 0; new_gpu < local_phys_dev_groups[new_idx].physicalDeviceCount; new_gpu++) { - if (local_phys_dev_groups[new_idx].physicalDevices[new_gpu] == inst->phys_dev_groups_term[old_idx]->physicalDevices[old_gpu]) { - found_gpu = true; - break; - } - } - - if (!found_gpu) { - found_all_gpus = false; - break; - } - } - if (!found_all_gpus) { - continue; - } else { - new_phys_dev_groups[new_idx] = inst->phys_dev_groups_term[old_idx]; - break; - } - } - } - - // If this physical device group isn't in the old buffer, create it - if (NULL == new_phys_dev_groups[new_idx]) { - new_phys_dev_groups[new_idx] = (VkPhysicalDeviceGroupPropertiesKHR *)loader_instance_heap_alloc( - inst, sizeof(VkPhysicalDeviceGroupPropertiesKHR), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_dev_groups[new_idx]) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTermPhysDevGroups: Failed to allocate " - "physical device group Terminator object %d", - new_idx); - total_count = new_idx; - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memcpy(new_phys_dev_groups[new_idx], &local_phys_dev_groups[new_idx], - sizeof(VkPhysicalDeviceGroupPropertiesKHR)); - } - } - -out: - - if (VK_SUCCESS != res) { - if (NULL != new_phys_dev_groups) { - for (uint32_t i = 0; i < total_count; i++) { - loader_instance_heap_free(inst, new_phys_dev_groups[i]); - } - loader_instance_heap_free(inst, new_phys_dev_groups); - } - total_count = 0; - } else { - // Free everything that didn't carry over to the new array of - // physical device groups - if (NULL != inst->phys_dev_groups_term) { - for (uint32_t i = 0; i < inst->phys_dev_group_count_term; i++) { - bool found = false; - for (uint32_t j = 0; j < total_count; j++) { - if (inst->phys_dev_groups_term[i] == new_phys_dev_groups[j]) { - found = true; - break; - } - } - if (!found) { - loader_instance_heap_free(inst, inst->phys_dev_groups_term[i]); - } - } - loader_instance_heap_free(inst, inst->phys_dev_groups_term); - } - - // Swap in the new physical device group list - inst->phys_dev_group_count_term = total_count; - inst->phys_dev_groups_term = new_phys_dev_groups; - } - - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDeviceGroups( - VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) { - struct loader_instance *inst = (struct loader_instance *)instance; - VkResult res = VK_SUCCESS; - - // Always call the setup loader terminator physical device groups because they may - // have changed at any point. - res = setupLoaderTermPhysDevGroups(inst); - if (VK_SUCCESS != res) { - goto out; - } - - uint32_t copy_count = inst->phys_dev_group_count_term; - if (NULL != pPhysicalDeviceGroupProperties) { - if (copy_count > *pPhysicalDeviceGroupCount) { - copy_count = *pPhysicalDeviceGroupCount; - res = VK_INCOMPLETE; - } - - for (uint32_t i = 0; i < copy_count; i++) { - memcpy(&pPhysicalDeviceGroupProperties[i], inst->phys_dev_groups_term[i], - sizeof(VkPhysicalDeviceGroupPropertiesKHR)); - } - } - - *pPhysicalDeviceGroupCount = copy_count; - -out: - - return res; -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2 *pFeatures) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceFeatures2 fpGetPhysicalDeviceFeatures2 = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - fpGetPhysicalDeviceFeatures2 = icd_term->dispatch.GetPhysicalDeviceFeatures2KHR; - } else { - fpGetPhysicalDeviceFeatures2 = icd_term->dispatch.GetPhysicalDeviceFeatures2; - } - - if (fpGetPhysicalDeviceFeatures2 != NULL || !inst->enabled_known_extensions.khr_get_physical_device_properties2) { - // Pass the call to the driver - fpGetPhysicalDeviceFeatures2(phys_dev_term->phys_dev, pFeatures); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceFeatures2: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceFeatures", - icd_term->scanned_icd->lib_name); - - // Write to the VkPhysicalDeviceFeatures2 struct - icd_term->dispatch.GetPhysicalDeviceFeatures(phys_dev_term->phys_dev, &pFeatures->features); - - void *pNext = pFeatures->pNext; - while (pNext != NULL) { - switch (*(VkStructureType *)pNext) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - // Skip the check if VK_KHR_multiview is enabled because it's a device extension - // Write to the VkPhysicalDeviceMultiviewFeaturesKHR struct - VkPhysicalDeviceMultiviewFeaturesKHR *multiview_features = pNext; - multiview_features->multiview = VK_FALSE; - multiview_features->multiviewGeometryShader = VK_FALSE; - multiview_features->multiviewTessellationShader = VK_FALSE; - - pNext = multiview_features->pNext; - break; - } - default: { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceFeatures2: Emulation found unrecognized structure type in pFeatures->pNext - " - "this struct will be ignored"); - - struct VkStructureHeader *header = pNext; - pNext = (void *)header->pNext; - break; - } - } - } - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2 *pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceProperties2 fpGetPhysicalDeviceProperties2 = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - fpGetPhysicalDeviceProperties2 = icd_term->dispatch.GetPhysicalDeviceProperties2KHR; - } else { - fpGetPhysicalDeviceProperties2 = icd_term->dispatch.GetPhysicalDeviceProperties2; - } - - if (fpGetPhysicalDeviceProperties2 != NULL || !inst->enabled_known_extensions.khr_get_physical_device_properties2) { - // Pass the call to the driver - fpGetPhysicalDeviceProperties2(phys_dev_term->phys_dev, pProperties); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceProperties2: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceProperties", - icd_term->scanned_icd->lib_name); - - // Write to the VkPhysicalDeviceProperties2 struct - icd_term->dispatch.GetPhysicalDeviceProperties(phys_dev_term->phys_dev, &pProperties->properties); - - void *pNext = pProperties->pNext; - while (pNext != NULL) { - switch (*(VkStructureType *)pNext) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: { - VkPhysicalDeviceIDPropertiesKHR *id_properties = pNext; - - // Verify that "VK_KHR_external_memory_capabilities" is enabled - if (icd_term->this_instance->enabled_known_extensions.khr_external_memory_capabilities) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceProperties2: Emulation cannot generate unique IDs for struct " - "VkPhysicalDeviceIDProperties - setting IDs to zero instead"); - - // Write to the VkPhysicalDeviceIDPropertiesKHR struct - memset(id_properties->deviceUUID, 0, VK_UUID_SIZE); - memset(id_properties->driverUUID, 0, VK_UUID_SIZE); - id_properties->deviceLUIDValid = VK_FALSE; - } - - pNext = id_properties->pNext; - break; - } - default: { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceProperties2KHR: Emulation found unrecognized structure type in " - "pProperties->pNext - this struct will be ignored"); - - struct VkStructureHeader *header = pNext; - pNext = (void *)header->pNext; - break; - } - } - } - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, - VkFormatProperties2 *pFormatProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceFormatProperties2 fpGetPhysicalDeviceFormatProperties2 = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - fpGetPhysicalDeviceFormatProperties2 = icd_term->dispatch.GetPhysicalDeviceFormatProperties2KHR; - } else { - fpGetPhysicalDeviceFormatProperties2 = icd_term->dispatch.GetPhysicalDeviceFormatProperties2; - } - - if (fpGetPhysicalDeviceFormatProperties2 != NULL || !inst->enabled_known_extensions.khr_get_physical_device_properties2) { - // Pass the call to the driver - fpGetPhysicalDeviceFormatProperties2(phys_dev_term->phys_dev, format, pFormatProperties); - } else { - // Emulate the call - loader_log( - icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceFormatProperties2: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceFormatProperties", - icd_term->scanned_icd->lib_name); - - // Write to the VkFormatProperties2 struct - icd_term->dispatch.GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev, format, &pFormatProperties->formatProperties); - - if (pFormatProperties->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceFormatProperties2: Emulation found unrecognized structure type in " - "pFormatProperties->pNext - this struct will be ignored"); - } - } -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, - VkImageFormatProperties2KHR *pImageFormatProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceImageFormatProperties2 fpGetPhysicalDeviceImageFormatProperties2 = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - fpGetPhysicalDeviceImageFormatProperties2 = icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2KHR; - } else { - fpGetPhysicalDeviceImageFormatProperties2 = icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2; - } - - if (fpGetPhysicalDeviceImageFormatProperties2 != NULL || !inst->enabled_known_extensions.khr_get_physical_device_properties2) { - // Pass the call to the driver - return fpGetPhysicalDeviceImageFormatProperties2(phys_dev_term->phys_dev, pImageFormatInfo, pImageFormatProperties); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceImageFormatProperties2: Emulating call in ICD \"%s\" using " - "vkGetPhysicalDeviceImageFormatProperties", - icd_term->scanned_icd->lib_name); - - // If there is more info in either pNext, then this is unsupported - if (pImageFormatInfo->pNext != NULL || pImageFormatProperties->pNext != NULL) { - return VK_ERROR_FORMAT_NOT_SUPPORTED; - } - - // Write to the VkImageFormatProperties2KHR struct - return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties( - phys_dev_term->phys_dev, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, - pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties); - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceQueueFamilyProperties2 fpGetPhysicalDeviceQueueFamilyProperties2 = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - fpGetPhysicalDeviceQueueFamilyProperties2 = icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2KHR; - } else { - fpGetPhysicalDeviceQueueFamilyProperties2 = icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2; - } - - if (fpGetPhysicalDeviceQueueFamilyProperties2 != NULL || !inst->enabled_known_extensions.khr_get_physical_device_properties2) { - // Pass the call to the driver - fpGetPhysicalDeviceQueueFamilyProperties2(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceQueueFamilyProperties2: Emulating call in ICD \"%s\" using " - "vkGetPhysicalDeviceQueueFamilyProperties", - icd_term->scanned_icd->lib_name); - - if (pQueueFamilyProperties == NULL || *pQueueFamilyPropertyCount == 0) { - // Write to pQueueFamilyPropertyCount - icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, NULL); - } else { - // Allocate a temporary array for the output of the old function - VkQueueFamilyProperties *properties = loader_stack_alloc(*pQueueFamilyPropertyCount * sizeof(VkQueueFamilyProperties)); - if (properties == NULL) { - *pQueueFamilyPropertyCount = 0; - loader_log( - icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkGetPhysicalDeviceQueueFamilyProperties2: Out of memory - Failed to allocate array for loader emulation."); - return; - } - - icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, - properties); - for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) { - // Write to the VkQueueFamilyProperties2KHR struct - memcpy(&pQueueFamilyProperties[i].queueFamilyProperties, &properties[i], sizeof(VkQueueFamilyProperties)); - - if (pQueueFamilyProperties[i].pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceQueueFamilyProperties2: Emulation found unrecognized structure type in " - "pQueueFamilyProperties[%d].pNext - this struct will be ignored", - i); - } - } - } - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceMemoryProperties2 fpGetPhysicalDeviceMemoryProperties2 = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - fpGetPhysicalDeviceMemoryProperties2 = icd_term->dispatch.GetPhysicalDeviceMemoryProperties2KHR; - } else { - fpGetPhysicalDeviceMemoryProperties2 = icd_term->dispatch.GetPhysicalDeviceMemoryProperties2; - } - - if (fpGetPhysicalDeviceMemoryProperties2 != NULL || !inst->enabled_known_extensions.khr_get_physical_device_properties2) { - // Pass the call to the driver - fpGetPhysicalDeviceMemoryProperties2(phys_dev_term->phys_dev, pMemoryProperties); - } else { - // Emulate the call - loader_log( - icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceMemoryProperties2: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceMemoryProperties", - icd_term->scanned_icd->lib_name); - - // Write to the VkPhysicalDeviceMemoryProperties2 struct - icd_term->dispatch.GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev, &pMemoryProperties->memoryProperties); - - if (pMemoryProperties->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceMemoryProperties2: Emulation found unrecognized structure type in " - "pMemoryProperties->pNext - this struct will be ignored"); - } - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, - VkSparseImageFormatProperties2KHR *pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 fpGetPhysicalDeviceSparseImageFormatProperties2 = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - fpGetPhysicalDeviceSparseImageFormatProperties2 = icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2KHR; - } else { - fpGetPhysicalDeviceSparseImageFormatProperties2 = icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2; - } - - if (fpGetPhysicalDeviceSparseImageFormatProperties2 != NULL || !inst->enabled_known_extensions.khr_get_physical_device_properties2) { - // Pass the call to the driver - fpGetPhysicalDeviceSparseImageFormatProperties2(phys_dev_term->phys_dev, pFormatInfo, pPropertyCount, pProperties); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceSparseImageFormatProperties2: Emulating call in ICD \"%s\" using " - "vkGetPhysicalDeviceSparseImageFormatProperties", - icd_term->scanned_icd->lib_name); - - if (pFormatInfo->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceSparseImageFormatProperties2: Emulation found unrecognized structure type in " - "pFormatInfo->pNext - this struct will be ignored"); - } - - if (pProperties == NULL || *pPropertyCount == 0) { - // Write to pPropertyCount - icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties( - phys_dev_term->phys_dev, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, - pFormatInfo->tiling, pPropertyCount, NULL); - } else { - // Allocate a temporary array for the output of the old function - VkSparseImageFormatProperties *properties = - loader_stack_alloc(*pPropertyCount * sizeof(VkSparseImageMemoryRequirements)); - if (properties == NULL) { - *pPropertyCount = 0; - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkGetPhysicalDeviceSparseImageFormatProperties2: Out of memory - Failed to allocate array for " - "loader emulation."); - return; - } - - icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties( - phys_dev_term->phys_dev, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, - pFormatInfo->tiling, pPropertyCount, properties); - for (uint32_t i = 0; i < *pPropertyCount; ++i) { - // Write to the VkSparseImageFormatProperties2KHR struct - memcpy(&pProperties[i].properties, &properties[i], sizeof(VkSparseImageFormatProperties)); - - if (pProperties[i].pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceSparseImageFormatProperties2: Emulation found unrecognized structure type in " - "pProperties[%d].pNext - this struct will be ignored", - i); - } - } - } - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, - VkExternalBufferProperties *pExternalBufferProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceExternalBufferProperties fpGetPhysicalDeviceExternalBufferProperties = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_external_memory_capabilities) { - fpGetPhysicalDeviceExternalBufferProperties = icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHR; - } else { - fpGetPhysicalDeviceExternalBufferProperties = icd_term->dispatch.GetPhysicalDeviceExternalBufferProperties; - } - - if (fpGetPhysicalDeviceExternalBufferProperties || !inst->enabled_known_extensions.khr_external_memory_capabilities) { - // Pass the call to the driver - fpGetPhysicalDeviceExternalBufferProperties(phys_dev_term->phys_dev, pExternalBufferInfo, pExternalBufferProperties); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalBufferProperties: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name); - - if (pExternalBufferInfo->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalBufferProperties: Emulation found unrecognized structure type in " - "pExternalBufferInfo->pNext - this struct will be ignored"); - } - - // Fill in everything being unsupported - memset(&pExternalBufferProperties->externalMemoryProperties, 0, sizeof(VkExternalMemoryPropertiesKHR)); - - if (pExternalBufferProperties->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalBufferProperties: Emulation found unrecognized structure type in " - "pExternalBufferProperties->pNext - this struct will be ignored"); - } - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, - VkExternalSemaphoreProperties *pExternalSemaphoreProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceExternalSemaphoreProperties fpGetPhysicalDeviceExternalSemaphoreProperties = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_external_semaphore_capabilities) { - fpGetPhysicalDeviceExternalSemaphoreProperties = icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHR; - } else { - fpGetPhysicalDeviceExternalSemaphoreProperties = icd_term->dispatch.GetPhysicalDeviceExternalSemaphoreProperties; - } - - if (fpGetPhysicalDeviceExternalSemaphoreProperties != NULL || !inst->enabled_known_extensions.khr_external_semaphore_capabilities) { - // Pass the call to the driver - fpGetPhysicalDeviceExternalSemaphoreProperties(phys_dev_term->phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalSemaphoreProperties: Emulating call in ICD \"%s\"", - icd_term->scanned_icd->lib_name); - - if (pExternalSemaphoreInfo->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalSemaphoreProperties: Emulation found unrecognized structure type in " - "pExternalSemaphoreInfo->pNext - this struct will be ignored"); - } - - // Fill in everything being unsupported - pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0; - pExternalSemaphoreProperties->compatibleHandleTypes = 0; - pExternalSemaphoreProperties->externalSemaphoreFeatures = 0; - - if (pExternalSemaphoreProperties->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalSemaphoreProperties: Emulation found unrecognized structure type in " - "pExternalSemaphoreProperties->pNext - this struct will be ignored"); - } - } -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, - VkExternalFenceProperties *pExternalFenceProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - const struct loader_instance *inst = icd_term->this_instance; - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - PFN_vkGetPhysicalDeviceExternalFenceProperties fpGetPhysicalDeviceExternalFenceProperties = NULL; - if (inst != NULL && inst->enabled_known_extensions.khr_external_fence_capabilities) { - fpGetPhysicalDeviceExternalFenceProperties = icd_term->dispatch.GetPhysicalDeviceExternalFencePropertiesKHR; - } else { - fpGetPhysicalDeviceExternalFenceProperties = icd_term->dispatch.GetPhysicalDeviceExternalFenceProperties; - } - - if (fpGetPhysicalDeviceExternalFenceProperties != NULL || !inst->enabled_known_extensions.khr_external_fence_capabilities) { - // Pass the call to the driver - fpGetPhysicalDeviceExternalFenceProperties(phys_dev_term->phys_dev, pExternalFenceInfo, pExternalFenceProperties); - } else { - // Emulate the call - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalFenceProperties: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name); - - if (pExternalFenceInfo->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalFenceProperties: Emulation found unrecognized structure type in " - "pExternalFenceInfo->pNext - this struct will be ignored"); - } - - // Fill in everything being unsupported - pExternalFenceProperties->exportFromImportedHandleTypes = 0; - pExternalFenceProperties->compatibleHandleTypes = 0; - pExternalFenceProperties->externalFenceFeatures = 0; - - if (pExternalFenceProperties->pNext != NULL) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "vkGetPhysicalDeviceExternalFenceProperties: Emulation found unrecognized structure type in " - "pExternalFenceProperties->pNext - this struct will be ignored"); - } - } -} diff --git a/loader/loader.h b/loader/loader.h deleted file mode 100644 index 4114dbe9..00000000 --- a/loader/loader.h +++ /dev/null @@ -1,512 +0,0 @@ -/* - * - * Copyright (c) 2014-2017 The Khronos Group Inc. - * Copyright (c) 2014-2017 Valve Corporation - * Copyright (c) 2014-2017 LunarG, Inc. - * Copyright (C) 2015 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: Jon Ashburn - * Author: Courtney Goeltzenleuchter - * Author: Chia-I Wu - * Author: Chia-I Wu - * Author: Mark Lobodzinski - * - */ - -#ifndef LOADER_H -#define LOADER_H - -#include -#include "vk_loader_platform.h" -#include "vk_loader_layer.h" -#include -#include -#include -#include "vk_loader_extensions.h" - -#if defined(__GNUC__) && __GNUC__ >= 4 -#define LOADER_EXPORT __attribute__((visibility("default"))) -#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -#define LOADER_EXPORT __attribute__((visibility("default"))) -#else -#define LOADER_EXPORT -#endif - -// A debug option to disable allocators at compile time to investigate future issues. -#define DEBUG_DISABLE_APP_ALLOCATORS 0 - -#define MAX_STRING_SIZE 1024 - -// This is defined in vk_layer.h, but if there's problems we need to create the define -// here. -#ifndef MAX_NUM_UNKNOWN_EXTS -#define MAX_NUM_UNKNOWN_EXTS 250 -#endif - -enum layer_type_flags { - VK_LAYER_TYPE_FLAG_INSTANCE_LAYER = 0x1, // If not set, indicates Device layer - VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER = 0x2, // If not set, indicates Implicit layer - VK_LAYER_TYPE_FLAG_META_LAYER = 0x4, // If not set, indicates standard layer -}; - -typedef enum VkStringErrorFlagBits { - VK_STRING_ERROR_NONE = 0x00000000, - VK_STRING_ERROR_LENGTH = 0x00000001, - VK_STRING_ERROR_BAD_DATA = 0x00000002, -} VkStringErrorFlagBits; -typedef VkFlags VkStringErrorFlags; - -static const int MaxLoaderStringLength = 256; -static const char UTF8_ONE_BYTE_CODE = 0xC0; -static const char UTF8_ONE_BYTE_MASK = 0xE0; -static const char UTF8_TWO_BYTE_CODE = 0xE0; -static const char UTF8_TWO_BYTE_MASK = 0xF0; -static const char UTF8_THREE_BYTE_CODE = 0xF0; -static const char UTF8_THREE_BYTE_MASK = 0xF8; -static const char UTF8_DATA_BYTE_CODE = 0x80; -static const char UTF8_DATA_BYTE_MASK = 0xC0; - -struct VkStructureHeader { - VkStructureType sType; - const void *pNext; -}; - -// form of all dynamic lists/arrays -// only the list element should be changed -struct loader_generic_list { - size_t capacity; - uint32_t count; - void *list; -}; - -struct loader_extension_list { - size_t capacity; - uint32_t count; - VkExtensionProperties *list; -}; - -struct loader_dev_ext_props { - VkExtensionProperties props; - uint32_t entrypoint_count; - char **entrypoints; -}; - -struct loader_device_extension_list { - size_t capacity; - uint32_t count; - struct loader_dev_ext_props *list; -}; - -struct loader_name_value { - char name[MAX_STRING_SIZE]; - char value[MAX_STRING_SIZE]; -}; - -struct loader_layer_functions { - char str_gipa[MAX_STRING_SIZE]; - char str_gdpa[MAX_STRING_SIZE]; - char str_negotiate_interface[MAX_STRING_SIZE]; - PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_layer_interface; - PFN_vkGetInstanceProcAddr get_instance_proc_addr; - PFN_vkGetDeviceProcAddr get_device_proc_addr; - PFN_GetPhysicalDeviceProcAddr get_physical_device_proc_addr; -}; - -struct loader_layer_properties { - VkLayerProperties info; - enum layer_type_flags type_flags; - uint32_t interface_version; // PFN_vkNegotiateLoaderLayerInterfaceVersion - char lib_name[MAX_STRING_SIZE]; - loader_platform_dl_handle lib_handle; - struct loader_layer_functions functions; - struct loader_extension_list instance_extension_list; - struct loader_device_extension_list device_extension_list; - struct loader_name_value disable_env_var; - struct loader_name_value enable_env_var; - uint32_t num_component_layers; - char (*component_layer_names)[MAX_STRING_SIZE]; - struct { - char enumerate_instance_extension_properties[MAX_STRING_SIZE]; - char enumerate_instance_layer_properties[MAX_STRING_SIZE]; - char enumerate_instance_version[MAX_STRING_SIZE]; - } pre_instance_functions; -}; - -struct loader_layer_list { - size_t capacity; - uint32_t count; - struct loader_layer_properties *list; -}; - -struct loader_dispatch_hash_list { - size_t capacity; - uint32_t count; - uint32_t *index; // index into the dev_ext dispatch table -}; - -// loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.dev_ext have -// one to one correspondence; one loader_dispatch_hash_entry for one dev_ext -// dispatch entry. -// Also have a one to one correspondence with functions in dev_ext_trampoline.c -struct loader_dispatch_hash_entry { - char *func_name; - struct loader_dispatch_hash_list list; // to handle hashing collisions -}; - -typedef VkResult(VKAPI_PTR *PFN_vkDevExt)(VkDevice device); -struct loader_dev_ext_dispatch_table { - PFN_vkDevExt dev_ext[MAX_NUM_UNKNOWN_EXTS]; -}; - -struct loader_dev_dispatch_table { - VkLayerDispatchTable core_dispatch; - struct loader_dev_ext_dispatch_table ext_dispatch; -}; - -// per CreateDevice structure -struct loader_device { - struct loader_dev_dispatch_table loader_dispatch; - VkDevice chain_device; // device object from the dispatch chain - VkDevice icd_device; // device object from the icd - struct loader_physical_device_term *phys_dev_term; - - // List of activated layers. - // app_ is the version based on exactly what the application asked for. - // This is what must be returned to the application on Enumerate calls. - // expanded_ is the version based on expanding meta-layers into their - // individual component layers. This is what is used internally. - struct loader_layer_list app_activated_layer_list; - struct loader_layer_list expanded_activated_layer_list; - - VkAllocationCallbacks alloc_callbacks; - - // List of activated device extensions that have terminators implemented in the loader - struct { - bool khr_swapchain_enabled; - bool khr_display_swapchain_enabled; - bool ext_debug_marker_enabled; - bool ext_debug_utils_enabled; - } extensions; - - struct loader_device *next; -}; - -// Per ICD information - -// Per ICD structure -struct loader_icd_term { - // pointers to find other structs - const struct loader_scanned_icd *scanned_icd; - const struct loader_instance *this_instance; - struct loader_device *logical_device_list; - VkInstance instance; // instance object from the icd - struct loader_icd_term_dispatch dispatch; - - struct loader_icd_term *next; - - PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS]; -}; - -// Per ICD library structure -struct loader_icd_tramp_list { - size_t capacity; - uint32_t count; - struct loader_scanned_icd *scanned_list; -}; - -struct loader_instance_dispatch_table { - VkLayerInstanceDispatchTable layer_inst_disp; // must be first entry in structure - - // Physical device functions unknown to the loader - PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS]; -}; - -// Per instance structure -struct loader_instance { - struct loader_instance_dispatch_table *disp; // must be first entry in structure - - // Vulkan API version the app is intending to use. - uint16_t app_api_major_version; - uint16_t app_api_minor_version; - - // We need to manually track physical devices over time. If the user - // re-queries the information, we don't want to delete old data or - // create new data unless necessary. - uint32_t total_gpu_count; - uint32_t phys_dev_count_term; - struct loader_physical_device_term **phys_devs_term; - uint32_t phys_dev_count_tramp; - struct loader_physical_device_tramp **phys_devs_tramp; - - // We also need to manually track physical device groups, but we don't need - // loader specific structures since we have that content in the physical - // device stored internal to the public structures. - uint32_t phys_dev_group_count_term; - struct VkPhysicalDeviceGroupProperties **phys_dev_groups_term; - uint32_t phys_dev_group_count_tramp; - struct VkPhysicalDeviceGroupProperties **phys_dev_groups_tramp; - - struct loader_instance *next; - - uint32_t total_icd_count; - struct loader_icd_term *icd_terms; - struct loader_icd_tramp_list icd_tramp_list; - - struct loader_dispatch_hash_entry dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS]; - struct loader_dispatch_hash_entry phys_dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS]; - - struct loader_msg_callback_map_entry *icd_msg_callback_map; - - struct loader_layer_list instance_layer_list; - - // List of activated layers. - // app_ is the version based on exactly what the application asked for. - // This is what must be returned to the application on Enumerate calls. - // expanded_ is the version based on expanding meta-layers into their - // individual component layers. This is what is used internally. - struct loader_layer_list app_activated_layer_list; - struct loader_layer_list expanded_activated_layer_list; - - VkInstance instance; // layers/ICD instance returned to trampoline - - struct loader_extension_list ext_list; // icds and loaders extensions - union loader_instance_extension_enables enabled_known_extensions; - - VkLayerDbgFunctionNode *DbgFunctionHead; - uint32_t num_tmp_report_callbacks; - VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos; - VkDebugReportCallbackEXT *tmp_report_callbacks; - uint32_t num_tmp_messengers; - VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos; - VkDebugUtilsMessengerEXT *tmp_messengers; - - VkAllocationCallbacks alloc_callbacks; - - bool wsi_surface_enabled; -#ifdef VK_USE_PLATFORM_WIN32_KHR - bool wsi_win32_surface_enabled; -#endif -#ifdef VK_USE_PLATFORM_MIR_KHR - bool wsi_mir_surface_enabled; -#endif -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - bool wsi_wayland_surface_enabled; -#endif -#ifdef VK_USE_PLATFORM_XCB_KHR - bool wsi_xcb_surface_enabled; -#endif -#ifdef VK_USE_PLATFORM_XLIB_KHR - bool wsi_xlib_surface_enabled; -#endif -#ifdef VK_USE_PLATFORM_ANDROID_KHR - bool wsi_android_surface_enabled; -#endif -#ifdef VK_USE_PLATFORM_MACOS_MVK - bool wsi_macos_surface_enabled; -#endif -#ifdef VK_USE_PLATFORM_IOS_MVK - bool wsi_ios_surface_enabled; -#endif - bool wsi_display_enabled; -}; - -// VkPhysicalDevice requires special treatment by loader. Firstly, terminator -// code must be able to get the struct loader_icd_term to call into the proper -// driver (multiple ICD/gpu case). This can be accomplished by wrapping the -// created VkPhysicalDevice in loader terminate_EnumeratePhysicalDevices(). -// Secondly, the loader must be able to handle wrapped by layer VkPhysicalDevice -// in trampoline code. This implies, that the loader trampoline code must also -// wrap the VkPhysicalDevice object in trampoline code. Thus, loader has to -// wrap the VkPhysicalDevice created object twice. In trampoline code it can't -// rely on the terminator object wrapping since a layer may also wrap. Since -// trampoline code wraps the VkPhysicalDevice this means all loader trampoline -// code that passes a VkPhysicalDevice should unwrap it. - -// Per enumerated PhysicalDevice structure, used to wrap in trampoline code and -// also same structure used to wrap in terminator code -struct loader_physical_device_tramp { - struct loader_instance_dispatch_table *disp; // must be first entry in structure - struct loader_instance *this_instance; - VkPhysicalDevice phys_dev; // object from layers/loader terminator -}; - -// Per enumerated PhysicalDevice structure, used to wrap in terminator code -struct loader_physical_device_term { - struct loader_instance_dispatch_table *disp; // must be first entry in structure - struct loader_icd_term *this_icd_term; - uint8_t icd_index; - VkPhysicalDevice phys_dev; // object from ICD -}; - -struct loader_struct { - struct loader_instance *instances; -}; - -struct loader_scanned_icd { - char *lib_name; - loader_platform_dl_handle handle; - uint32_t api_version; - uint32_t interface_version; - PFN_vkGetInstanceProcAddr GetInstanceProcAddr; - PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr; - PFN_vkCreateInstance CreateInstance; - PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties; -}; - -static inline struct loader_instance *loader_instance(VkInstance instance) { return (struct loader_instance *)instance; } - -static inline VkPhysicalDevice loader_unwrap_physical_device(VkPhysicalDevice physicalDevice) { - struct loader_physical_device_tramp *phys_dev = (struct loader_physical_device_tramp *)physicalDevice; - return phys_dev->phys_dev; -} - -static inline void loader_set_dispatch(void *obj, const void *data) { *((const void **)obj) = data; } - -static inline VkLayerDispatchTable *loader_get_dispatch(const void *obj) { return *((VkLayerDispatchTable **)obj); } - -static inline struct loader_dev_dispatch_table *loader_get_dev_dispatch(const void *obj) { - return *((struct loader_dev_dispatch_table **)obj); -} - -static inline VkLayerInstanceDispatchTable *loader_get_instance_layer_dispatch(const void *obj) { - return *((VkLayerInstanceDispatchTable **)obj); -} - -static inline struct loader_instance_dispatch_table *loader_get_instance_dispatch(const void *obj) { - return *((struct loader_instance_dispatch_table **)obj); -} - -static inline void loader_init_dispatch(void *obj, const void *data) { -#ifdef DEBUG - assert(valid_loader_magic_value(obj) && - "Incompatible ICD, first dword must be initialized to " - "ICD_LOADER_MAGIC. See loader/README.md for details."); -#endif - - loader_set_dispatch(obj, data); -} - -// Global variables used across files -extern struct loader_struct loader; -extern THREAD_LOCAL_DECL struct loader_instance *tls_instance; -#if defined(_WIN32) && !defined(LOADER_DYNAMIC_LIB) -extern LOADER_PLATFORM_THREAD_ONCE_DEFINITION(once_init); -#endif -extern loader_platform_thread_mutex loader_lock; -extern loader_platform_thread_mutex loader_json_lock; - -struct loader_msg_callback_map_entry { - VkDebugReportCallbackEXT icd_obj; - VkDebugReportCallbackEXT loader_obj; -}; - -// Helper function definitions -void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope allocationScope); -void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory); -void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size, - VkSystemAllocationScope alloc_scope); -void *loader_instance_tls_heap_alloc(size_t size); -void loader_instance_tls_heap_free(void *pMemory); -void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope allocationScope); -void loader_device_heap_free(const struct loader_device *device, void *pMemory); -void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size, - VkSystemAllocationScope alloc_scope); - -void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...); - -bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2); - -VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count, - const char *const *ppEnabledLayerNames, const struct loader_layer_list *list); - -VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts, - const struct loader_layer_list *instance_layer, - const VkInstanceCreateInfo *pCreateInfo); - -void loader_initialize(void); -VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst, - struct loader_layer_properties *src); -bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count, - const VkExtensionProperties *ext_array); -bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list); - -VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list, - uint32_t prop_list_count, const VkExtensionProperties *props); -VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list, - const VkExtensionProperties *props, uint32_t entry_count, char **entrys); -VkResult loader_add_device_extensions(const struct loader_instance *inst, - PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties, - VkPhysicalDevice physical_device, const char *lib_name, - struct loader_extension_list *ext_list); -VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size); -void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list); -void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device, - struct loader_layer_list *layer_list); -void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list); -bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]); -VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count, - const struct loader_layer_properties *props); -void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags, - const struct loader_layer_list *source_list, struct loader_layer_list *target_list, - struct loader_layer_list *expanded_target_list); -void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list); -VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list); -void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers); -void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers); -bool loader_is_implicit_layer_enabled(const struct loader_instance *inst, const struct loader_layer_properties *prop); -VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list, - struct loader_extension_list *inst_exts); -struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index); -void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev); -void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName); -void *loader_get_dev_ext_trampoline(uint32_t index); -bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr, - void **term_addr); -void *loader_get_phys_dev_ext_tramp(uint32_t index); -void *loader_get_phys_dev_ext_termin(uint32_t index); -struct loader_instance *loader_get_instance(const VkInstance instance); -void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device, struct loader_layer_list *list); -struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator); -void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, - struct loader_device *found_dev); -void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, - struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator); -// NOTE: Outside of loader, this entry-point is only provided for error -// cleanup. -void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev, - const VkAllocationCallbacks *pAllocator); - -VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo, - const struct loader_layer_list *instance_layers); - -VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - struct loader_instance *inst, VkInstance *created_instance); - -void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst); - -VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst, - struct loader_device *dev); - -VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev, - const struct loader_layer_list *activated_device_layers, - const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo); - -VkResult setupLoaderTrampPhysDevs(VkInstance instance); -VkResult setupLoaderTermPhysDevs(struct loader_instance *inst); - -VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array); - -#endif // LOADER_H diff --git a/loader/loader.rc b/loader/loader.rc deleted file mode 100755 index fca74629..00000000 --- a/loader/loader.rc +++ /dev/null @@ -1,98 +0,0 @@ -// -// Copyright (c) 2014-2017 The Khronos Group Inc. -// Copyright (c) 2014-2017 Valve Corporation -// Copyright (c) 2014-2017 LunarG, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -// Author: David Pinedo -// - -/////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////// -// Start customize section -// Edit this section for your build -/////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////// - -#define VERSION_MAJOR 1 -#define VERSION_MINOR 0 -#define VERSION_PATCH 1111 -#define VERSION_BUILDNO 2222 - -#define VERSION_BUILD_DESCRIPTION "Dev Build" - -// All builds except release builds should set this to 0. -// Release builds should set this to 1. -#define VERSION_IS_RELEASEBUILD 0 - - -/////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////// -// End of customize section -/////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////// - -#include "winres.h" - -#define VER_FILE_VERSION VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_BUILDNO - -#define STRINGIZE2(s) #s -#define STRINGIZE(s) STRINGIZE2(s) - -#if VERSION_IS_RELEASEBUILD==1 - #define VER_FILE_DESCRIPTION_STR "Vulkan Loader" - #define VER_FILE_VERSION_STR STRINGIZE(VERSION_MAJOR) \ - "." STRINGIZE(VERSION_MINOR) \ - "." STRINGIZE(VERSION_PATCH) \ - "." STRINGIZE(VERSION_BUILDNO) -#else - #define VER_FILE_DESCRIPTION_STR "Vulkan Loader - " VERSION_BUILD_DESCRIPTION - #define VER_FILE_VERSION_STR STRINGIZE(VERSION_MAJOR) \ - "." STRINGIZE(VERSION_MINOR) \ - "." STRINGIZE(VERSION_PATCH) \ - "." STRINGIZE(VERSION_BUILDNO) \ - "." VERSION_BUILD_DESCRIPTION -#endif - - -VS_VERSION_INFO VERSIONINFO - FILEVERSION VER_FILE_VERSION - PRODUCTVERSION VER_FILE_VERSION - FILEFLAGSMASK 0x3fL -#ifdef _DEBUG - FILEFLAGS VS_FF_DEBUG -#else - FILEFLAGS 0x0L -#endif - - FILEOS 0x00000L - FILETYPE VFT_DLL - FILESUBTYPE 0x0L -BEGIN - BLOCK "StringFileInfo" - BEGIN - BLOCK "04090000" - BEGIN - VALUE "FileDescription", VER_FILE_DESCRIPTION_STR - VALUE "FileVersion", VER_FILE_VERSION_STR - VALUE "LegalCopyright", "Copyright (C) 2015-2018" - VALUE "ProductName", "Vulkan Runtime" - VALUE "ProductVersion", VER_FILE_VERSION_STR - END - END - BLOCK "VarFileInfo" - BEGIN - VALUE "Translation", 0x409, 0000 - END -END diff --git a/loader/loader_cmake_config.h.in b/loader/loader_cmake_config.h.in deleted file mode 100644 index 3bbc4612..00000000 --- a/loader/loader_cmake_config.h.in +++ /dev/null @@ -1,2 +0,0 @@ -#cmakedefine HAVE_SECURE_GETENV -#cmakedefine HAVE___SECURE_GETENV diff --git a/loader/murmurhash.c b/loader/murmurhash.c deleted file mode 100644 index 40f0d5e9..00000000 --- a/loader/murmurhash.c +++ /dev/null @@ -1,98 +0,0 @@ - -/** - * `murmurhash.h' - murmurhash - * - * copyright (c) 2014 joseph werle - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and/or associated documentation files (the "Materials"), to - * deal in the Materials without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Materials, and to permit persons to whom the Materials are - * furnished to do so, subject to the following conditions: - * - * The above copyright notice(s) and this permission notice shall be included in - * all copies or substantial portions of the Materials. - * - * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. - * - * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE - * USE OR OTHER DEALINGS IN THE MATERIALS. - */ - -#include -#include -#include -#include "murmurhash.h" - -uint32_t murmurhash(const char *key, size_t len, uint32_t seed) { - uint32_t c1 = 0xcc9e2d51; - uint32_t c2 = 0x1b873593; - uint32_t r1 = 15; - uint32_t r2 = 13; - uint32_t m = 5; - uint32_t n = 0xe6546b64; - uint32_t h = 0; - uint32_t k = 0; - uint8_t *d = (uint8_t *)key; // 32 bit extract from `key' - const uint32_t *chunks = NULL; - const uint8_t *tail = NULL; // tail - last 8 bytes - int i = 0; - int l = (int)len / 4; // chunk length - - h = seed; - - chunks = (const uint32_t *)(d + l * 4); // body - tail = (const uint8_t *)(d + l * 4); // last 8 byte chunk of `key' - - // for each 4 byte chunk of `key' - for (i = -l; i != 0; ++i) { - // next 4 byte chunk of `key' - k = chunks[i]; - - // encode next 4 byte chunk of `key' - k *= c1; - k = (k << r1) | (k >> (32 - r1)); - k *= c2; - - // append to hash - h ^= k; - h = (h << r2) | (h >> (32 - r2)); - h = h * m + n; - } - - k = 0; - - // remainder - switch (len & 3) { // `len % 4' - case 3: - k ^= (tail[2] << 16); - // fall through - case 2: - k ^= (tail[1] << 8); - // fall through - case 1: - k ^= tail[0]; - k *= c1; - k = (k << r1) | (k >> (32 - r1)); - k *= c2; - h ^= k; - } - - h ^= len; - - h ^= (h >> 16); - h *= 0x85ebca6b; - h ^= (h >> 13); - h *= 0xc2b2ae35; - h ^= (h >> 16); - - return h; -} diff --git a/loader/murmurhash.h b/loader/murmurhash.h deleted file mode 100644 index 775532e8..00000000 --- a/loader/murmurhash.h +++ /dev/null @@ -1,52 +0,0 @@ - -/** - * `murmurhash.h' - murmurhash - * - * copyright (c) 2014 joseph werle - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and/or associated documentation files (the "Materials"), to - * deal in the Materials without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Materials, and to permit persons to whom the Materials are - * furnished to do so, subject to the following conditions: - * - * The above copyright notice(s) and this permission notice shall be included in - * all copies or substantial portions of the Materials. - * - * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. - * - * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE - * USE OR OTHER DEALINGS IN THE MATERIALS. - */ - -#ifndef MURMURHASH_H -#define MURMURHASH_H 1 - -#include - -#define MURMURHASH_VERSION "0.0.3" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * Returns a murmur hash of `key' based on `seed' - * using the MurmurHash3 algorithm - */ - -uint32_t murmurhash(const char *key, size_t len, uint32_t seed); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/loader/phys_dev_ext.c b/loader/phys_dev_ext.c deleted file mode 100644 index 91e0ef8f..00000000 --- a/loader/phys_dev_ext.c +++ /dev/null @@ -1,1056 +0,0 @@ -/* - * - * Copyright (c) 2016-17 The Khronos Group Inc. - * Copyright (c) 2016-17 Valve Corporation - * Copyright (c) 2016-17 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Mark Young - * Author: Lenny Komow - * - */ - -// This code is used to enable generic instance extensions which use a physical device -// as the first parameter. If the extension is already known by the loader, it will -// not use this code, but instead use the more direct route. However, if it is -// unknown to the loader, it will use this code. Technically, this is not trampoline -// code since we don't want to optimize it out. - -#include "vk_loader_platform.h" -#include "loader.h" - -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC optimize(3) // force gcc to use tail-calls -#endif - -// Declarations for the trampoline -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp0(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp1(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp2(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp3(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp4(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp5(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp6(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp7(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp8(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp9(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp10(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp11(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp12(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp13(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp14(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp15(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp16(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp17(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp18(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp19(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp20(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp21(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp22(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp23(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp24(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp25(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp26(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp27(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp28(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp29(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp30(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp31(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp32(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp33(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp34(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp35(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp36(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp37(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp38(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp39(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp40(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp41(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp42(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp43(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp44(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp45(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp46(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp47(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp48(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp49(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp50(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp51(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp52(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp53(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp54(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp55(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp56(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp57(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp58(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp59(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp60(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp61(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp62(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp63(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp64(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp65(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp66(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp67(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp68(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp69(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp70(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp71(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp72(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp73(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp74(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp75(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp76(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp77(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp78(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp79(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp80(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp81(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp82(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp83(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp84(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp85(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp86(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp87(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp88(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp89(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp90(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp91(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp92(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp93(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp94(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp95(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp96(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp97(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp98(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp99(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp100(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp101(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp102(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp103(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp104(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp105(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp106(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp107(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp108(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp109(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp110(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp111(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp112(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp113(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp114(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp115(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp116(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp117(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp118(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp119(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp120(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp121(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp122(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp123(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp124(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp125(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp126(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp127(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp128(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp129(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp130(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp131(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp132(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp133(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp134(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp135(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp136(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp137(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp138(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp139(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp140(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp141(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp142(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp143(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp144(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp145(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp146(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp147(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp148(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp149(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp150(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp151(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp152(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp153(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp154(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp155(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp156(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp157(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp158(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp159(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp160(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp161(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp162(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp163(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp164(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp165(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp166(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp167(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp168(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp169(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp170(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp171(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp172(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp173(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp174(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp175(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp176(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp177(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp178(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp179(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp180(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp181(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp182(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp183(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp184(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp185(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp186(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp187(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp188(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp189(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp190(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp191(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp192(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp193(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp194(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp195(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp196(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp197(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp198(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp199(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp200(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp201(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp202(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp203(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp204(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp205(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp206(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp207(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp208(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp209(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp210(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp211(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp212(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp213(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp214(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp215(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp216(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp217(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp218(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp219(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp220(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp221(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp222(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp223(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp224(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp225(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp226(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp227(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp228(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp229(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp230(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp231(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp232(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp233(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp234(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp235(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp236(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp237(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp238(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp239(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp240(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp241(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp242(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp243(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp244(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp245(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp246(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp247(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp248(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp249(VkPhysicalDevice); - -// Disable clang-format for lists of macros -// clang-format off - -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin0(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin1(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin2(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin3(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin4(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin5(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin6(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin7(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin8(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin9(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin10(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin11(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin12(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin13(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin14(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin15(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin16(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin17(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin18(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin19(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin20(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin21(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin22(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin23(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin24(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin25(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin26(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin27(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin28(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin29(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin30(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin31(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin32(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin33(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin34(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin35(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin36(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin37(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin38(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin39(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin40(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin41(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin42(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin43(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin44(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin45(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin46(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin47(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin48(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin49(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin50(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin51(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin52(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin53(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin54(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin55(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin56(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin57(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin58(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin59(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin60(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin61(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin62(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin63(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin64(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin65(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin66(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin67(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin68(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin69(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin70(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin71(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin72(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin73(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin74(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin75(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin76(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin77(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin78(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin79(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin80(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin81(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin82(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin83(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin84(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin85(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin86(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin87(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin88(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin89(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin90(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin91(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin92(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin93(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin94(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin95(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin96(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin97(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin98(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin99(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin100(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin101(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin102(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin103(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin104(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin105(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin106(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin107(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin108(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin109(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin110(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin111(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin112(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin113(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin114(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin115(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin116(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin117(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin118(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin119(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin120(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin121(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin122(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin123(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin124(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin125(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin126(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin127(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin128(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin129(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin130(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin131(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin132(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin133(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin134(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin135(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin136(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin137(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin138(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin139(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin140(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin141(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin142(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin143(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin144(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin145(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin146(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin147(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin148(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin149(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin150(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin151(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin152(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin153(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin154(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin155(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin156(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin157(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin158(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin159(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin160(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin161(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin162(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin163(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin164(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin165(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin166(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin167(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin168(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin169(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin170(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin171(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin172(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin173(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin174(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin175(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin176(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin177(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin178(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin179(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin180(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin181(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin182(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin183(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin184(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin185(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin186(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin187(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin188(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin189(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin190(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin191(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin192(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin193(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin194(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin195(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin196(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin197(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin198(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin199(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin200(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin201(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin202(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin203(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin204(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin205(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin206(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin207(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin208(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin209(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin210(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin211(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin212(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin213(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin214(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin215(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin216(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin217(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin218(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin219(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin220(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin221(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin222(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin223(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin224(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin225(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin226(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin227(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin228(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin229(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin230(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin231(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin232(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin233(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin234(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin235(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin236(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin237(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin238(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin239(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin240(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin241(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin242(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin243(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin244(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin245(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin246(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin247(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin248(VkPhysicalDevice); -VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin249(VkPhysicalDevice); - - -void *loader_get_phys_dev_ext_tramp(uint32_t index) { - switch (index) { -#define TRAMP_CASE_HANDLE(num) case num: return vkPhysDevExtTramp##num - TRAMP_CASE_HANDLE(0); - TRAMP_CASE_HANDLE(1); - TRAMP_CASE_HANDLE(2); - TRAMP_CASE_HANDLE(3); - TRAMP_CASE_HANDLE(4); - TRAMP_CASE_HANDLE(5); - TRAMP_CASE_HANDLE(6); - TRAMP_CASE_HANDLE(7); - TRAMP_CASE_HANDLE(8); - TRAMP_CASE_HANDLE(9); - TRAMP_CASE_HANDLE(10); - TRAMP_CASE_HANDLE(11); - TRAMP_CASE_HANDLE(12); - TRAMP_CASE_HANDLE(13); - TRAMP_CASE_HANDLE(14); - TRAMP_CASE_HANDLE(15); - TRAMP_CASE_HANDLE(16); - TRAMP_CASE_HANDLE(17); - TRAMP_CASE_HANDLE(18); - TRAMP_CASE_HANDLE(19); - TRAMP_CASE_HANDLE(20); - TRAMP_CASE_HANDLE(21); - TRAMP_CASE_HANDLE(22); - TRAMP_CASE_HANDLE(23); - TRAMP_CASE_HANDLE(24); - TRAMP_CASE_HANDLE(25); - TRAMP_CASE_HANDLE(26); - TRAMP_CASE_HANDLE(27); - TRAMP_CASE_HANDLE(28); - TRAMP_CASE_HANDLE(29); - TRAMP_CASE_HANDLE(30); - TRAMP_CASE_HANDLE(31); - TRAMP_CASE_HANDLE(32); - TRAMP_CASE_HANDLE(33); - TRAMP_CASE_HANDLE(34); - TRAMP_CASE_HANDLE(35); - TRAMP_CASE_HANDLE(36); - TRAMP_CASE_HANDLE(37); - TRAMP_CASE_HANDLE(38); - TRAMP_CASE_HANDLE(39); - TRAMP_CASE_HANDLE(40); - TRAMP_CASE_HANDLE(41); - TRAMP_CASE_HANDLE(42); - TRAMP_CASE_HANDLE(43); - TRAMP_CASE_HANDLE(44); - TRAMP_CASE_HANDLE(45); - TRAMP_CASE_HANDLE(46); - TRAMP_CASE_HANDLE(47); - TRAMP_CASE_HANDLE(48); - TRAMP_CASE_HANDLE(49); - TRAMP_CASE_HANDLE(50); - TRAMP_CASE_HANDLE(51); - TRAMP_CASE_HANDLE(52); - TRAMP_CASE_HANDLE(53); - TRAMP_CASE_HANDLE(54); - TRAMP_CASE_HANDLE(55); - TRAMP_CASE_HANDLE(56); - TRAMP_CASE_HANDLE(57); - TRAMP_CASE_HANDLE(58); - TRAMP_CASE_HANDLE(59); - TRAMP_CASE_HANDLE(60); - TRAMP_CASE_HANDLE(61); - TRAMP_CASE_HANDLE(62); - TRAMP_CASE_HANDLE(63); - TRAMP_CASE_HANDLE(64); - TRAMP_CASE_HANDLE(65); - TRAMP_CASE_HANDLE(66); - TRAMP_CASE_HANDLE(67); - TRAMP_CASE_HANDLE(68); - TRAMP_CASE_HANDLE(69); - TRAMP_CASE_HANDLE(70); - TRAMP_CASE_HANDLE(71); - TRAMP_CASE_HANDLE(72); - TRAMP_CASE_HANDLE(73); - TRAMP_CASE_HANDLE(74); - TRAMP_CASE_HANDLE(75); - TRAMP_CASE_HANDLE(76); - TRAMP_CASE_HANDLE(77); - TRAMP_CASE_HANDLE(78); - TRAMP_CASE_HANDLE(79); - TRAMP_CASE_HANDLE(80); - TRAMP_CASE_HANDLE(81); - TRAMP_CASE_HANDLE(82); - TRAMP_CASE_HANDLE(83); - TRAMP_CASE_HANDLE(84); - TRAMP_CASE_HANDLE(85); - TRAMP_CASE_HANDLE(86); - TRAMP_CASE_HANDLE(87); - TRAMP_CASE_HANDLE(88); - TRAMP_CASE_HANDLE(89); - TRAMP_CASE_HANDLE(90); - TRAMP_CASE_HANDLE(91); - TRAMP_CASE_HANDLE(92); - TRAMP_CASE_HANDLE(93); - TRAMP_CASE_HANDLE(94); - TRAMP_CASE_HANDLE(95); - TRAMP_CASE_HANDLE(96); - TRAMP_CASE_HANDLE(97); - TRAMP_CASE_HANDLE(98); - TRAMP_CASE_HANDLE(99); - TRAMP_CASE_HANDLE(100); - TRAMP_CASE_HANDLE(101); - TRAMP_CASE_HANDLE(102); - TRAMP_CASE_HANDLE(103); - TRAMP_CASE_HANDLE(104); - TRAMP_CASE_HANDLE(105); - TRAMP_CASE_HANDLE(106); - TRAMP_CASE_HANDLE(107); - TRAMP_CASE_HANDLE(108); - TRAMP_CASE_HANDLE(109); - TRAMP_CASE_HANDLE(110); - TRAMP_CASE_HANDLE(111); - TRAMP_CASE_HANDLE(112); - TRAMP_CASE_HANDLE(113); - TRAMP_CASE_HANDLE(114); - TRAMP_CASE_HANDLE(115); - TRAMP_CASE_HANDLE(116); - TRAMP_CASE_HANDLE(117); - TRAMP_CASE_HANDLE(118); - TRAMP_CASE_HANDLE(119); - TRAMP_CASE_HANDLE(120); - TRAMP_CASE_HANDLE(121); - TRAMP_CASE_HANDLE(122); - TRAMP_CASE_HANDLE(123); - TRAMP_CASE_HANDLE(124); - TRAMP_CASE_HANDLE(125); - TRAMP_CASE_HANDLE(126); - TRAMP_CASE_HANDLE(127); - TRAMP_CASE_HANDLE(128); - TRAMP_CASE_HANDLE(129); - TRAMP_CASE_HANDLE(130); - TRAMP_CASE_HANDLE(131); - TRAMP_CASE_HANDLE(132); - TRAMP_CASE_HANDLE(133); - TRAMP_CASE_HANDLE(134); - TRAMP_CASE_HANDLE(135); - TRAMP_CASE_HANDLE(136); - TRAMP_CASE_HANDLE(137); - TRAMP_CASE_HANDLE(138); - TRAMP_CASE_HANDLE(139); - TRAMP_CASE_HANDLE(140); - TRAMP_CASE_HANDLE(141); - TRAMP_CASE_HANDLE(142); - TRAMP_CASE_HANDLE(143); - TRAMP_CASE_HANDLE(144); - TRAMP_CASE_HANDLE(145); - TRAMP_CASE_HANDLE(146); - TRAMP_CASE_HANDLE(147); - TRAMP_CASE_HANDLE(148); - TRAMP_CASE_HANDLE(149); - TRAMP_CASE_HANDLE(150); - TRAMP_CASE_HANDLE(151); - TRAMP_CASE_HANDLE(152); - TRAMP_CASE_HANDLE(153); - TRAMP_CASE_HANDLE(154); - TRAMP_CASE_HANDLE(155); - TRAMP_CASE_HANDLE(156); - TRAMP_CASE_HANDLE(157); - TRAMP_CASE_HANDLE(158); - TRAMP_CASE_HANDLE(159); - TRAMP_CASE_HANDLE(160); - TRAMP_CASE_HANDLE(161); - TRAMP_CASE_HANDLE(162); - TRAMP_CASE_HANDLE(163); - TRAMP_CASE_HANDLE(164); - TRAMP_CASE_HANDLE(165); - TRAMP_CASE_HANDLE(166); - TRAMP_CASE_HANDLE(167); - TRAMP_CASE_HANDLE(168); - TRAMP_CASE_HANDLE(169); - TRAMP_CASE_HANDLE(170); - TRAMP_CASE_HANDLE(171); - TRAMP_CASE_HANDLE(172); - TRAMP_CASE_HANDLE(173); - TRAMP_CASE_HANDLE(174); - TRAMP_CASE_HANDLE(175); - TRAMP_CASE_HANDLE(176); - TRAMP_CASE_HANDLE(177); - TRAMP_CASE_HANDLE(178); - TRAMP_CASE_HANDLE(179); - TRAMP_CASE_HANDLE(180); - TRAMP_CASE_HANDLE(181); - TRAMP_CASE_HANDLE(182); - TRAMP_CASE_HANDLE(183); - TRAMP_CASE_HANDLE(184); - TRAMP_CASE_HANDLE(185); - TRAMP_CASE_HANDLE(186); - TRAMP_CASE_HANDLE(187); - TRAMP_CASE_HANDLE(188); - TRAMP_CASE_HANDLE(189); - TRAMP_CASE_HANDLE(190); - TRAMP_CASE_HANDLE(191); - TRAMP_CASE_HANDLE(192); - TRAMP_CASE_HANDLE(193); - TRAMP_CASE_HANDLE(194); - TRAMP_CASE_HANDLE(195); - TRAMP_CASE_HANDLE(196); - TRAMP_CASE_HANDLE(197); - TRAMP_CASE_HANDLE(198); - TRAMP_CASE_HANDLE(199); - TRAMP_CASE_HANDLE(200); - TRAMP_CASE_HANDLE(201); - TRAMP_CASE_HANDLE(202); - TRAMP_CASE_HANDLE(203); - TRAMP_CASE_HANDLE(204); - TRAMP_CASE_HANDLE(205); - TRAMP_CASE_HANDLE(206); - TRAMP_CASE_HANDLE(207); - TRAMP_CASE_HANDLE(208); - TRAMP_CASE_HANDLE(209); - TRAMP_CASE_HANDLE(210); - TRAMP_CASE_HANDLE(211); - TRAMP_CASE_HANDLE(212); - TRAMP_CASE_HANDLE(213); - TRAMP_CASE_HANDLE(214); - TRAMP_CASE_HANDLE(215); - TRAMP_CASE_HANDLE(216); - TRAMP_CASE_HANDLE(217); - TRAMP_CASE_HANDLE(218); - TRAMP_CASE_HANDLE(219); - TRAMP_CASE_HANDLE(220); - TRAMP_CASE_HANDLE(221); - TRAMP_CASE_HANDLE(222); - TRAMP_CASE_HANDLE(223); - TRAMP_CASE_HANDLE(224); - TRAMP_CASE_HANDLE(225); - TRAMP_CASE_HANDLE(226); - TRAMP_CASE_HANDLE(227); - TRAMP_CASE_HANDLE(228); - TRAMP_CASE_HANDLE(229); - TRAMP_CASE_HANDLE(230); - TRAMP_CASE_HANDLE(231); - TRAMP_CASE_HANDLE(232); - TRAMP_CASE_HANDLE(233); - TRAMP_CASE_HANDLE(234); - TRAMP_CASE_HANDLE(235); - TRAMP_CASE_HANDLE(236); - TRAMP_CASE_HANDLE(237); - TRAMP_CASE_HANDLE(238); - TRAMP_CASE_HANDLE(239); - TRAMP_CASE_HANDLE(240); - TRAMP_CASE_HANDLE(241); - TRAMP_CASE_HANDLE(242); - TRAMP_CASE_HANDLE(243); - TRAMP_CASE_HANDLE(244); - TRAMP_CASE_HANDLE(245); - TRAMP_CASE_HANDLE(246); - TRAMP_CASE_HANDLE(247); - TRAMP_CASE_HANDLE(248); - TRAMP_CASE_HANDLE(249); - } - return NULL; -} - -void *loader_get_phys_dev_ext_termin(uint32_t index) { - switch (index) { -#define TERM_CASE_HANDLE(num) case num: return vkPhysDevExtTermin##num - TERM_CASE_HANDLE(0); - TERM_CASE_HANDLE(1); - TERM_CASE_HANDLE(2); - TERM_CASE_HANDLE(3); - TERM_CASE_HANDLE(4); - TERM_CASE_HANDLE(5); - TERM_CASE_HANDLE(6); - TERM_CASE_HANDLE(7); - TERM_CASE_HANDLE(8); - TERM_CASE_HANDLE(9); - TERM_CASE_HANDLE(10); - TERM_CASE_HANDLE(11); - TERM_CASE_HANDLE(12); - TERM_CASE_HANDLE(13); - TERM_CASE_HANDLE(14); - TERM_CASE_HANDLE(15); - TERM_CASE_HANDLE(16); - TERM_CASE_HANDLE(17); - TERM_CASE_HANDLE(18); - TERM_CASE_HANDLE(19); - TERM_CASE_HANDLE(20); - TERM_CASE_HANDLE(21); - TERM_CASE_HANDLE(22); - TERM_CASE_HANDLE(23); - TERM_CASE_HANDLE(24); - TERM_CASE_HANDLE(25); - TERM_CASE_HANDLE(26); - TERM_CASE_HANDLE(27); - TERM_CASE_HANDLE(28); - TERM_CASE_HANDLE(29); - TERM_CASE_HANDLE(30); - TERM_CASE_HANDLE(31); - TERM_CASE_HANDLE(32); - TERM_CASE_HANDLE(33); - TERM_CASE_HANDLE(34); - TERM_CASE_HANDLE(35); - TERM_CASE_HANDLE(36); - TERM_CASE_HANDLE(37); - TERM_CASE_HANDLE(38); - TERM_CASE_HANDLE(39); - TERM_CASE_HANDLE(40); - TERM_CASE_HANDLE(41); - TERM_CASE_HANDLE(42); - TERM_CASE_HANDLE(43); - TERM_CASE_HANDLE(44); - TERM_CASE_HANDLE(45); - TERM_CASE_HANDLE(46); - TERM_CASE_HANDLE(47); - TERM_CASE_HANDLE(48); - TERM_CASE_HANDLE(49); - TERM_CASE_HANDLE(50); - TERM_CASE_HANDLE(51); - TERM_CASE_HANDLE(52); - TERM_CASE_HANDLE(53); - TERM_CASE_HANDLE(54); - TERM_CASE_HANDLE(55); - TERM_CASE_HANDLE(56); - TERM_CASE_HANDLE(57); - TERM_CASE_HANDLE(58); - TERM_CASE_HANDLE(59); - TERM_CASE_HANDLE(60); - TERM_CASE_HANDLE(61); - TERM_CASE_HANDLE(62); - TERM_CASE_HANDLE(63); - TERM_CASE_HANDLE(64); - TERM_CASE_HANDLE(65); - TERM_CASE_HANDLE(66); - TERM_CASE_HANDLE(67); - TERM_CASE_HANDLE(68); - TERM_CASE_HANDLE(69); - TERM_CASE_HANDLE(70); - TERM_CASE_HANDLE(71); - TERM_CASE_HANDLE(72); - TERM_CASE_HANDLE(73); - TERM_CASE_HANDLE(74); - TERM_CASE_HANDLE(75); - TERM_CASE_HANDLE(76); - TERM_CASE_HANDLE(77); - TERM_CASE_HANDLE(78); - TERM_CASE_HANDLE(79); - TERM_CASE_HANDLE(80); - TERM_CASE_HANDLE(81); - TERM_CASE_HANDLE(82); - TERM_CASE_HANDLE(83); - TERM_CASE_HANDLE(84); - TERM_CASE_HANDLE(85); - TERM_CASE_HANDLE(86); - TERM_CASE_HANDLE(87); - TERM_CASE_HANDLE(88); - TERM_CASE_HANDLE(89); - TERM_CASE_HANDLE(90); - TERM_CASE_HANDLE(91); - TERM_CASE_HANDLE(92); - TERM_CASE_HANDLE(93); - TERM_CASE_HANDLE(94); - TERM_CASE_HANDLE(95); - TERM_CASE_HANDLE(96); - TERM_CASE_HANDLE(97); - TERM_CASE_HANDLE(98); - TERM_CASE_HANDLE(99); - TERM_CASE_HANDLE(100); - TERM_CASE_HANDLE(101); - TERM_CASE_HANDLE(102); - TERM_CASE_HANDLE(103); - TERM_CASE_HANDLE(104); - TERM_CASE_HANDLE(105); - TERM_CASE_HANDLE(106); - TERM_CASE_HANDLE(107); - TERM_CASE_HANDLE(108); - TERM_CASE_HANDLE(109); - TERM_CASE_HANDLE(110); - TERM_CASE_HANDLE(111); - TERM_CASE_HANDLE(112); - TERM_CASE_HANDLE(113); - TERM_CASE_HANDLE(114); - TERM_CASE_HANDLE(115); - TERM_CASE_HANDLE(116); - TERM_CASE_HANDLE(117); - TERM_CASE_HANDLE(118); - TERM_CASE_HANDLE(119); - TERM_CASE_HANDLE(120); - TERM_CASE_HANDLE(121); - TERM_CASE_HANDLE(122); - TERM_CASE_HANDLE(123); - TERM_CASE_HANDLE(124); - TERM_CASE_HANDLE(125); - TERM_CASE_HANDLE(126); - TERM_CASE_HANDLE(127); - TERM_CASE_HANDLE(128); - TERM_CASE_HANDLE(129); - TERM_CASE_HANDLE(130); - TERM_CASE_HANDLE(131); - TERM_CASE_HANDLE(132); - TERM_CASE_HANDLE(133); - TERM_CASE_HANDLE(134); - TERM_CASE_HANDLE(135); - TERM_CASE_HANDLE(136); - TERM_CASE_HANDLE(137); - TERM_CASE_HANDLE(138); - TERM_CASE_HANDLE(139); - TERM_CASE_HANDLE(140); - TERM_CASE_HANDLE(141); - TERM_CASE_HANDLE(142); - TERM_CASE_HANDLE(143); - TERM_CASE_HANDLE(144); - TERM_CASE_HANDLE(145); - TERM_CASE_HANDLE(146); - TERM_CASE_HANDLE(147); - TERM_CASE_HANDLE(148); - TERM_CASE_HANDLE(149); - TERM_CASE_HANDLE(150); - TERM_CASE_HANDLE(151); - TERM_CASE_HANDLE(152); - TERM_CASE_HANDLE(153); - TERM_CASE_HANDLE(154); - TERM_CASE_HANDLE(155); - TERM_CASE_HANDLE(156); - TERM_CASE_HANDLE(157); - TERM_CASE_HANDLE(158); - TERM_CASE_HANDLE(159); - TERM_CASE_HANDLE(160); - TERM_CASE_HANDLE(161); - TERM_CASE_HANDLE(162); - TERM_CASE_HANDLE(163); - TERM_CASE_HANDLE(164); - TERM_CASE_HANDLE(165); - TERM_CASE_HANDLE(166); - TERM_CASE_HANDLE(167); - TERM_CASE_HANDLE(168); - TERM_CASE_HANDLE(169); - TERM_CASE_HANDLE(170); - TERM_CASE_HANDLE(171); - TERM_CASE_HANDLE(172); - TERM_CASE_HANDLE(173); - TERM_CASE_HANDLE(174); - TERM_CASE_HANDLE(175); - TERM_CASE_HANDLE(176); - TERM_CASE_HANDLE(177); - TERM_CASE_HANDLE(178); - TERM_CASE_HANDLE(179); - TERM_CASE_HANDLE(180); - TERM_CASE_HANDLE(181); - TERM_CASE_HANDLE(182); - TERM_CASE_HANDLE(183); - TERM_CASE_HANDLE(184); - TERM_CASE_HANDLE(185); - TERM_CASE_HANDLE(186); - TERM_CASE_HANDLE(187); - TERM_CASE_HANDLE(188); - TERM_CASE_HANDLE(189); - TERM_CASE_HANDLE(190); - TERM_CASE_HANDLE(191); - TERM_CASE_HANDLE(192); - TERM_CASE_HANDLE(193); - TERM_CASE_HANDLE(194); - TERM_CASE_HANDLE(195); - TERM_CASE_HANDLE(196); - TERM_CASE_HANDLE(197); - TERM_CASE_HANDLE(198); - TERM_CASE_HANDLE(199); - TERM_CASE_HANDLE(200); - TERM_CASE_HANDLE(201); - TERM_CASE_HANDLE(202); - TERM_CASE_HANDLE(203); - TERM_CASE_HANDLE(204); - TERM_CASE_HANDLE(205); - TERM_CASE_HANDLE(206); - TERM_CASE_HANDLE(207); - TERM_CASE_HANDLE(208); - TERM_CASE_HANDLE(209); - TERM_CASE_HANDLE(210); - TERM_CASE_HANDLE(211); - TERM_CASE_HANDLE(212); - TERM_CASE_HANDLE(213); - TERM_CASE_HANDLE(214); - TERM_CASE_HANDLE(215); - TERM_CASE_HANDLE(216); - TERM_CASE_HANDLE(217); - TERM_CASE_HANDLE(218); - TERM_CASE_HANDLE(219); - TERM_CASE_HANDLE(220); - TERM_CASE_HANDLE(221); - TERM_CASE_HANDLE(222); - TERM_CASE_HANDLE(223); - TERM_CASE_HANDLE(224); - TERM_CASE_HANDLE(225); - TERM_CASE_HANDLE(226); - TERM_CASE_HANDLE(227); - TERM_CASE_HANDLE(228); - TERM_CASE_HANDLE(229); - TERM_CASE_HANDLE(230); - TERM_CASE_HANDLE(231); - TERM_CASE_HANDLE(232); - TERM_CASE_HANDLE(233); - TERM_CASE_HANDLE(234); - TERM_CASE_HANDLE(235); - TERM_CASE_HANDLE(236); - TERM_CASE_HANDLE(237); - TERM_CASE_HANDLE(238); - TERM_CASE_HANDLE(239); - TERM_CASE_HANDLE(240); - TERM_CASE_HANDLE(241); - TERM_CASE_HANDLE(242); - TERM_CASE_HANDLE(243); - TERM_CASE_HANDLE(244); - TERM_CASE_HANDLE(245); - TERM_CASE_HANDLE(246); - TERM_CASE_HANDLE(247); - TERM_CASE_HANDLE(248); - TERM_CASE_HANDLE(249); - } - return NULL; -} diff --git a/loader/trampoline.c b/loader/trampoline.c deleted file mode 100644 index 212f0f55..00000000 --- a/loader/trampoline.c +++ /dev/null @@ -1,2637 +0,0 @@ -/* - * - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * Copyright (C) 2015 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: Courtney Goeltzenleuchter - * Author: Jon Ashburn - * Author: Tony Barbour - * Author: Chia-I Wu - */ -#define _GNU_SOURCE -#include -#include - -#include "vk_loader_platform.h" -#include "loader.h" -#include "debug_utils.h" -#include "wsi.h" -#include "vk_loader_extensions.h" -#include "gpa_helper.h" - - -// Trampoline entrypoints are in this file for core Vulkan commands - -// Get an instance level or global level entry point address. -// @param instance -// @param pName -// @return -// If instance == NULL returns a global level functions only -// If instance is valid returns a trampoline entry point for all dispatchable Vulkan -// functions both core and extensions. -LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName) { - void *addr; - - addr = globalGetProcAddr(pName); - if (instance == VK_NULL_HANDLE || addr != NULL) { - return addr; - } - - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (ptr_instance == NULL) return NULL; - // Return trampoline code for non-global entrypoints including any extensions. - // Device extensions are returned if a layer or ICD supports the extension. - // Instance extensions are returned if the extension is enabled and the - // loader or someone else supports the extension - return trampolineGetProcAddr(ptr_instance, pName); -} - -// Get a device level or global level entry point address. -// @param device -// @param pName -// @return -// If device is valid, returns a device relative entry point for device level -// entry points both core and extensions. -// Device relative means call down the device chain. -LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName) { - void *addr; - - // For entrypoints that loader must handle (ie non-dispatchable or create object) - // make sure the loader entrypoint is returned - addr = loader_non_passthrough_gdpa(pName); - if (addr) { - return addr; - } - - // Although CreateDevice is on device chain it's dispatchable object isn't - // a VkDevice or child of VkDevice so return NULL. - if (!strcmp(pName, "CreateDevice")) return NULL; - - // Return the dispatch table entrypoint for the fastest case - const VkLayerDispatchTable *disp_table = *(VkLayerDispatchTable **)device; - if (disp_table == NULL) return NULL; - - addr = loader_lookup_device_dispatch_table(disp_table, pName); - if (addr) return addr; - - if (disp_table->GetDeviceProcAddr == NULL) return NULL; - return disp_table->GetDeviceProcAddr(device, pName); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, - uint32_t *pPropertyCount, - VkExtensionProperties *pProperties) { - tls_instance = NULL; - LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize); - - // We know we need to call at least the terminator - VkResult res = VK_SUCCESS; - VkEnumerateInstanceExtensionPropertiesChain chain_tail = { - .header = - { - .type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES, - .version = VK_CURRENT_CHAIN_VERSION, - .size = sizeof(chain_tail), - }, - .pfnNextLayer = &terminator_EnumerateInstanceExtensionProperties, - .pNextLink = NULL, - }; - VkEnumerateInstanceExtensionPropertiesChain *chain_head = &chain_tail; - - // Get the implicit layers - struct loader_layer_list layers; - memset(&layers, 0, sizeof(layers)); - loader_implicit_layer_scan(NULL, &layers); - - // We'll need to save the dl handles so we can close them later - loader_platform_dl_handle *libs = malloc(sizeof(loader_platform_dl_handle) * layers.count); - if (libs == NULL) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - size_t lib_count = 0; - - // Prepend layers onto the chain if they implment this entry point - for (uint32_t i = 0; i < layers.count; ++i) { - if (!loader_is_implicit_layer_enabled(NULL, layers.list + i) || - layers.list[i].pre_instance_functions.enumerate_instance_extension_properties[0] == '\0') { - continue; - } - - loader_platform_dl_handle layer_lib = loader_platform_open_library(layers.list[i].lib_name); - libs[lib_count++] = layer_lib; - void *pfn = loader_platform_get_proc_address(layer_lib, - layers.list[i].pre_instance_functions.enumerate_instance_extension_properties); - if (pfn == NULL) { - loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "%s: Unable to resolve symbol \"%s\" in implicit layer library \"%s\"", __FUNCTION__, - layers.list[i].pre_instance_functions.enumerate_instance_extension_properties, layers.list[i].lib_name); - continue; - } - - VkEnumerateInstanceExtensionPropertiesChain *chain_link = malloc(sizeof(VkEnumerateInstanceExtensionPropertiesChain)); - if (chain_link == NULL) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - break; - } - - chain_link->header.type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES; - chain_link->header.version = VK_CURRENT_CHAIN_VERSION; - chain_link->header.size = sizeof(*chain_link); - chain_link->pfnNextLayer = pfn; - chain_link->pNextLink = chain_head; - - chain_head = chain_link; - } - - // Call down the chain - if (res == VK_SUCCESS) { - res = chain_head->pfnNextLayer(chain_head->pNextLink, pLayerName, pPropertyCount, pProperties); - } - - // Free up the layers - loader_delete_layer_properties(NULL, &layers); - - // Tear down the chain - while (chain_head != &chain_tail) { - VkEnumerateInstanceExtensionPropertiesChain *holder = chain_head; - chain_head = (VkEnumerateInstanceExtensionPropertiesChain *)chain_head->pNextLink; - free(holder); - } - - // Close the dl handles - for (size_t i = 0; i < lib_count; ++i) { - loader_platform_close_library(libs[i]); - } - free(libs); - - return res; -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, - VkLayerProperties *pProperties) { - tls_instance = NULL; - LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize); - - // We know we need to call at least the terminator - VkResult res = VK_SUCCESS; - VkEnumerateInstanceLayerPropertiesChain chain_tail = { - .header = - { - .type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES, - .version = VK_CURRENT_CHAIN_VERSION, - .size = sizeof(chain_tail), - }, - .pfnNextLayer = &terminator_EnumerateInstanceLayerProperties, - .pNextLink = NULL, - }; - VkEnumerateInstanceLayerPropertiesChain *chain_head = &chain_tail; - - // Get the implicit layers - struct loader_layer_list layers; - memset(&layers, 0, sizeof(layers)); - loader_implicit_layer_scan(NULL, &layers); - - // We'll need to save the dl handles so we can close them later - loader_platform_dl_handle *libs = malloc(sizeof(loader_platform_dl_handle) * layers.count); - if (libs == NULL) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - size_t lib_count = 0; - - // Prepend layers onto the chain if they implment this entry point - for (uint32_t i = 0; i < layers.count; ++i) { - if (!loader_is_implicit_layer_enabled(NULL, layers.list + i) || - layers.list[i].pre_instance_functions.enumerate_instance_layer_properties[0] == '\0') { - continue; - } - - loader_platform_dl_handle layer_lib = loader_platform_open_library(layers.list[i].lib_name); - libs[lib_count++] = layer_lib; - void *pfn = - loader_platform_get_proc_address(layer_lib, layers.list[i].pre_instance_functions.enumerate_instance_layer_properties); - if (pfn == NULL) { - loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "%s: Unable to resolve symbol \"%s\" in implicit layer library \"%s\"", __FUNCTION__, - layers.list[i].pre_instance_functions.enumerate_instance_layer_properties, layers.list[i].lib_name); - continue; - } - - VkEnumerateInstanceLayerPropertiesChain *chain_link = malloc(sizeof(VkEnumerateInstanceLayerPropertiesChain)); - if (chain_link == NULL) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - break; - } - - chain_link->header.type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES; - chain_link->header.version = VK_CURRENT_CHAIN_VERSION; - chain_link->header.size = sizeof(*chain_link); - chain_link->pfnNextLayer = pfn; - chain_link->pNextLink = chain_head; - - chain_head = chain_link; - } - - // Call down the chain - if (res == VK_SUCCESS) { - res = chain_head->pfnNextLayer(chain_head->pNextLink, pPropertyCount, pProperties); - } - - // Free up the layers - loader_delete_layer_properties(NULL, &layers); - - // Tear down the chain - while (chain_head != &chain_tail) { - VkEnumerateInstanceLayerPropertiesChain *holder = chain_head; - chain_head = (VkEnumerateInstanceLayerPropertiesChain *)chain_head->pNextLink; - free(holder); - } - - // Close the dl handles - for (size_t i = 0; i < lib_count; ++i) { - loader_platform_close_library(libs[i]); - } - free(libs); - - return res; -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(uint32_t* pApiVersion) { - - tls_instance = NULL; - LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize); - - // We know we need to call at least the terminator - VkResult res = VK_SUCCESS; - VkEnumerateInstanceVersionChain chain_tail = { - .header = - { - .type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION, - .version = VK_CURRENT_CHAIN_VERSION, - .size = sizeof(chain_tail), - }, - .pfnNextLayer = &terminator_EnumerateInstanceVersion, - .pNextLink = NULL, - }; - VkEnumerateInstanceVersionChain *chain_head = &chain_tail; - - // Get the implicit layers - struct loader_layer_list layers; - memset(&layers, 0, sizeof(layers)); - loader_implicit_layer_scan(NULL, &layers); - - // We'll need to save the dl handles so we can close them later - loader_platform_dl_handle *libs = malloc(sizeof(loader_platform_dl_handle) * layers.count); - if (libs == NULL) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - size_t lib_count = 0; - - // Prepend layers onto the chain if they implment this entry point - for (uint32_t i = 0; i < layers.count; ++i) { - if (!loader_is_implicit_layer_enabled(NULL, layers.list + i) || - layers.list[i].pre_instance_functions.enumerate_instance_version[0] == '\0') { - continue; - } - - loader_platform_dl_handle layer_lib = loader_platform_open_library(layers.list[i].lib_name); - libs[lib_count++] = layer_lib; - void *pfn = loader_platform_get_proc_address(layer_lib, - layers.list[i].pre_instance_functions.enumerate_instance_version); - if (pfn == NULL) { - loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "%s: Unable to resolve symbol \"%s\" in implicit layer library \"%s\"", __FUNCTION__, - layers.list[i].pre_instance_functions.enumerate_instance_version, layers.list[i].lib_name); - continue; - } - - VkEnumerateInstanceVersionChain *chain_link = malloc(sizeof(VkEnumerateInstanceVersionChain)); - if (chain_link == NULL) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - break; - } - - chain_link->header.type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION; - chain_link->header.version = VK_CURRENT_CHAIN_VERSION; - chain_link->header.size = sizeof(*chain_link); - chain_link->pfnNextLayer = pfn; - chain_link->pNextLink = chain_head; - - chain_head = chain_link; - } - - // Call down the chain - if (res == VK_SUCCESS) { - res = chain_head->pfnNextLayer(chain_head->pNextLink, pApiVersion); - } - - // Free up the layers - loader_delete_layer_properties(NULL, &layers); - - // Tear down the chain - while (chain_head != &chain_tail) { - VkEnumerateInstanceVersionChain *holder = chain_head; - chain_head = (VkEnumerateInstanceVersionChain *)chain_head->pNextLink; - free(holder); - } - - // Close the dl handles - for (size_t i = 0; i < lib_count; ++i) { - loader_platform_close_library(libs[i]); - } - free(libs); - - return res; -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) { - struct loader_instance *ptr_instance = NULL; - VkInstance created_instance = VK_NULL_HANDLE; - bool loaderLocked = false; - VkResult res = VK_ERROR_INITIALIZATION_FAILED; - - LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize); - -#if (DEBUG_DISABLE_APP_ALLOCATORS == 1) - { -#else - if (pAllocator) { - ptr_instance = (struct loader_instance *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(struct loader_instance), - sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - } else { -#endif - ptr_instance = (struct loader_instance *)malloc(sizeof(struct loader_instance)); - } - - VkInstanceCreateInfo ici = *pCreateInfo; - - if (ptr_instance == NULL) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - tls_instance = ptr_instance; - loader_platform_thread_lock_mutex(&loader_lock); - loaderLocked = true; - memset(ptr_instance, 0, sizeof(struct loader_instance)); - if (pAllocator) { - ptr_instance->alloc_callbacks = *pAllocator; - } - - // Save the application version - if (NULL == pCreateInfo || NULL == pCreateInfo->pApplicationInfo || 0 == pCreateInfo->pApplicationInfo->apiVersion) -{ - ptr_instance->app_api_major_version = 1; - ptr_instance->app_api_minor_version = 0; - } else { - ptr_instance->app_api_major_version = VK_VERSION_MAJOR(pCreateInfo->pApplicationInfo->apiVersion); - ptr_instance->app_api_minor_version = VK_VERSION_MINOR(pCreateInfo->pApplicationInfo->apiVersion); - } - - // Look for one or more VK_EXT_debug_report or VK_EXT_debug_utils create info structures - // and setup a callback(s) for each one found. - ptr_instance->num_tmp_report_callbacks = 0; - ptr_instance->tmp_report_create_infos = NULL; - ptr_instance->tmp_report_callbacks = NULL; - ptr_instance->num_tmp_messengers = 0; - ptr_instance->tmp_messenger_create_infos = NULL; - ptr_instance->tmp_messengers = NULL; - - // Handle cases of VK_EXT_debug_utils - if (util_CopyDebugUtilsMessengerCreateInfos(pCreateInfo->pNext, pAllocator, &ptr_instance->num_tmp_messengers, - &ptr_instance->tmp_messenger_create_infos, &ptr_instance->tmp_messengers)) { - // One or more were found, but allocation failed. Therefore, clean up and fail this function: - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } else if (ptr_instance->num_tmp_messengers > 0) { - // Setup the temporary messenger(s) here to catch early issues: - if (util_CreateDebugUtilsMessengers(ptr_instance, pAllocator, ptr_instance->num_tmp_messengers, - ptr_instance->tmp_messenger_create_infos, ptr_instance->tmp_messengers)) { - // Failure of setting up one or more of the messenger. Therefore, clean up and fail this function: - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - } - - // Handle cases of VK_EXT_debug_report - if (util_CopyDebugReportCreateInfos(pCreateInfo->pNext, pAllocator, &ptr_instance->num_tmp_report_callbacks, - &ptr_instance->tmp_report_create_infos, &ptr_instance->tmp_report_callbacks)) { - // One or more were found, but allocation failed. Therefore, clean up and fail this function: - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } else if (ptr_instance->num_tmp_report_callbacks > 0) { - // Setup the temporary callback(s) here to catch early issues: - if (util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_report_callbacks, - ptr_instance->tmp_report_create_infos, ptr_instance->tmp_report_callbacks)) { - // Failure of setting up one or more of the callback. Therefore, clean up and fail this function: - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - } - - // Due to implicit layers need to get layer list even if - // enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always - // get layer list via loader_layer_scan(). - memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list)); - loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list); - - // Validate the app requested layers to be enabled - if (pCreateInfo->enabledLayerCount > 0) { - res = loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, - &ptr_instance->instance_layer_list); - if (res != VK_SUCCESS) { - goto out; - } - } - - // Scan/discover all ICD libraries - memset(&ptr_instance->icd_tramp_list, 0, sizeof(ptr_instance->icd_tramp_list)); - res = loader_icd_scan(ptr_instance, &ptr_instance->icd_tramp_list); - if (res != VK_SUCCESS) { - goto out; - } - - // Get extensions from all ICD's, merge so no duplicates, then validate - res = loader_get_icd_loader_instance_extensions(ptr_instance, &ptr_instance->icd_tramp_list, &ptr_instance->ext_list); - if (res != VK_SUCCESS) { - goto out; - } - res = loader_validate_instance_extensions(ptr_instance, &ptr_instance->ext_list, &ptr_instance->instance_layer_list, &ici); - if (res != VK_SUCCESS) { - goto out; - } - - ptr_instance->disp = loader_instance_heap_alloc(ptr_instance, sizeof(struct loader_instance_dispatch_table), - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (ptr_instance->disp == NULL) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkCreateInstance: Failed to allocate Loader's full Instance dispatch table."); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memcpy(&ptr_instance->disp->layer_inst_disp, &instance_disp, sizeof(instance_disp)); - - ptr_instance->next = loader.instances; - loader.instances = ptr_instance; - - // Activate any layers on instance chain - res = loader_enable_instance_layers(ptr_instance, &ici, &ptr_instance->instance_layer_list); - if (res != VK_SUCCESS) { - goto out; - } - - created_instance = (VkInstance)ptr_instance; - res = loader_create_instance_chain(&ici, pAllocator, ptr_instance, &created_instance); - - if (res == VK_SUCCESS) { - memset(ptr_instance->enabled_known_extensions.padding, 0, sizeof(uint64_t) * 4); - - wsi_create_instance(ptr_instance, &ici); - debug_utils_CreateInstance(ptr_instance, &ici); - extensions_create_instance(ptr_instance, &ici); - - *pInstance = created_instance; - - // Finally have the layers in place and everyone has seen - // the CreateInstance command go by. This allows the layer's - // GetInstanceProcAddr functions to return valid extension functions - // if enabled. - loader_activate_instance_layer_extensions(ptr_instance, *pInstance); - } - -out: - - if (NULL != ptr_instance) { - if (res != VK_SUCCESS) { - if (NULL != ptr_instance->next) { - loader.instances = ptr_instance->next; - } - if (NULL != ptr_instance->disp) { - loader_instance_heap_free(ptr_instance, ptr_instance->disp); - } - if (ptr_instance->num_tmp_report_callbacks > 0) { - // Remove temporary VK_EXT_debug_report items - util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_report_callbacks, - ptr_instance->tmp_report_callbacks); - util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_report_create_infos, - ptr_instance->tmp_report_callbacks); - } - if (ptr_instance->num_tmp_messengers > 0) { - // Remove temporary VK_EXT_debug_utils items - util_DestroyDebugUtilsMessengers(ptr_instance, pAllocator, ptr_instance->num_tmp_messengers, - ptr_instance->tmp_messengers); - util_FreeDebugUtilsMessengerCreateInfos(pAllocator, ptr_instance->tmp_messenger_create_infos, - ptr_instance->tmp_messengers); - } - - if (NULL != ptr_instance->expanded_activated_layer_list.list) { - loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list); - } - if (NULL != ptr_instance->app_activated_layer_list.list) { - loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list); - } - - loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list); - loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list); - loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list); - - loader_instance_heap_free(ptr_instance, ptr_instance); - } else { - // Remove temporary VK_EXT_debug_report or VK_EXT_debug_utils items - util_DestroyDebugUtilsMessengers(ptr_instance, pAllocator, ptr_instance->num_tmp_messengers, - ptr_instance->tmp_messengers); - util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_report_callbacks, - ptr_instance->tmp_report_callbacks); - } - - if (loaderLocked) { - loader_platform_thread_unlock_mutex(&loader_lock); - } - } - - return res; -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - const VkLayerInstanceDispatchTable *disp; - struct loader_instance *ptr_instance = NULL; - bool callback_setup = false; - bool messenger_setup = false; - - if (instance == VK_NULL_HANDLE) { - return; - } - - disp = loader_get_instance_layer_dispatch(instance); - - loader_platform_thread_lock_mutex(&loader_lock); - - ptr_instance = loader_get_instance(instance); - - if (pAllocator) { - ptr_instance->alloc_callbacks = *pAllocator; - } - - if (ptr_instance->num_tmp_messengers > 0) { - // Setup the temporary VK_EXT_debug_utils messenger(s) here to catch cleanup issues: - if (!util_CreateDebugUtilsMessengers(ptr_instance, pAllocator, ptr_instance->num_tmp_messengers, - ptr_instance->tmp_messenger_create_infos, ptr_instance->tmp_messengers)) { - messenger_setup = true; - } - } - - if (ptr_instance->num_tmp_report_callbacks > 0) { - // Setup the temporary VK_EXT_debug_report callback(s) here to catch cleanup issues: - if (!util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_report_callbacks, - ptr_instance->tmp_report_create_infos, ptr_instance->tmp_report_callbacks)) { - callback_setup = true; - } - } - - disp->DestroyInstance(instance, pAllocator); - - if (NULL != ptr_instance->expanded_activated_layer_list.list) { - loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list); - } - if (NULL != ptr_instance->app_activated_layer_list.list) { - loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list); - } - - if (ptr_instance->phys_devs_tramp) { - for (uint32_t i = 0; i < ptr_instance->phys_dev_count_tramp; i++) { - loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp[i]); - } - loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp); - } - - if (ptr_instance->phys_dev_groups_tramp) { - for (uint32_t i = 0; i < ptr_instance->phys_dev_group_count_tramp; i++) { - loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_tramp[i]); - } - loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_tramp); - } - - if (messenger_setup) { - util_DestroyDebugUtilsMessengers(ptr_instance, pAllocator, ptr_instance->num_tmp_messengers, ptr_instance->tmp_messengers); - util_FreeDebugUtilsMessengerCreateInfos(pAllocator, ptr_instance->tmp_messenger_create_infos, ptr_instance->tmp_messengers); - } - - if (callback_setup) { - util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_report_callbacks, - ptr_instance->tmp_report_callbacks); - util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_report_create_infos, ptr_instance->tmp_report_callbacks); - } - loader_instance_heap_free(ptr_instance, ptr_instance->disp); - loader_instance_heap_free(ptr_instance, ptr_instance); - loader_platform_thread_unlock_mutex(&loader_lock); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, - VkPhysicalDevice *pPhysicalDevices) { - VkResult res = VK_SUCCESS; - uint32_t count; - uint32_t i; - struct loader_instance *inst; - - loader_platform_thread_lock_mutex(&loader_lock); - - inst = loader_get_instance(instance); - if (NULL == inst) { - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - if (NULL == pPhysicalDeviceCount) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkEnumeratePhysicalDevices: Received NULL pointer for physical device count return value."); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - // Setup the trampoline loader physical devices. This will actually - // call down and setup the terminator loader physical devices during the - // process. - VkResult setup_res = setupLoaderTrampPhysDevs(instance); - if (setup_res != VK_SUCCESS && setup_res != VK_INCOMPLETE) { - res = setup_res; - goto out; - } - - count = inst->phys_dev_count_tramp; - - // Wrap the PhysDev object for loader usage, return wrapped objects - if (NULL != pPhysicalDevices) { - if (inst->phys_dev_count_tramp > *pPhysicalDeviceCount) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkEnumeratePhysicalDevices: Trimming device count down" - " by application request from %d to %d physical devices", - inst->phys_dev_count_tramp, *pPhysicalDeviceCount); - count = *pPhysicalDeviceCount; - res = VK_INCOMPLETE; - } - for (i = 0; i < count; i++) { - pPhysicalDevices[i] = (VkPhysicalDevice)inst->phys_devs_tramp[i]; - } - } - - *pPhysicalDeviceCount = count; - -out: - - loader_platform_thread_unlock_mutex(&loader_lock); - return res; -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures *pFeatures) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceFeatures(unwrapped_phys_dev, pFeatures); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, - VkFormatProperties *pFormatInfo) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_pd = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceFormatProperties(unwrapped_pd, format, pFormatInfo); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, - VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetPhysicalDeviceImageFormatProperties(unwrapped_phys_dev, format, type, tiling, usage, flags, - pImageFormatProperties); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties *pProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceProperties(unwrapped_phys_dev, pProperties); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties *pQueueProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceQueueFamilyProperties(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueProperties); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties *pMemoryProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceMemoryProperties(unwrapped_phys_dev, pMemoryProperties); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - VkResult res; - struct loader_physical_device_tramp *phys_dev = NULL; - struct loader_device *dev = NULL; - struct loader_instance *inst = NULL; - - assert(pCreateInfo->queueCreateInfoCount >= 1); - - loader_platform_thread_lock_mutex(&loader_lock); - - phys_dev = (struct loader_physical_device_tramp *)physicalDevice; - inst = (struct loader_instance *)phys_dev->this_instance; - - // Get the physical device (ICD) extensions - struct loader_extension_list icd_exts; - icd_exts.list = NULL; - res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties)); - if (VK_SUCCESS != res) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice: Failed to create ICD extension list"); - goto out; - } - - res = loader_add_device_extensions(inst, inst->disp->layer_inst_disp.EnumerateDeviceExtensionProperties, phys_dev->phys_dev, - "Unknown", &icd_exts); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice: Failed to add extensions to list"); - goto out; - } - - // Make sure requested extensions to be enabled are supported - res = loader_validate_device_extensions(phys_dev, &inst->expanded_activated_layer_list, &icd_exts, pCreateInfo); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice: Failed to validate extensions in list"); - goto out; - } - - dev = loader_create_logical_device(inst, pAllocator); - if (dev == NULL) { - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - // Copy the application enabled instance layer list into the device - if (NULL != inst->app_activated_layer_list.list) { - dev->app_activated_layer_list.capacity = inst->app_activated_layer_list.capacity; - dev->app_activated_layer_list.count = inst->app_activated_layer_list.count; - dev->app_activated_layer_list.list = - loader_device_heap_alloc(dev, inst->app_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); - if (dev->app_activated_layer_list.list == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkCreateDevice: Failed to allocate application activated layer list of size %d.", - inst->app_activated_layer_list.capacity); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memcpy(dev->app_activated_layer_list.list, inst->app_activated_layer_list.list, - sizeof(*dev->app_activated_layer_list.list) * dev->app_activated_layer_list.count); - } else { - dev->app_activated_layer_list.capacity = 0; - dev->app_activated_layer_list.count = 0; - dev->app_activated_layer_list.list = NULL; - } - - // Copy the expanded enabled instance layer list into the device - if (NULL != inst->expanded_activated_layer_list.list) { - dev->expanded_activated_layer_list.capacity = inst->expanded_activated_layer_list.capacity; - dev->expanded_activated_layer_list.count = inst->expanded_activated_layer_list.count; - dev->expanded_activated_layer_list.list = - loader_device_heap_alloc(dev, inst->expanded_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); - if (dev->expanded_activated_layer_list.list == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkCreateDevice: Failed to allocate expanded activated layer list of size %d.", - inst->expanded_activated_layer_list.capacity); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memcpy(dev->expanded_activated_layer_list.list, inst->expanded_activated_layer_list.list, - sizeof(*dev->expanded_activated_layer_list.list) * dev->expanded_activated_layer_list.count); - } else { - dev->expanded_activated_layer_list.capacity = 0; - dev->expanded_activated_layer_list.count = 0; - dev->expanded_activated_layer_list.list = NULL; - } - - res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, dev); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice: Failed to create device chain."); - goto out; - } - - *pDevice = dev->chain_device; - - // Initialize any device extension dispatch entry's from the instance list - loader_init_dispatch_dev_ext(inst, dev); - - // Initialize WSI device extensions as part of core dispatch since loader - // has dedicated trampoline code for these*/ - loader_init_device_extension_dispatch_table(&dev->loader_dispatch, dev->loader_dispatch.core_dispatch.GetDeviceProcAddr, - *pDevice); - -out: - - // Failure cleanup - if (VK_SUCCESS != res) { - if (NULL != dev) { - loader_destroy_logical_device(inst, dev, pAllocator); - } - } - - if (NULL != icd_exts.list) { - loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts); - } - loader_platform_thread_unlock_mutex(&loader_lock); - return res; -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - struct loader_device *dev; - - if (device == VK_NULL_HANDLE) { - return; - } - - loader_platform_thread_lock_mutex(&loader_lock); - - struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL); - const struct loader_instance *inst = icd_term->this_instance; - disp = loader_get_dispatch(device); - - disp->DestroyDevice(device, pAllocator); - dev->chain_device = NULL; - dev->icd_device = NULL; - loader_remove_logical_device(inst, icd_term, dev, pAllocator); - - loader_platform_thread_unlock_mutex(&loader_lock); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pPropertyCount, - VkExtensionProperties *pProperties) { - VkResult res = VK_SUCCESS; - struct loader_physical_device_tramp *phys_dev; - phys_dev = (struct loader_physical_device_tramp *)physicalDevice; - - loader_platform_thread_lock_mutex(&loader_lock); - - // If pLayerName == NULL, then querying ICD extensions, pass this call - // down the instance chain which will terminate in the ICD. This allows - // layers to filter the extensions coming back up the chain. - // If pLayerName != NULL then get layer extensions from manifest file. - if (pLayerName == NULL || strlen(pLayerName) == 0) { - const VkLayerInstanceDispatchTable *disp; - - disp = loader_get_instance_layer_dispatch(physicalDevice); - res = disp->EnumerateDeviceExtensionProperties(phys_dev->phys_dev, NULL, pPropertyCount, pProperties); - } else { - uint32_t count; - uint32_t copy_size; - const struct loader_instance *inst = phys_dev->this_instance; - struct loader_device_extension_list *dev_ext_list = NULL; - struct loader_device_extension_list local_ext_list; - memset(&local_ext_list, 0, sizeof(local_ext_list)); - if (vk_string_validate(MaxLoaderStringLength, pLayerName) == VK_STRING_ERROR_NONE) { - for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) { - struct loader_layer_properties *props = &inst->instance_layer_list.list[i]; - if (strcmp(props->info.layerName, pLayerName) == 0) { - dev_ext_list = &props->device_extension_list; - } - } - - count = (dev_ext_list == NULL) ? 0 : dev_ext_list->count; - if (pProperties == NULL) { - *pPropertyCount = count; - loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list); - loader_platform_thread_unlock_mutex(&loader_lock); - return VK_SUCCESS; - } - - copy_size = *pPropertyCount < count ? *pPropertyCount : count; - for (uint32_t i = 0; i < copy_size; i++) { - memcpy(&pProperties[i], &dev_ext_list->list[i].props, sizeof(VkExtensionProperties)); - } - *pPropertyCount = copy_size; - - loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list); - if (copy_size < count) { - loader_platform_thread_unlock_mutex(&loader_lock); - return VK_INCOMPLETE; - } - } else { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkEnumerateDeviceExtensionProperties: pLayerName " - "is too long or is badly formed"); - loader_platform_thread_unlock_mutex(&loader_lock); - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - } - - loader_platform_thread_unlock_mutex(&loader_lock); - return res; -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, - uint32_t *pPropertyCount, - VkLayerProperties *pProperties) { - uint32_t copy_size; - struct loader_physical_device_tramp *phys_dev; - struct loader_layer_list *enabled_layers, layers_list; - memset(&layers_list, 0, sizeof(layers_list)); - loader_platform_thread_lock_mutex(&loader_lock); - - // Don't dispatch this call down the instance chain, want all device layers - // enumerated and instance chain may not contain all device layers - // TODO re-evaluate the above statement we maybe able to start calling - // down the chain - - phys_dev = (struct loader_physical_device_tramp *)physicalDevice; - const struct loader_instance *inst = phys_dev->this_instance; - - uint32_t count = inst->app_activated_layer_list.count; - if (count == 0 || pProperties == NULL) { - *pPropertyCount = count; - loader_platform_thread_unlock_mutex(&loader_lock); - return VK_SUCCESS; - } - enabled_layers = (struct loader_layer_list *)&inst->app_activated_layer_list; - - copy_size = (*pPropertyCount < count) ? *pPropertyCount : count; - for (uint32_t i = 0; i < copy_size; i++) { - memcpy(&pProperties[i], &(enabled_layers->list[i].info), sizeof(VkLayerProperties)); - } - *pPropertyCount = copy_size; - - if (copy_size < count) { - loader_platform_thread_unlock_mutex(&loader_lock); - return VK_INCOMPLETE; - } - - loader_platform_thread_unlock_mutex(&loader_lock); - return VK_SUCCESS; -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, - VkQueue *pQueue) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); - loader_set_dispatch(*pQueue, disp); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, - VkFence fence) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(queue); - - return disp->QueueSubmit(queue, submitCount, pSubmits, fence); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(queue); - - return disp->QueueWaitIdle(queue); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->DeviceWaitIdle(device); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, - const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->FreeMemory(device, mem, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, - VkDeviceSize size, VkFlags flags, void **ppData) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->MapMemory(device, mem, offset, size, flags, ppData); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->UnmapMemory(device, mem); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, - const VkMappedMemoryRange *pMemoryRanges) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, - const VkMappedMemoryRange *pMemoryRanges) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, - VkDeviceSize *pCommittedMemoryInBytes) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, - VkDeviceSize offset) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->BindBufferMemory(device, buffer, mem, offset); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, - VkDeviceSize offset) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->BindImageMemory(device, image, mem, offset); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, - VkMemoryRequirements *pMemoryRequirements) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, - VkMemoryRequirements *pMemoryRequirements) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->GetImageMemoryRequirements(device, image, pMemoryRequirements); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL -vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements *pSparseMemoryRequirements) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, - VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - - disp->GetPhysicalDeviceSparseImageFormatProperties(unwrapped_phys_dev, format, type, samples, usage, tiling, pPropertyCount, - pProperties); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, - const VkBindSparseInfo *pBindInfo, VkFence fence) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(queue); - - return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkFence *pFence) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateFence(device, pCreateInfo, pAllocator, pFence); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyFence(device, fence, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->ResetFences(device, fenceCount, pFences); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->GetFenceStatus(device, fence); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, - VkBool32 waitAll, uint64_t timeout) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroySemaphore(device, semaphore, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyEvent(device, event, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->GetEventStatus(device, event); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->SetEvent(device, event); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->ResetEvent(device, event); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyQueryPool(device, queryPool, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, - uint32_t queryCount, size_t dataSize, void *pData, - VkDeviceSize stride, VkQueryResultFlags flags) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyBuffer(device, buffer, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkBufferView *pView) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyBufferView(device, bufferView, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkImage *pImage) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateImage(device, pCreateInfo, pAllocator, pImage); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyImage(device, image, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, - const VkImageSubresource *pSubresource, - VkSubresourceLayout *pLayout) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkImageView *pView) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateImageView(device, pCreateInfo, pAllocator, pView); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyImageView(device, imageView, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkShaderModule *pShader) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyShaderModule(device, shaderModule, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkPipelineCache *pPipelineCache) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyPipelineCache(device, pipelineCache, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, - size_t *pDataSize, void *pData) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, - uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo *pCreateInfos, - const VkAllocationCallbacks *pAllocator, - VkPipeline *pPipelines) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo *pCreateInfos, - const VkAllocationCallbacks *pAllocator, - VkPipeline *pPipelines) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyPipeline(device, pipeline, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkPipelineLayout *pPipelineLayout) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroySampler(device, sampler, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, - const VkDescriptorSetLayoutCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorSetLayout *pSetLayout) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorPool *pDescriptorPool) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyDescriptorPool(device, descriptorPool, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->ResetDescriptorPool(device, descriptorPool, flags); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, - const VkDescriptorSetAllocateInfo *pAllocateInfo, - VkDescriptorSet *pDescriptorSets) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet *pDescriptorSets) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet *pDescriptorCopies) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkFramebuffer *pFramebuffer) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyFramebuffer(device, framebuffer, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkRenderPass *pRenderPass) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyRenderPass(device, renderPass, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, - VkExtent2D *pGranularity) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->GetRenderAreaGranularity(device, renderPass, pGranularity); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkCommandPool *pCommandPool) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->DestroyCommandPool(device, commandPool, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, - VkCommandPoolResetFlags flags) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - return disp->ResetCommandPool(device, commandPool, flags); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, - const VkCommandBufferAllocateInfo *pAllocateInfo, - VkCommandBuffer *pCommandBuffers) { - const VkLayerDispatchTable *disp; - VkResult res; - - disp = loader_get_dispatch(device); - - res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); - if (res == VK_SUCCESS) { - for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) { - if (pCommandBuffers[i]) { - loader_init_dispatch(pCommandBuffers[i], disp); - } - } - } - - return res; -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, - uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(device); - - disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo *pBeginInfo) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - return disp->BeginCommandBuffer(commandBuffer, pBeginInfo); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - return disp->EndCommandBuffer(commandBuffer); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - return disp->ResetCommandBuffer(commandBuffer, flags); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, - uint32_t viewportCount, const VkViewport *pViewports) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, - uint32_t scissorCount, const VkRect2D *pScissors) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetLineWidth(commandBuffer, lineWidth); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, - float depthBiasClamp, float depthBiasSlopeFactor) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetBlendConstants(commandBuffer, blendConstants); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, - float maxDepthBounds) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, - uint32_t compareMask) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, - uint32_t writeMask) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, - uint32_t reference) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetStencilReference(commandBuffer, faceMask, reference); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, - uint32_t firstSet, uint32_t descriptorSetCount, - const VkDescriptorSet *pDescriptorSets, - uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, - dynamicOffsetCount, pDynamicOffsets); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, - VkIndexType indexType) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, - uint32_t bindingCount, const VkBuffer *pBuffers, - const VkDeviceSize *pOffsets) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, - uint32_t firstVertex, uint32_t firstInstance) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, - uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, - uint32_t firstInstance) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, - uint32_t drawCount, uint32_t stride) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, - VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdDispatch(commandBuffer, x, y, z); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, - VkDeviceSize offset) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdDispatchIndirect(commandBuffer, buffer, offset); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, - uint32_t regionCount, const VkBufferCopy *pRegions) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageCopy *pRegions) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageBlit *pRegions, VkFilter filter) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkBufferImageCopy *pRegions) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkBuffer dstBuffer, - uint32_t regionCount, const VkBufferImageCopy *pRegions) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, - VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, - VkDeviceSize size, uint32_t data) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, const VkClearColorValue *pColor, - uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue *pDepthStencil, - uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, - const VkClearAttachment *pAttachments, uint32_t rectCount, - const VkClearRect *pRects) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageResolve *pRegions) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, - VkPipelineStageFlags stageMask) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdSetEvent(commandBuffer, event, stageMask); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, - VkPipelineStageFlags stageMask) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdResetEvent(commandBuffer, event, stageMask); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, - VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier *pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier *pImageMemoryBarriers) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, - bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(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) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, - bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, - VkFlags flags) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdEndQuery(commandBuffer, queryPool, slot); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, - uint32_t firstQuery, uint32_t queryCount) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, uint32_t slot) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, - uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, - VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, - VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, - const void *pValues) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo *pRenderPassBegin, - VkSubpassContents contents) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdNextSubpass(commandBuffer, contents); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdEndRenderPass(commandBuffer); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, - const VkCommandBuffer *pCommandBuffers) { - const VkLayerDispatchTable *disp; - - disp = loader_get_dispatch(commandBuffer); - - disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers); -} - -// ---- Vulkan core 1.1 trampolines - -VkResult setupLoaderTrampPhysDevGroups(VkInstance instance) { - VkResult res = VK_SUCCESS; - struct loader_instance *inst; - uint32_t total_count = 0; - VkPhysicalDeviceGroupPropertiesKHR **new_phys_dev_groups = NULL; - VkPhysicalDeviceGroupPropertiesKHR *local_phys_dev_groups = NULL; - PFN_vkEnumeratePhysicalDeviceGroups fpEnumeratePhysicalDeviceGroups = NULL; - - inst = loader_get_instance(instance); - if (NULL == inst) { - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - // Get the function pointer to use to call into the ICD. This could be the core or KHR version - if (inst->enabled_known_extensions.khr_device_group_creation) { - fpEnumeratePhysicalDeviceGroups = inst->disp->layer_inst_disp.EnumeratePhysicalDeviceGroupsKHR; - } else { - fpEnumeratePhysicalDeviceGroups = inst->disp->layer_inst_disp.EnumeratePhysicalDeviceGroups; - } - - // Setup the trampoline loader physical devices. This will actually - // call down and setup the terminator loader physical devices during the - // process. - VkResult setup_res = setupLoaderTrampPhysDevs(instance); - if (setup_res != VK_SUCCESS && setup_res != VK_INCOMPLETE) { - res = setup_res; - goto out; - } - - // Query how many physical device groups there - res = fpEnumeratePhysicalDeviceGroups(instance, &total_count, NULL); - if (res != VK_SUCCESS) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevGroups: Failed during dispatch call of " - "\'EnumeratePhysicalDeviceGroupsKHR\' to lower layers or " - "loader to get count."); - goto out; - } - - // Create an array for the new physical device groups, which will be stored - // in the instance for the trampoline code. - new_phys_dev_groups = (VkPhysicalDeviceGroupPropertiesKHR **)loader_instance_heap_alloc( - inst, total_count * sizeof(VkPhysicalDeviceGroupPropertiesKHR *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_dev_groups) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevGroups: Failed to allocate new physical device" - " group array of size %d", - total_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memset(new_phys_dev_groups, 0, total_count * sizeof(VkPhysicalDeviceGroupPropertiesKHR *)); - - // Create a temporary array (on the stack) to keep track of the - // returned VkPhysicalDevice values. - local_phys_dev_groups = loader_stack_alloc(sizeof(VkPhysicalDeviceGroupPropertiesKHR) * total_count); - if (NULL == local_phys_dev_groups) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevGroups: Failed to allocate local " - "physical device group array of size %d", - total_count); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - // Initialize the memory to something valid - memset(local_phys_dev_groups, 0, sizeof(VkPhysicalDeviceGroupPropertiesKHR) * total_count); - for (uint32_t group = 0; group < total_count; group++) { - local_phys_dev_groups[group].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR; - local_phys_dev_groups[group].pNext = NULL; - local_phys_dev_groups[group].subsetAllocation = false; - } - - // Call down and get the content - fpEnumeratePhysicalDeviceGroups(instance, &total_count, local_phys_dev_groups); - if (VK_SUCCESS != res) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevGroups: Failed during dispatch call of " - "\'EnumeratePhysicalDeviceGroupsKHR\' to lower layers or " - "loader to get content."); - goto out; - } - - // Replace all the physical device IDs with the proper loader values - for (uint32_t group = 0; group < total_count; group++) { - for (uint32_t group_gpu = 0; group_gpu < local_phys_dev_groups[group].physicalDeviceCount; group_gpu++) { - bool found = false; - for (uint32_t tramp_gpu = 0; tramp_gpu < inst->phys_dev_count_tramp; tramp_gpu++) { - if (local_phys_dev_groups[group].physicalDevices[group_gpu] == inst->phys_devs_tramp[tramp_gpu]->phys_dev) { - local_phys_dev_groups[group].physicalDevices[group_gpu] = (VkPhysicalDevice)inst->phys_devs_tramp[tramp_gpu]; - found = true; - break; - } - } - if (!found) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevGroups: Failed to find GPU %d in group %d" - " returned by \'EnumeratePhysicalDeviceGroupsKHR\' in list returned" - " by \'EnumeratePhysicalDevices\'", group_gpu, group); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - } - } - - // Copy or create everything to fill the new array of physical device groups - for (uint32_t new_idx = 0; new_idx < total_count; new_idx++) { - // Check if this physical device group with the same contents is already in the old buffer - for (uint32_t old_idx = 0; old_idx < inst->phys_dev_group_count_tramp; old_idx++) { - if (local_phys_dev_groups[new_idx].physicalDeviceCount == inst->phys_dev_groups_tramp[old_idx]->physicalDeviceCount) { - bool found_all_gpus = true; - for (uint32_t old_gpu = 0; old_gpu < inst->phys_dev_groups_tramp[old_idx]->physicalDeviceCount; old_gpu++) { - bool found_gpu = false; - for (uint32_t new_gpu = 0; new_gpu < local_phys_dev_groups[new_idx].physicalDeviceCount; new_gpu++) { - if (local_phys_dev_groups[new_idx].physicalDevices[new_gpu] == inst->phys_dev_groups_tramp[old_idx]->physicalDevices[old_gpu]) { - found_gpu = true; - break; - } - } - - if (!found_gpu) { - found_all_gpus = false; - break; - } - } - if (!found_all_gpus) { - continue; - } else { - new_phys_dev_groups[new_idx] = inst->phys_dev_groups_tramp[old_idx]; - break; - } - } - } - - // If this physical device group isn't in the old buffer, create it - if (NULL == new_phys_dev_groups[new_idx]) { - new_phys_dev_groups[new_idx] = (VkPhysicalDeviceGroupPropertiesKHR *)loader_instance_heap_alloc( - inst, sizeof(VkPhysicalDeviceGroupPropertiesKHR), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == new_phys_dev_groups[new_idx]) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "setupLoaderTrampPhysDevGroups: Failed to allocate " - "physical device group trampoline object %d", - new_idx); - total_count = new_idx; - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - memcpy(new_phys_dev_groups[new_idx], &local_phys_dev_groups[new_idx], - sizeof(VkPhysicalDeviceGroupPropertiesKHR)); - } - } - -out: - - if (VK_SUCCESS != res) { - if (NULL != new_phys_dev_groups) { - for (uint32_t i = 0; i < total_count; i++) { - loader_instance_heap_free(inst, new_phys_dev_groups[i]); - } - loader_instance_heap_free(inst, new_phys_dev_groups); - } - total_count = 0; - } else { - // Free everything that didn't carry over to the new array of - // physical device groups - if (NULL != inst->phys_dev_groups_tramp) { - for (uint32_t i = 0; i < inst->phys_dev_group_count_tramp; i++) { - bool found = false; - for (uint32_t j = 0; j < total_count; j++) { - if (inst->phys_dev_groups_tramp[i] == new_phys_dev_groups[j]) { - found = true; - break; - } - } - if (!found) { - loader_instance_heap_free(inst, inst->phys_dev_groups_tramp[i]); - } - } - loader_instance_heap_free(inst, inst->phys_dev_groups_tramp); - } - - // Swap in the new physical device group list - inst->phys_dev_group_count_tramp = total_count; - inst->phys_dev_groups_tramp = new_phys_dev_groups; - } - - return res; -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( - VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) { - VkResult res = VK_SUCCESS; - uint32_t count; - uint32_t i; - struct loader_instance *inst = NULL; - - loader_platform_thread_lock_mutex(&loader_lock); - - inst = loader_get_instance(instance); - if (NULL == inst) { - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - if (NULL == pPhysicalDeviceGroupCount) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkEnumeratePhysicalDeviceGroupsKHR: Received NULL pointer for physical " - "device group count return value."); - res = VK_ERROR_INITIALIZATION_FAILED; - goto out; - } - - VkResult setup_res = setupLoaderTrampPhysDevGroups(instance); - if (VK_SUCCESS != setup_res) { - res = setup_res; - goto out; - } - - count = inst->phys_dev_group_count_tramp; - - // Wrap the PhysDev object for loader usage, return wrapped objects - if (NULL != pPhysicalDeviceGroupProperties) { - if (inst->phys_dev_group_count_tramp > *pPhysicalDeviceGroupCount) { - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "vkEnumeratePhysicalDeviceGroupsKHR: Trimming device group count down" - " by application request from %d to %d physical device groups", - inst->phys_dev_group_count_tramp, *pPhysicalDeviceGroupCount); - count = *pPhysicalDeviceGroupCount; - res = VK_INCOMPLETE; - } - for (i = 0; i < count; i++) { - memcpy(&pPhysicalDeviceGroupProperties[i], inst->phys_dev_groups_tramp[i], - sizeof(VkPhysicalDeviceGroupPropertiesKHR)); - } - } - - *pPhysicalDeviceGroupCount = count; - -out: - - loader_platform_thread_unlock_mutex(&loader_lock); - return res; -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - disp->GetPhysicalDeviceFeatures2KHR(unwrapped_phys_dev, pFeatures); - } else { - disp->GetPhysicalDeviceFeatures2(unwrapped_phys_dev, pFeatures); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2 *pProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - disp->GetPhysicalDeviceProperties2KHR(unwrapped_phys_dev, pProperties); - } else { - disp->GetPhysicalDeviceProperties2(unwrapped_phys_dev, pProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, - VkFormatProperties2 *pFormatProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - disp->GetPhysicalDeviceFormatProperties2KHR(unwrapped_phys_dev, format, pFormatProperties); - } else { - disp->GetPhysicalDeviceFormatProperties2(unwrapped_phys_dev, format, pFormatProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, - VkImageFormatProperties2 *pImageFormatProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - return disp->GetPhysicalDeviceImageFormatProperties2KHR(unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties); - } else { - return disp->GetPhysicalDeviceImageFormatProperties2(unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, - uint32_t *pQueueFamilyPropertyCount, - VkQueueFamilyProperties2 *pQueueFamilyProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - disp->GetPhysicalDeviceQueueFamilyProperties2KHR(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } else { - disp->GetPhysicalDeviceQueueFamilyProperties2(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - disp->GetPhysicalDeviceMemoryProperties2KHR(unwrapped_phys_dev, pMemoryProperties); - } else { - disp->GetPhysicalDeviceMemoryProperties2(unwrapped_phys_dev, pMemoryProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, - VkSparseImageFormatProperties2 *pProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_get_physical_device_properties2) { - disp->GetPhysicalDeviceSparseImageFormatProperties2KHR(unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties); - } else { - disp->GetPhysicalDeviceSparseImageFormatProperties2(unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, - VkExternalBufferProperties *pExternalBufferProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_external_memory_capabilities){ - disp->GetPhysicalDeviceExternalBufferPropertiesKHR(unwrapped_phys_dev, pExternalBufferInfo, pExternalBufferProperties); - } else { - disp->GetPhysicalDeviceExternalBufferProperties(unwrapped_phys_dev, pExternalBufferInfo, pExternalBufferProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, - VkExternalSemaphoreProperties *pExternalSemaphoreProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_external_semaphore_capabilities) { - disp->GetPhysicalDeviceExternalSemaphorePropertiesKHR(unwrapped_phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - } else { - disp->GetPhysicalDeviceExternalSemaphoreProperties(unwrapped_phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, - VkExternalFenceProperties *pExternalFenceProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(physicalDevice); - const struct loader_instance *inst = ((struct loader_physical_device_tramp*) physicalDevice)->this_instance; - - if (inst != NULL && inst->enabled_known_extensions.khr_external_fence_capabilities) { - disp->GetPhysicalDeviceExternalFencePropertiesKHR(unwrapped_phys_dev, pExternalFenceInfo, pExternalFenceProperties); - } else { - disp->GetPhysicalDeviceExternalFenceProperties(unwrapped_phys_dev, pExternalFenceInfo, pExternalFenceProperties); - } -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->BindBufferMemory2(device, bindInfoCount, pBindInfos); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->BindImageMemory2(device, bindInfoCount, pBindInfos); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask) { - const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); - disp->CmdSetDeviceMask(commandBuffer, deviceMask); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) { - const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); - disp->CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->TrimCommandPool(device, commandPool, flags); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->GetDeviceQueue2(device, pQueueInfo, pQueue); - if (*pQueue != VK_NULL_HANDLE) - { - loader_set_dispatch(*pQueue, disp); - } -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL -vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); -} - -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void *pData) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - disp->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); -} diff --git a/loader/unknown_ext_chain.c b/loader/unknown_ext_chain.c deleted file mode 100644 index 1c8560dd..00000000 --- a/loader/unknown_ext_chain.c +++ /dev/null @@ -1,819 +0,0 @@ -/* - * Copyright (c) 2017 The Khronos Group Inc. - * Copyright (c) 2017 Valve Corporation - * Copyright (c) 2017 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author Jon Ashburn - * Author: Lenny Komow - */ - - // This code is used to pass on physical device extensions through the call chain. It must do this without creating a stack frame, - // because the actual parameters of the call are not known. Since the first parameter is known to be a VkPhysicalDevice, it can -// unwrap the physical device, overwriting the wrapped device, and then jump to the next function in the call chain. This code -// attempts to accomplish this by relying on tail-call optimizations, but there is no guarantee that this will work. As a result, -// this code is only compiled on systems where an assembly alternative has not been written. - - #include "vk_loader_platform.h" - #include "loader.h" - - #if defined(__GNUC__) && !defined(__clang__) - #pragma GCC optimize(3) // force gcc to use tail-calls - #endif - - // Trampoline function macro for unknown physical device extension command. - #define PhysDevExtTramp(num) \ - VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp##num(VkPhysicalDevice physical_device) { \ - const struct loader_instance_dispatch_table *disp; \ - disp = loader_get_instance_dispatch(physical_device); \ - disp->phys_dev_ext[num](loader_unwrap_physical_device(physical_device)); \ - } - -// Terminator function macro for unknown physical device extension command. -#define PhysDevExtTermin(num) \ - VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin##num(VkPhysicalDevice physical_device) { \ - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physical_device; \ - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; \ - struct loader_instance *inst = (struct loader_instance *)icd_term->this_instance; \ - if (NULL == icd_term->phys_dev_ext[num]) { \ - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "Extension %s not supported for this physical device", \ - inst->phys_dev_ext_disp_hash[num].func_name); \ - } \ - icd_term->phys_dev_ext[num](phys_dev_term->phys_dev); \ - } - -// Trampoline function macro for unknown physical device extension command. -#define DevExtTramp(num) \ - VKAPI_ATTR void VKAPI_CALL vkdev_ext##num(VkDevice device) { \ - const struct loader_dev_dispatch_table *disp; \ - disp = loader_get_dev_dispatch(device); \ - disp->ext_dispatch.dev_ext[num](device); \ - } - - -// Instantiations of the trampoline -PhysDevExtTramp(0) -PhysDevExtTramp(1) -PhysDevExtTramp(2) -PhysDevExtTramp(3) -PhysDevExtTramp(4) -PhysDevExtTramp(5) -PhysDevExtTramp(6) -PhysDevExtTramp(7) -PhysDevExtTramp(8) -PhysDevExtTramp(9) -PhysDevExtTramp(10) -PhysDevExtTramp(11) -PhysDevExtTramp(12) -PhysDevExtTramp(13) -PhysDevExtTramp(14) -PhysDevExtTramp(15) -PhysDevExtTramp(16) -PhysDevExtTramp(17) -PhysDevExtTramp(18) -PhysDevExtTramp(19) -PhysDevExtTramp(20) -PhysDevExtTramp(21) -PhysDevExtTramp(22) -PhysDevExtTramp(23) -PhysDevExtTramp(24) -PhysDevExtTramp(25) -PhysDevExtTramp(26) -PhysDevExtTramp(27) -PhysDevExtTramp(28) -PhysDevExtTramp(29) -PhysDevExtTramp(30) -PhysDevExtTramp(31) -PhysDevExtTramp(32) -PhysDevExtTramp(33) -PhysDevExtTramp(34) -PhysDevExtTramp(35) -PhysDevExtTramp(36) -PhysDevExtTramp(37) -PhysDevExtTramp(38) -PhysDevExtTramp(39) -PhysDevExtTramp(40) -PhysDevExtTramp(41) -PhysDevExtTramp(42) -PhysDevExtTramp(43) -PhysDevExtTramp(44) -PhysDevExtTramp(45) -PhysDevExtTramp(46) -PhysDevExtTramp(47) -PhysDevExtTramp(48) -PhysDevExtTramp(49) -PhysDevExtTramp(50) -PhysDevExtTramp(51) -PhysDevExtTramp(52) -PhysDevExtTramp(53) -PhysDevExtTramp(54) -PhysDevExtTramp(55) -PhysDevExtTramp(56) -PhysDevExtTramp(57) -PhysDevExtTramp(58) -PhysDevExtTramp(59) -PhysDevExtTramp(60) -PhysDevExtTramp(61) -PhysDevExtTramp(62) -PhysDevExtTramp(63) -PhysDevExtTramp(64) -PhysDevExtTramp(65) -PhysDevExtTramp(66) -PhysDevExtTramp(67) -PhysDevExtTramp(68) -PhysDevExtTramp(69) -PhysDevExtTramp(70) -PhysDevExtTramp(71) -PhysDevExtTramp(72) -PhysDevExtTramp(73) -PhysDevExtTramp(74) -PhysDevExtTramp(75) -PhysDevExtTramp(76) -PhysDevExtTramp(77) -PhysDevExtTramp(78) -PhysDevExtTramp(79) -PhysDevExtTramp(80) -PhysDevExtTramp(81) -PhysDevExtTramp(82) -PhysDevExtTramp(83) -PhysDevExtTramp(84) -PhysDevExtTramp(85) -PhysDevExtTramp(86) -PhysDevExtTramp(87) -PhysDevExtTramp(88) -PhysDevExtTramp(89) -PhysDevExtTramp(90) -PhysDevExtTramp(91) -PhysDevExtTramp(92) -PhysDevExtTramp(93) -PhysDevExtTramp(94) -PhysDevExtTramp(95) -PhysDevExtTramp(96) -PhysDevExtTramp(97) -PhysDevExtTramp(98) -PhysDevExtTramp(99) -PhysDevExtTramp(100) -PhysDevExtTramp(101) -PhysDevExtTramp(102) -PhysDevExtTramp(103) -PhysDevExtTramp(104) -PhysDevExtTramp(105) -PhysDevExtTramp(106) -PhysDevExtTramp(107) -PhysDevExtTramp(108) -PhysDevExtTramp(109) -PhysDevExtTramp(110) -PhysDevExtTramp(111) -PhysDevExtTramp(112) -PhysDevExtTramp(113) -PhysDevExtTramp(114) -PhysDevExtTramp(115) -PhysDevExtTramp(116) -PhysDevExtTramp(117) -PhysDevExtTramp(118) -PhysDevExtTramp(119) -PhysDevExtTramp(120) -PhysDevExtTramp(121) -PhysDevExtTramp(122) -PhysDevExtTramp(123) -PhysDevExtTramp(124) -PhysDevExtTramp(125) -PhysDevExtTramp(126) -PhysDevExtTramp(127) -PhysDevExtTramp(128) -PhysDevExtTramp(129) -PhysDevExtTramp(130) -PhysDevExtTramp(131) -PhysDevExtTramp(132) -PhysDevExtTramp(133) -PhysDevExtTramp(134) -PhysDevExtTramp(135) -PhysDevExtTramp(136) -PhysDevExtTramp(137) -PhysDevExtTramp(138) -PhysDevExtTramp(139) -PhysDevExtTramp(140) -PhysDevExtTramp(141) -PhysDevExtTramp(142) -PhysDevExtTramp(143) -PhysDevExtTramp(144) -PhysDevExtTramp(145) -PhysDevExtTramp(146) -PhysDevExtTramp(147) -PhysDevExtTramp(148) -PhysDevExtTramp(149) -PhysDevExtTramp(150) -PhysDevExtTramp(151) -PhysDevExtTramp(152) -PhysDevExtTramp(153) -PhysDevExtTramp(154) -PhysDevExtTramp(155) -PhysDevExtTramp(156) -PhysDevExtTramp(157) -PhysDevExtTramp(158) -PhysDevExtTramp(159) -PhysDevExtTramp(160) -PhysDevExtTramp(161) -PhysDevExtTramp(162) -PhysDevExtTramp(163) -PhysDevExtTramp(164) -PhysDevExtTramp(165) -PhysDevExtTramp(166) -PhysDevExtTramp(167) -PhysDevExtTramp(168) -PhysDevExtTramp(169) -PhysDevExtTramp(170) -PhysDevExtTramp(171) -PhysDevExtTramp(172) -PhysDevExtTramp(173) -PhysDevExtTramp(174) -PhysDevExtTramp(175) -PhysDevExtTramp(176) -PhysDevExtTramp(177) -PhysDevExtTramp(178) -PhysDevExtTramp(179) -PhysDevExtTramp(180) -PhysDevExtTramp(181) -PhysDevExtTramp(182) -PhysDevExtTramp(183) -PhysDevExtTramp(184) -PhysDevExtTramp(185) -PhysDevExtTramp(186) -PhysDevExtTramp(187) -PhysDevExtTramp(188) -PhysDevExtTramp(189) -PhysDevExtTramp(190) -PhysDevExtTramp(191) -PhysDevExtTramp(192) -PhysDevExtTramp(193) -PhysDevExtTramp(194) -PhysDevExtTramp(195) -PhysDevExtTramp(196) -PhysDevExtTramp(197) -PhysDevExtTramp(198) -PhysDevExtTramp(199) -PhysDevExtTramp(200) -PhysDevExtTramp(201) -PhysDevExtTramp(202) -PhysDevExtTramp(203) -PhysDevExtTramp(204) -PhysDevExtTramp(205) -PhysDevExtTramp(206) -PhysDevExtTramp(207) -PhysDevExtTramp(208) -PhysDevExtTramp(209) -PhysDevExtTramp(210) -PhysDevExtTramp(211) -PhysDevExtTramp(212) -PhysDevExtTramp(213) -PhysDevExtTramp(214) -PhysDevExtTramp(215) -PhysDevExtTramp(216) -PhysDevExtTramp(217) -PhysDevExtTramp(218) -PhysDevExtTramp(219) -PhysDevExtTramp(220) -PhysDevExtTramp(221) -PhysDevExtTramp(222) -PhysDevExtTramp(223) -PhysDevExtTramp(224) -PhysDevExtTramp(225) -PhysDevExtTramp(226) -PhysDevExtTramp(227) -PhysDevExtTramp(228) -PhysDevExtTramp(229) -PhysDevExtTramp(230) -PhysDevExtTramp(231) -PhysDevExtTramp(232) -PhysDevExtTramp(233) -PhysDevExtTramp(234) -PhysDevExtTramp(235) -PhysDevExtTramp(236) -PhysDevExtTramp(237) -PhysDevExtTramp(238) -PhysDevExtTramp(239) -PhysDevExtTramp(240) -PhysDevExtTramp(241) -PhysDevExtTramp(242) -PhysDevExtTramp(243) -PhysDevExtTramp(244) -PhysDevExtTramp(245) -PhysDevExtTramp(246) -PhysDevExtTramp(247) -PhysDevExtTramp(248) -PhysDevExtTramp(249) - -// Instantiations of the terminator -PhysDevExtTermin(0) -PhysDevExtTermin(1) -PhysDevExtTermin(2) -PhysDevExtTermin(3) -PhysDevExtTermin(4) -PhysDevExtTermin(5) -PhysDevExtTermin(6) -PhysDevExtTermin(7) -PhysDevExtTermin(8) -PhysDevExtTermin(9) -PhysDevExtTermin(10) -PhysDevExtTermin(11) -PhysDevExtTermin(12) -PhysDevExtTermin(13) -PhysDevExtTermin(14) -PhysDevExtTermin(15) -PhysDevExtTermin(16) -PhysDevExtTermin(17) -PhysDevExtTermin(18) -PhysDevExtTermin(19) -PhysDevExtTermin(20) -PhysDevExtTermin(21) -PhysDevExtTermin(22) -PhysDevExtTermin(23) -PhysDevExtTermin(24) -PhysDevExtTermin(25) -PhysDevExtTermin(26) -PhysDevExtTermin(27) -PhysDevExtTermin(28) -PhysDevExtTermin(29) -PhysDevExtTermin(30) -PhysDevExtTermin(31) -PhysDevExtTermin(32) -PhysDevExtTermin(33) -PhysDevExtTermin(34) -PhysDevExtTermin(35) -PhysDevExtTermin(36) -PhysDevExtTermin(37) -PhysDevExtTermin(38) -PhysDevExtTermin(39) -PhysDevExtTermin(40) -PhysDevExtTermin(41) -PhysDevExtTermin(42) -PhysDevExtTermin(43) -PhysDevExtTermin(44) -PhysDevExtTermin(45) -PhysDevExtTermin(46) -PhysDevExtTermin(47) -PhysDevExtTermin(48) -PhysDevExtTermin(49) -PhysDevExtTermin(50) -PhysDevExtTermin(51) -PhysDevExtTermin(52) -PhysDevExtTermin(53) -PhysDevExtTermin(54) -PhysDevExtTermin(55) -PhysDevExtTermin(56) -PhysDevExtTermin(57) -PhysDevExtTermin(58) -PhysDevExtTermin(59) -PhysDevExtTermin(60) -PhysDevExtTermin(61) -PhysDevExtTermin(62) -PhysDevExtTermin(63) -PhysDevExtTermin(64) -PhysDevExtTermin(65) -PhysDevExtTermin(66) -PhysDevExtTermin(67) -PhysDevExtTermin(68) -PhysDevExtTermin(69) -PhysDevExtTermin(70) -PhysDevExtTermin(71) -PhysDevExtTermin(72) -PhysDevExtTermin(73) -PhysDevExtTermin(74) -PhysDevExtTermin(75) -PhysDevExtTermin(76) -PhysDevExtTermin(77) -PhysDevExtTermin(78) -PhysDevExtTermin(79) -PhysDevExtTermin(80) -PhysDevExtTermin(81) -PhysDevExtTermin(82) -PhysDevExtTermin(83) -PhysDevExtTermin(84) -PhysDevExtTermin(85) -PhysDevExtTermin(86) -PhysDevExtTermin(87) -PhysDevExtTermin(88) -PhysDevExtTermin(89) -PhysDevExtTermin(90) -PhysDevExtTermin(91) -PhysDevExtTermin(92) -PhysDevExtTermin(93) -PhysDevExtTermin(94) -PhysDevExtTermin(95) -PhysDevExtTermin(96) -PhysDevExtTermin(97) -PhysDevExtTermin(98) -PhysDevExtTermin(99) -PhysDevExtTermin(100) -PhysDevExtTermin(101) -PhysDevExtTermin(102) -PhysDevExtTermin(103) -PhysDevExtTermin(104) -PhysDevExtTermin(105) -PhysDevExtTermin(106) -PhysDevExtTermin(107) -PhysDevExtTermin(108) -PhysDevExtTermin(109) -PhysDevExtTermin(110) -PhysDevExtTermin(111) -PhysDevExtTermin(112) -PhysDevExtTermin(113) -PhysDevExtTermin(114) -PhysDevExtTermin(115) -PhysDevExtTermin(116) -PhysDevExtTermin(117) -PhysDevExtTermin(118) -PhysDevExtTermin(119) -PhysDevExtTermin(120) -PhysDevExtTermin(121) -PhysDevExtTermin(122) -PhysDevExtTermin(123) -PhysDevExtTermin(124) -PhysDevExtTermin(125) -PhysDevExtTermin(126) -PhysDevExtTermin(127) -PhysDevExtTermin(128) -PhysDevExtTermin(129) -PhysDevExtTermin(130) -PhysDevExtTermin(131) -PhysDevExtTermin(132) -PhysDevExtTermin(133) -PhysDevExtTermin(134) -PhysDevExtTermin(135) -PhysDevExtTermin(136) -PhysDevExtTermin(137) -PhysDevExtTermin(138) -PhysDevExtTermin(139) -PhysDevExtTermin(140) -PhysDevExtTermin(141) -PhysDevExtTermin(142) -PhysDevExtTermin(143) -PhysDevExtTermin(144) -PhysDevExtTermin(145) -PhysDevExtTermin(146) -PhysDevExtTermin(147) -PhysDevExtTermin(148) -PhysDevExtTermin(149) -PhysDevExtTermin(150) -PhysDevExtTermin(151) -PhysDevExtTermin(152) -PhysDevExtTermin(153) -PhysDevExtTermin(154) -PhysDevExtTermin(155) -PhysDevExtTermin(156) -PhysDevExtTermin(157) -PhysDevExtTermin(158) -PhysDevExtTermin(159) -PhysDevExtTermin(160) -PhysDevExtTermin(161) -PhysDevExtTermin(162) -PhysDevExtTermin(163) -PhysDevExtTermin(164) -PhysDevExtTermin(165) -PhysDevExtTermin(166) -PhysDevExtTermin(167) -PhysDevExtTermin(168) -PhysDevExtTermin(169) -PhysDevExtTermin(170) -PhysDevExtTermin(171) -PhysDevExtTermin(172) -PhysDevExtTermin(173) -PhysDevExtTermin(174) -PhysDevExtTermin(175) -PhysDevExtTermin(176) -PhysDevExtTermin(177) -PhysDevExtTermin(178) -PhysDevExtTermin(179) -PhysDevExtTermin(180) -PhysDevExtTermin(181) -PhysDevExtTermin(182) -PhysDevExtTermin(183) -PhysDevExtTermin(184) -PhysDevExtTermin(185) -PhysDevExtTermin(186) -PhysDevExtTermin(187) -PhysDevExtTermin(188) -PhysDevExtTermin(189) -PhysDevExtTermin(190) -PhysDevExtTermin(191) -PhysDevExtTermin(192) -PhysDevExtTermin(193) -PhysDevExtTermin(194) -PhysDevExtTermin(195) -PhysDevExtTermin(196) -PhysDevExtTermin(197) -PhysDevExtTermin(198) -PhysDevExtTermin(199) -PhysDevExtTermin(200) -PhysDevExtTermin(201) -PhysDevExtTermin(202) -PhysDevExtTermin(203) -PhysDevExtTermin(204) -PhysDevExtTermin(205) -PhysDevExtTermin(206) -PhysDevExtTermin(207) -PhysDevExtTermin(208) -PhysDevExtTermin(209) -PhysDevExtTermin(210) -PhysDevExtTermin(211) -PhysDevExtTermin(212) -PhysDevExtTermin(213) -PhysDevExtTermin(214) -PhysDevExtTermin(215) -PhysDevExtTermin(216) -PhysDevExtTermin(217) -PhysDevExtTermin(218) -PhysDevExtTermin(219) -PhysDevExtTermin(220) -PhysDevExtTermin(221) -PhysDevExtTermin(222) -PhysDevExtTermin(223) -PhysDevExtTermin(224) -PhysDevExtTermin(225) -PhysDevExtTermin(226) -PhysDevExtTermin(227) -PhysDevExtTermin(228) -PhysDevExtTermin(229) -PhysDevExtTermin(230) -PhysDevExtTermin(231) -PhysDevExtTermin(232) -PhysDevExtTermin(233) -PhysDevExtTermin(234) -PhysDevExtTermin(235) -PhysDevExtTermin(236) -PhysDevExtTermin(237) -PhysDevExtTermin(238) -PhysDevExtTermin(239) -PhysDevExtTermin(240) -PhysDevExtTermin(241) -PhysDevExtTermin(242) -PhysDevExtTermin(243) -PhysDevExtTermin(244) -PhysDevExtTermin(245) -PhysDevExtTermin(246) -PhysDevExtTermin(247) -PhysDevExtTermin(248) -PhysDevExtTermin(249) - -// Instantiations of the device trampoline -DevExtTramp(0) -DevExtTramp(1) -DevExtTramp(2) -DevExtTramp(3) -DevExtTramp(4) -DevExtTramp(5) -DevExtTramp(6) -DevExtTramp(7) -DevExtTramp(8) -DevExtTramp(9) -DevExtTramp(10) -DevExtTramp(11) -DevExtTramp(12) -DevExtTramp(13) -DevExtTramp(14) -DevExtTramp(15) -DevExtTramp(16) -DevExtTramp(17) -DevExtTramp(18) -DevExtTramp(19) -DevExtTramp(20) -DevExtTramp(21) -DevExtTramp(22) -DevExtTramp(23) -DevExtTramp(24) -DevExtTramp(25) -DevExtTramp(26) -DevExtTramp(27) -DevExtTramp(28) -DevExtTramp(29) -DevExtTramp(30) -DevExtTramp(31) -DevExtTramp(32) -DevExtTramp(33) -DevExtTramp(34) -DevExtTramp(35) -DevExtTramp(36) -DevExtTramp(37) -DevExtTramp(38) -DevExtTramp(39) -DevExtTramp(40) -DevExtTramp(41) -DevExtTramp(42) -DevExtTramp(43) -DevExtTramp(44) -DevExtTramp(45) -DevExtTramp(46) -DevExtTramp(47) -DevExtTramp(48) -DevExtTramp(49) -DevExtTramp(50) -DevExtTramp(51) -DevExtTramp(52) -DevExtTramp(53) -DevExtTramp(54) -DevExtTramp(55) -DevExtTramp(56) -DevExtTramp(57) -DevExtTramp(58) -DevExtTramp(59) -DevExtTramp(60) -DevExtTramp(61) -DevExtTramp(62) -DevExtTramp(63) -DevExtTramp(64) -DevExtTramp(65) -DevExtTramp(66) -DevExtTramp(67) -DevExtTramp(68) -DevExtTramp(69) -DevExtTramp(70) -DevExtTramp(71) -DevExtTramp(72) -DevExtTramp(73) -DevExtTramp(74) -DevExtTramp(75) -DevExtTramp(76) -DevExtTramp(77) -DevExtTramp(78) -DevExtTramp(79) -DevExtTramp(80) -DevExtTramp(81) -DevExtTramp(82) -DevExtTramp(83) -DevExtTramp(84) -DevExtTramp(85) -DevExtTramp(86) -DevExtTramp(87) -DevExtTramp(88) -DevExtTramp(89) -DevExtTramp(90) -DevExtTramp(91) -DevExtTramp(92) -DevExtTramp(93) -DevExtTramp(94) -DevExtTramp(95) -DevExtTramp(96) -DevExtTramp(97) -DevExtTramp(98) -DevExtTramp(99) -DevExtTramp(100) -DevExtTramp(101) -DevExtTramp(102) -DevExtTramp(103) -DevExtTramp(104) -DevExtTramp(105) -DevExtTramp(106) -DevExtTramp(107) -DevExtTramp(108) -DevExtTramp(109) -DevExtTramp(110) -DevExtTramp(111) -DevExtTramp(112) -DevExtTramp(113) -DevExtTramp(114) -DevExtTramp(115) -DevExtTramp(116) -DevExtTramp(117) -DevExtTramp(118) -DevExtTramp(119) -DevExtTramp(120) -DevExtTramp(121) -DevExtTramp(122) -DevExtTramp(123) -DevExtTramp(124) -DevExtTramp(125) -DevExtTramp(126) -DevExtTramp(127) -DevExtTramp(128) -DevExtTramp(129) -DevExtTramp(130) -DevExtTramp(131) -DevExtTramp(132) -DevExtTramp(133) -DevExtTramp(134) -DevExtTramp(135) -DevExtTramp(136) -DevExtTramp(137) -DevExtTramp(138) -DevExtTramp(139) -DevExtTramp(140) -DevExtTramp(141) -DevExtTramp(142) -DevExtTramp(143) -DevExtTramp(144) -DevExtTramp(145) -DevExtTramp(146) -DevExtTramp(147) -DevExtTramp(148) -DevExtTramp(149) -DevExtTramp(150) -DevExtTramp(151) -DevExtTramp(152) -DevExtTramp(153) -DevExtTramp(154) -DevExtTramp(155) -DevExtTramp(156) -DevExtTramp(157) -DevExtTramp(158) -DevExtTramp(159) -DevExtTramp(160) -DevExtTramp(161) -DevExtTramp(162) -DevExtTramp(163) -DevExtTramp(164) -DevExtTramp(165) -DevExtTramp(166) -DevExtTramp(167) -DevExtTramp(168) -DevExtTramp(169) -DevExtTramp(170) -DevExtTramp(171) -DevExtTramp(172) -DevExtTramp(173) -DevExtTramp(174) -DevExtTramp(175) -DevExtTramp(176) -DevExtTramp(177) -DevExtTramp(178) -DevExtTramp(179) -DevExtTramp(180) -DevExtTramp(181) -DevExtTramp(182) -DevExtTramp(183) -DevExtTramp(184) -DevExtTramp(185) -DevExtTramp(186) -DevExtTramp(187) -DevExtTramp(188) -DevExtTramp(189) -DevExtTramp(190) -DevExtTramp(191) -DevExtTramp(192) -DevExtTramp(193) -DevExtTramp(194) -DevExtTramp(195) -DevExtTramp(196) -DevExtTramp(197) -DevExtTramp(198) -DevExtTramp(199) -DevExtTramp(200) -DevExtTramp(201) -DevExtTramp(202) -DevExtTramp(203) -DevExtTramp(204) -DevExtTramp(205) -DevExtTramp(206) -DevExtTramp(207) -DevExtTramp(208) -DevExtTramp(209) -DevExtTramp(210) -DevExtTramp(211) -DevExtTramp(212) -DevExtTramp(213) -DevExtTramp(214) -DevExtTramp(215) -DevExtTramp(216) -DevExtTramp(217) -DevExtTramp(218) -DevExtTramp(219) -DevExtTramp(220) -DevExtTramp(221) -DevExtTramp(222) -DevExtTramp(223) -DevExtTramp(224) -DevExtTramp(225) -DevExtTramp(226) -DevExtTramp(227) -DevExtTramp(228) -DevExtTramp(229) -DevExtTramp(230) -DevExtTramp(231) -DevExtTramp(232) -DevExtTramp(233) -DevExtTramp(234) -DevExtTramp(235) -DevExtTramp(236) -DevExtTramp(237) -DevExtTramp(238) -DevExtTramp(239) -DevExtTramp(240) -DevExtTramp(241) -DevExtTramp(242) -DevExtTramp(243) -DevExtTramp(244) -DevExtTramp(245) -DevExtTramp(246) -DevExtTramp(247) -DevExtTramp(248) -DevExtTramp(249) diff --git a/loader/unknown_ext_chain_gas.asm b/loader/unknown_ext_chain_gas.asm deleted file mode 100644 index aca92ea5..00000000 --- a/loader/unknown_ext_chain_gas.asm +++ /dev/null @@ -1,873 +0,0 @@ -# -# Copyright (c) 2017 The Khronos Group Inc. -# Copyright (c) 2017 Valve Corporation -# Copyright (c) 2017 LunarG, Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Author: Lenny Komow -# - -# This code is used to pass on device (including physical device) extensions through the call chain. It must do this without -# creating a stack frame, because the actual parameters of the call are not known. Since the first parameter is known to be a -# VkPhysicalDevice or a dispatchable object it can unwrap the object, possibly overwriting the wrapped physical device, and then -# jump to the next function in the call chain - -.intel_syntax noprefix -.include "gen_defines.asm" - -.ifdef X86_64 - -.macro PhysDevExtTramp num -.global vkPhysDevExtTramp\num -vkPhysDevExtTramp\num: - mov rax, [rdi] - mov rdi, [rdi + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP] - jmp [rax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * \num))] -.endm - -.macro PhysDevExtTermin num -.global vkPhysDevExtTermin\num -vkPhysDevExtTermin\num: - mov rax, [rdi + ICD_TERM_OFFSET_PHYS_DEV_TERM] # Store the loader_icd_term* in rax - cmp qword ptr [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))], 0 # Check if the next function in the chain is NULL - je terminError\num # Go to the error section if it is NULL - mov rdi, [rdi + PHYS_DEV_OFFSET_PHYS_DEV_TERM] # Load the unwrapped VkPhysicalDevice into the first arg - jmp [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))] # Jump to the next function in the chain -terminError\num: - sub rsp, 56 # Create the stack frame - mov rdi, [rax + INSTANCE_OFFSET_ICD_TERM] # Load the loader_instance into rdi (first arg) - mov r8, [rdi + (HASH_OFFSET_INSTANCE + (HASH_SIZE * \num) + FUNC_NAME_OFFSET_HASH)] # Load the func name into r8 (fifth arg) - lea rcx, termin_error_string@GOTPCREL # Load the error string into rcx (fourth arg) - xor edx, edx # Set rdx to zero (third arg) - lea esi, [rdx + VK_DEBUG_REPORT_ERROR_BIT_EXT] # Write the error logging bit to rsi (second arg) - call loader_log # Log the error message before we crash - add rsp, 56 # Clean up the stack frame - mov rax, 0 - jmp rax # Crash intentionally by jumping to address zero -.endm - -.macro DevExtTramp num -.global vkdev_ext\num -vkdev_ext\num: - mov rax, [rdi] # Dereference the handle to get the dispatch table - jmp [rax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * \num))] # Jump to the appropriate call chain -.endm - -.else - -.macro PhysDevExtTramp num -.global vkPhysDevExtTramp\num -vkPhysDevExtTramp\num: - mov eax, [esp + 4] # Load the wrapped VkPhysicalDevice into eax - mov ecx, [eax + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP] # Load the unwrapped VkPhysicalDevice into ecx - mov [esp + 4], ecx # Overwrite the wrapped VkPhysicalDevice with the unwrapped one (on the stack) - mov eax, [eax] # Dereference the wrapped VkPhysicalDevice to get the dispatch table in eax - jmp [eax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * \num))] # Dereference the wrapped VkPhysicalDevice to get the dispatch table in eax -.endm - -.macro PhysDevExtTermin num -.global vkPhysDevExtTermin\num -vkPhysDevExtTermin\num: - mov ecx, [esp + 4] # Move the wrapped VkPhysicalDevice into ecx - mov eax, [ecx + ICD_TERM_OFFSET_PHYS_DEV_TERM] # Store the loader_icd_term* in eax - cmp dword ptr [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))], 0 # Check if the next function in the chain is NULL - je terminError\num # Go to the error section if it is NULL - mov ecx, [ecx + PHYS_DEV_OFFSET_PHYS_DEV_TERM] # Unwrap the VkPhysicalDevice in ecx - mov [esp + 4], ecx # Copy the unwrapped VkPhysicalDevice into the first arg - jmp [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))] # Jump to the next function in the chain -terminError\num: - mov eax, [eax + INSTANCE_OFFSET_ICD_TERM] # Load the loader_instance into eax - push [eax + (HASH_OFFSET_INSTANCE + (HASH_SIZE * \num) + FUNC_NAME_OFFSET_HASH)] # Push the func name (fifth arg) - push offset termin_error_string@GOT # Push the error string (fourth arg) - push 0 # Push zero (third arg) - push VK_DEBUG_REPORT_ERROR_BIT_EXT # Push the error logging bit (second arg) - push eax # Push the loader_instance (first arg) - call loader_log # Log the error message before we crash - add esp, 20 # Clean up the args - mov eax, 0 - jmp eax # Crash intentionally by jumping to address zero -.endm - -.macro DevExtTramp num -.global vkdev_ext\num -vkdev_ext\num: - mov eax, [esp + 4] # Dereference the handle to get the dispatch table - jmp [eax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * \num))] # Jump to the appropriate call chain -.endm - -.endif - -#if defined(__ELF__) -.section .note.GNU-stack,"",%progbits -#endif - -.data - -termin_error_string: -.string "Extension %s not supported for this physical device" - -.text - - PhysDevExtTramp 0 - PhysDevExtTramp 1 - PhysDevExtTramp 2 - PhysDevExtTramp 3 - PhysDevExtTramp 4 - PhysDevExtTramp 5 - PhysDevExtTramp 6 - PhysDevExtTramp 7 - PhysDevExtTramp 8 - PhysDevExtTramp 9 - PhysDevExtTramp 10 - PhysDevExtTramp 11 - PhysDevExtTramp 12 - PhysDevExtTramp 13 - PhysDevExtTramp 14 - PhysDevExtTramp 15 - PhysDevExtTramp 16 - PhysDevExtTramp 17 - PhysDevExtTramp 18 - PhysDevExtTramp 19 - PhysDevExtTramp 20 - PhysDevExtTramp 21 - PhysDevExtTramp 22 - PhysDevExtTramp 23 - PhysDevExtTramp 24 - PhysDevExtTramp 25 - PhysDevExtTramp 26 - PhysDevExtTramp 27 - PhysDevExtTramp 28 - PhysDevExtTramp 29 - PhysDevExtTramp 30 - PhysDevExtTramp 31 - PhysDevExtTramp 32 - PhysDevExtTramp 33 - PhysDevExtTramp 34 - PhysDevExtTramp 35 - PhysDevExtTramp 36 - PhysDevExtTramp 37 - PhysDevExtTramp 38 - PhysDevExtTramp 39 - PhysDevExtTramp 40 - PhysDevExtTramp 41 - PhysDevExtTramp 42 - PhysDevExtTramp 43 - PhysDevExtTramp 44 - PhysDevExtTramp 45 - PhysDevExtTramp 46 - PhysDevExtTramp 47 - PhysDevExtTramp 48 - PhysDevExtTramp 49 - PhysDevExtTramp 50 - PhysDevExtTramp 51 - PhysDevExtTramp 52 - PhysDevExtTramp 53 - PhysDevExtTramp 54 - PhysDevExtTramp 55 - PhysDevExtTramp 56 - PhysDevExtTramp 57 - PhysDevExtTramp 58 - PhysDevExtTramp 59 - PhysDevExtTramp 60 - PhysDevExtTramp 61 - PhysDevExtTramp 62 - PhysDevExtTramp 63 - PhysDevExtTramp 64 - PhysDevExtTramp 65 - PhysDevExtTramp 66 - PhysDevExtTramp 67 - PhysDevExtTramp 68 - PhysDevExtTramp 69 - PhysDevExtTramp 70 - PhysDevExtTramp 71 - PhysDevExtTramp 72 - PhysDevExtTramp 73 - PhysDevExtTramp 74 - PhysDevExtTramp 75 - PhysDevExtTramp 76 - PhysDevExtTramp 77 - PhysDevExtTramp 78 - PhysDevExtTramp 79 - PhysDevExtTramp 80 - PhysDevExtTramp 81 - PhysDevExtTramp 82 - PhysDevExtTramp 83 - PhysDevExtTramp 84 - PhysDevExtTramp 85 - PhysDevExtTramp 86 - PhysDevExtTramp 87 - PhysDevExtTramp 88 - PhysDevExtTramp 89 - PhysDevExtTramp 90 - PhysDevExtTramp 91 - PhysDevExtTramp 92 - PhysDevExtTramp 93 - PhysDevExtTramp 94 - PhysDevExtTramp 95 - PhysDevExtTramp 96 - PhysDevExtTramp 97 - PhysDevExtTramp 98 - PhysDevExtTramp 99 - PhysDevExtTramp 100 - PhysDevExtTramp 101 - PhysDevExtTramp 102 - PhysDevExtTramp 103 - PhysDevExtTramp 104 - PhysDevExtTramp 105 - PhysDevExtTramp 106 - PhysDevExtTramp 107 - PhysDevExtTramp 108 - PhysDevExtTramp 109 - PhysDevExtTramp 110 - PhysDevExtTramp 111 - PhysDevExtTramp 112 - PhysDevExtTramp 113 - PhysDevExtTramp 114 - PhysDevExtTramp 115 - PhysDevExtTramp 116 - PhysDevExtTramp 117 - PhysDevExtTramp 118 - PhysDevExtTramp 119 - PhysDevExtTramp 120 - PhysDevExtTramp 121 - PhysDevExtTramp 122 - PhysDevExtTramp 123 - PhysDevExtTramp 124 - PhysDevExtTramp 125 - PhysDevExtTramp 126 - PhysDevExtTramp 127 - PhysDevExtTramp 128 - PhysDevExtTramp 129 - PhysDevExtTramp 130 - PhysDevExtTramp 131 - PhysDevExtTramp 132 - PhysDevExtTramp 133 - PhysDevExtTramp 134 - PhysDevExtTramp 135 - PhysDevExtTramp 136 - PhysDevExtTramp 137 - PhysDevExtTramp 138 - PhysDevExtTramp 139 - PhysDevExtTramp 140 - PhysDevExtTramp 141 - PhysDevExtTramp 142 - PhysDevExtTramp 143 - PhysDevExtTramp 144 - PhysDevExtTramp 145 - PhysDevExtTramp 146 - PhysDevExtTramp 147 - PhysDevExtTramp 148 - PhysDevExtTramp 149 - PhysDevExtTramp 150 - PhysDevExtTramp 151 - PhysDevExtTramp 152 - PhysDevExtTramp 153 - PhysDevExtTramp 154 - PhysDevExtTramp 155 - PhysDevExtTramp 156 - PhysDevExtTramp 157 - PhysDevExtTramp 158 - PhysDevExtTramp 159 - PhysDevExtTramp 160 - PhysDevExtTramp 161 - PhysDevExtTramp 162 - PhysDevExtTramp 163 - PhysDevExtTramp 164 - PhysDevExtTramp 165 - PhysDevExtTramp 166 - PhysDevExtTramp 167 - PhysDevExtTramp 168 - PhysDevExtTramp 169 - PhysDevExtTramp 170 - PhysDevExtTramp 171 - PhysDevExtTramp 172 - PhysDevExtTramp 173 - PhysDevExtTramp 174 - PhysDevExtTramp 175 - PhysDevExtTramp 176 - PhysDevExtTramp 177 - PhysDevExtTramp 178 - PhysDevExtTramp 179 - PhysDevExtTramp 180 - PhysDevExtTramp 181 - PhysDevExtTramp 182 - PhysDevExtTramp 183 - PhysDevExtTramp 184 - PhysDevExtTramp 185 - PhysDevExtTramp 186 - PhysDevExtTramp 187 - PhysDevExtTramp 188 - PhysDevExtTramp 189 - PhysDevExtTramp 190 - PhysDevExtTramp 191 - PhysDevExtTramp 192 - PhysDevExtTramp 193 - PhysDevExtTramp 194 - PhysDevExtTramp 195 - PhysDevExtTramp 196 - PhysDevExtTramp 197 - PhysDevExtTramp 198 - PhysDevExtTramp 199 - PhysDevExtTramp 200 - PhysDevExtTramp 201 - PhysDevExtTramp 202 - PhysDevExtTramp 203 - PhysDevExtTramp 204 - PhysDevExtTramp 205 - PhysDevExtTramp 206 - PhysDevExtTramp 207 - PhysDevExtTramp 208 - PhysDevExtTramp 209 - PhysDevExtTramp 210 - PhysDevExtTramp 211 - PhysDevExtTramp 212 - PhysDevExtTramp 213 - PhysDevExtTramp 214 - PhysDevExtTramp 215 - PhysDevExtTramp 216 - PhysDevExtTramp 217 - PhysDevExtTramp 218 - PhysDevExtTramp 219 - PhysDevExtTramp 220 - PhysDevExtTramp 221 - PhysDevExtTramp 222 - PhysDevExtTramp 223 - PhysDevExtTramp 224 - PhysDevExtTramp 225 - PhysDevExtTramp 226 - PhysDevExtTramp 227 - PhysDevExtTramp 228 - PhysDevExtTramp 229 - PhysDevExtTramp 230 - PhysDevExtTramp 231 - PhysDevExtTramp 232 - PhysDevExtTramp 233 - PhysDevExtTramp 234 - PhysDevExtTramp 235 - PhysDevExtTramp 236 - PhysDevExtTramp 237 - PhysDevExtTramp 238 - PhysDevExtTramp 239 - PhysDevExtTramp 240 - PhysDevExtTramp 241 - PhysDevExtTramp 242 - PhysDevExtTramp 243 - PhysDevExtTramp 244 - PhysDevExtTramp 245 - PhysDevExtTramp 246 - PhysDevExtTramp 247 - PhysDevExtTramp 248 - PhysDevExtTramp 249 - - PhysDevExtTermin 0 - PhysDevExtTermin 1 - PhysDevExtTermin 2 - PhysDevExtTermin 3 - PhysDevExtTermin 4 - PhysDevExtTermin 5 - PhysDevExtTermin 6 - PhysDevExtTermin 7 - PhysDevExtTermin 8 - PhysDevExtTermin 9 - PhysDevExtTermin 10 - PhysDevExtTermin 11 - PhysDevExtTermin 12 - PhysDevExtTermin 13 - PhysDevExtTermin 14 - PhysDevExtTermin 15 - PhysDevExtTermin 16 - PhysDevExtTermin 17 - PhysDevExtTermin 18 - PhysDevExtTermin 19 - PhysDevExtTermin 20 - PhysDevExtTermin 21 - PhysDevExtTermin 22 - PhysDevExtTermin 23 - PhysDevExtTermin 24 - PhysDevExtTermin 25 - PhysDevExtTermin 26 - PhysDevExtTermin 27 - PhysDevExtTermin 28 - PhysDevExtTermin 29 - PhysDevExtTermin 30 - PhysDevExtTermin 31 - PhysDevExtTermin 32 - PhysDevExtTermin 33 - PhysDevExtTermin 34 - PhysDevExtTermin 35 - PhysDevExtTermin 36 - PhysDevExtTermin 37 - PhysDevExtTermin 38 - PhysDevExtTermin 39 - PhysDevExtTermin 40 - PhysDevExtTermin 41 - PhysDevExtTermin 42 - PhysDevExtTermin 43 - PhysDevExtTermin 44 - PhysDevExtTermin 45 - PhysDevExtTermin 46 - PhysDevExtTermin 47 - PhysDevExtTermin 48 - PhysDevExtTermin 49 - PhysDevExtTermin 50 - PhysDevExtTermin 51 - PhysDevExtTermin 52 - PhysDevExtTermin 53 - PhysDevExtTermin 54 - PhysDevExtTermin 55 - PhysDevExtTermin 56 - PhysDevExtTermin 57 - PhysDevExtTermin 58 - PhysDevExtTermin 59 - PhysDevExtTermin 60 - PhysDevExtTermin 61 - PhysDevExtTermin 62 - PhysDevExtTermin 63 - PhysDevExtTermin 64 - PhysDevExtTermin 65 - PhysDevExtTermin 66 - PhysDevExtTermin 67 - PhysDevExtTermin 68 - PhysDevExtTermin 69 - PhysDevExtTermin 70 - PhysDevExtTermin 71 - PhysDevExtTermin 72 - PhysDevExtTermin 73 - PhysDevExtTermin 74 - PhysDevExtTermin 75 - PhysDevExtTermin 76 - PhysDevExtTermin 77 - PhysDevExtTermin 78 - PhysDevExtTermin 79 - PhysDevExtTermin 80 - PhysDevExtTermin 81 - PhysDevExtTermin 82 - PhysDevExtTermin 83 - PhysDevExtTermin 84 - PhysDevExtTermin 85 - PhysDevExtTermin 86 - PhysDevExtTermin 87 - PhysDevExtTermin 88 - PhysDevExtTermin 89 - PhysDevExtTermin 90 - PhysDevExtTermin 91 - PhysDevExtTermin 92 - PhysDevExtTermin 93 - PhysDevExtTermin 94 - PhysDevExtTermin 95 - PhysDevExtTermin 96 - PhysDevExtTermin 97 - PhysDevExtTermin 98 - PhysDevExtTermin 99 - PhysDevExtTermin 100 - PhysDevExtTermin 101 - PhysDevExtTermin 102 - PhysDevExtTermin 103 - PhysDevExtTermin 104 - PhysDevExtTermin 105 - PhysDevExtTermin 106 - PhysDevExtTermin 107 - PhysDevExtTermin 108 - PhysDevExtTermin 109 - PhysDevExtTermin 110 - PhysDevExtTermin 111 - PhysDevExtTermin 112 - PhysDevExtTermin 113 - PhysDevExtTermin 114 - PhysDevExtTermin 115 - PhysDevExtTermin 116 - PhysDevExtTermin 117 - PhysDevExtTermin 118 - PhysDevExtTermin 119 - PhysDevExtTermin 120 - PhysDevExtTermin 121 - PhysDevExtTermin 122 - PhysDevExtTermin 123 - PhysDevExtTermin 124 - PhysDevExtTermin 125 - PhysDevExtTermin 126 - PhysDevExtTermin 127 - PhysDevExtTermin 128 - PhysDevExtTermin 129 - PhysDevExtTermin 130 - PhysDevExtTermin 131 - PhysDevExtTermin 132 - PhysDevExtTermin 133 - PhysDevExtTermin 134 - PhysDevExtTermin 135 - PhysDevExtTermin 136 - PhysDevExtTermin 137 - PhysDevExtTermin 138 - PhysDevExtTermin 139 - PhysDevExtTermin 140 - PhysDevExtTermin 141 - PhysDevExtTermin 142 - PhysDevExtTermin 143 - PhysDevExtTermin 144 - PhysDevExtTermin 145 - PhysDevExtTermin 146 - PhysDevExtTermin 147 - PhysDevExtTermin 148 - PhysDevExtTermin 149 - PhysDevExtTermin 150 - PhysDevExtTermin 151 - PhysDevExtTermin 152 - PhysDevExtTermin 153 - PhysDevExtTermin 154 - PhysDevExtTermin 155 - PhysDevExtTermin 156 - PhysDevExtTermin 157 - PhysDevExtTermin 158 - PhysDevExtTermin 159 - PhysDevExtTermin 160 - PhysDevExtTermin 161 - PhysDevExtTermin 162 - PhysDevExtTermin 163 - PhysDevExtTermin 164 - PhysDevExtTermin 165 - PhysDevExtTermin 166 - PhysDevExtTermin 167 - PhysDevExtTermin 168 - PhysDevExtTermin 169 - PhysDevExtTermin 170 - PhysDevExtTermin 171 - PhysDevExtTermin 172 - PhysDevExtTermin 173 - PhysDevExtTermin 174 - PhysDevExtTermin 175 - PhysDevExtTermin 176 - PhysDevExtTermin 177 - PhysDevExtTermin 178 - PhysDevExtTermin 179 - PhysDevExtTermin 180 - PhysDevExtTermin 181 - PhysDevExtTermin 182 - PhysDevExtTermin 183 - PhysDevExtTermin 184 - PhysDevExtTermin 185 - PhysDevExtTermin 186 - PhysDevExtTermin 187 - PhysDevExtTermin 188 - PhysDevExtTermin 189 - PhysDevExtTermin 190 - PhysDevExtTermin 191 - PhysDevExtTermin 192 - PhysDevExtTermin 193 - PhysDevExtTermin 194 - PhysDevExtTermin 195 - PhysDevExtTermin 196 - PhysDevExtTermin 197 - PhysDevExtTermin 198 - PhysDevExtTermin 199 - PhysDevExtTermin 200 - PhysDevExtTermin 201 - PhysDevExtTermin 202 - PhysDevExtTermin 203 - PhysDevExtTermin 204 - PhysDevExtTermin 205 - PhysDevExtTermin 206 - PhysDevExtTermin 207 - PhysDevExtTermin 208 - PhysDevExtTermin 209 - PhysDevExtTermin 210 - PhysDevExtTermin 211 - PhysDevExtTermin 212 - PhysDevExtTermin 213 - PhysDevExtTermin 214 - PhysDevExtTermin 215 - PhysDevExtTermin 216 - PhysDevExtTermin 217 - PhysDevExtTermin 218 - PhysDevExtTermin 219 - PhysDevExtTermin 220 - PhysDevExtTermin 221 - PhysDevExtTermin 222 - PhysDevExtTermin 223 - PhysDevExtTermin 224 - PhysDevExtTermin 225 - PhysDevExtTermin 226 - PhysDevExtTermin 227 - PhysDevExtTermin 228 - PhysDevExtTermin 229 - PhysDevExtTermin 230 - PhysDevExtTermin 231 - PhysDevExtTermin 232 - PhysDevExtTermin 233 - PhysDevExtTermin 234 - PhysDevExtTermin 235 - PhysDevExtTermin 236 - PhysDevExtTermin 237 - PhysDevExtTermin 238 - PhysDevExtTermin 239 - PhysDevExtTermin 240 - PhysDevExtTermin 241 - PhysDevExtTermin 242 - PhysDevExtTermin 243 - PhysDevExtTermin 244 - PhysDevExtTermin 245 - PhysDevExtTermin 246 - PhysDevExtTermin 247 - PhysDevExtTermin 248 - PhysDevExtTermin 249 - - DevExtTramp 0 - DevExtTramp 1 - DevExtTramp 2 - DevExtTramp 3 - DevExtTramp 4 - DevExtTramp 5 - DevExtTramp 6 - DevExtTramp 7 - DevExtTramp 8 - DevExtTramp 9 - DevExtTramp 10 - DevExtTramp 11 - DevExtTramp 12 - DevExtTramp 13 - DevExtTramp 14 - DevExtTramp 15 - DevExtTramp 16 - DevExtTramp 17 - DevExtTramp 18 - DevExtTramp 19 - DevExtTramp 20 - DevExtTramp 21 - DevExtTramp 22 - DevExtTramp 23 - DevExtTramp 24 - DevExtTramp 25 - DevExtTramp 26 - DevExtTramp 27 - DevExtTramp 28 - DevExtTramp 29 - DevExtTramp 30 - DevExtTramp 31 - DevExtTramp 32 - DevExtTramp 33 - DevExtTramp 34 - DevExtTramp 35 - DevExtTramp 36 - DevExtTramp 37 - DevExtTramp 38 - DevExtTramp 39 - DevExtTramp 40 - DevExtTramp 41 - DevExtTramp 42 - DevExtTramp 43 - DevExtTramp 44 - DevExtTramp 45 - DevExtTramp 46 - DevExtTramp 47 - DevExtTramp 48 - DevExtTramp 49 - DevExtTramp 50 - DevExtTramp 51 - DevExtTramp 52 - DevExtTramp 53 - DevExtTramp 54 - DevExtTramp 55 - DevExtTramp 56 - DevExtTramp 57 - DevExtTramp 58 - DevExtTramp 59 - DevExtTramp 60 - DevExtTramp 61 - DevExtTramp 62 - DevExtTramp 63 - DevExtTramp 64 - DevExtTramp 65 - DevExtTramp 66 - DevExtTramp 67 - DevExtTramp 68 - DevExtTramp 69 - DevExtTramp 70 - DevExtTramp 71 - DevExtTramp 72 - DevExtTramp 73 - DevExtTramp 74 - DevExtTramp 75 - DevExtTramp 76 - DevExtTramp 77 - DevExtTramp 78 - DevExtTramp 79 - DevExtTramp 80 - DevExtTramp 81 - DevExtTramp 82 - DevExtTramp 83 - DevExtTramp 84 - DevExtTramp 85 - DevExtTramp 86 - DevExtTramp 87 - DevExtTramp 88 - DevExtTramp 89 - DevExtTramp 90 - DevExtTramp 91 - DevExtTramp 92 - DevExtTramp 93 - DevExtTramp 94 - DevExtTramp 95 - DevExtTramp 96 - DevExtTramp 97 - DevExtTramp 98 - DevExtTramp 99 - DevExtTramp 100 - DevExtTramp 101 - DevExtTramp 102 - DevExtTramp 103 - DevExtTramp 104 - DevExtTramp 105 - DevExtTramp 106 - DevExtTramp 107 - DevExtTramp 108 - DevExtTramp 109 - DevExtTramp 110 - DevExtTramp 111 - DevExtTramp 112 - DevExtTramp 113 - DevExtTramp 114 - DevExtTramp 115 - DevExtTramp 116 - DevExtTramp 117 - DevExtTramp 118 - DevExtTramp 119 - DevExtTramp 120 - DevExtTramp 121 - DevExtTramp 122 - DevExtTramp 123 - DevExtTramp 124 - DevExtTramp 125 - DevExtTramp 126 - DevExtTramp 127 - DevExtTramp 128 - DevExtTramp 129 - DevExtTramp 130 - DevExtTramp 131 - DevExtTramp 132 - DevExtTramp 133 - DevExtTramp 134 - DevExtTramp 135 - DevExtTramp 136 - DevExtTramp 137 - DevExtTramp 138 - DevExtTramp 139 - DevExtTramp 140 - DevExtTramp 141 - DevExtTramp 142 - DevExtTramp 143 - DevExtTramp 144 - DevExtTramp 145 - DevExtTramp 146 - DevExtTramp 147 - DevExtTramp 148 - DevExtTramp 149 - DevExtTramp 150 - DevExtTramp 151 - DevExtTramp 152 - DevExtTramp 153 - DevExtTramp 154 - DevExtTramp 155 - DevExtTramp 156 - DevExtTramp 157 - DevExtTramp 158 - DevExtTramp 159 - DevExtTramp 160 - DevExtTramp 161 - DevExtTramp 162 - DevExtTramp 163 - DevExtTramp 164 - DevExtTramp 165 - DevExtTramp 166 - DevExtTramp 167 - DevExtTramp 168 - DevExtTramp 169 - DevExtTramp 170 - DevExtTramp 171 - DevExtTramp 172 - DevExtTramp 173 - DevExtTramp 174 - DevExtTramp 175 - DevExtTramp 176 - DevExtTramp 177 - DevExtTramp 178 - DevExtTramp 179 - DevExtTramp 180 - DevExtTramp 181 - DevExtTramp 182 - DevExtTramp 183 - DevExtTramp 184 - DevExtTramp 185 - DevExtTramp 186 - DevExtTramp 187 - DevExtTramp 188 - DevExtTramp 189 - DevExtTramp 190 - DevExtTramp 191 - DevExtTramp 192 - DevExtTramp 193 - DevExtTramp 194 - DevExtTramp 195 - DevExtTramp 196 - DevExtTramp 197 - DevExtTramp 198 - DevExtTramp 199 - DevExtTramp 200 - DevExtTramp 201 - DevExtTramp 202 - DevExtTramp 203 - DevExtTramp 204 - DevExtTramp 205 - DevExtTramp 206 - DevExtTramp 207 - DevExtTramp 208 - DevExtTramp 209 - DevExtTramp 210 - DevExtTramp 211 - DevExtTramp 212 - DevExtTramp 213 - DevExtTramp 214 - DevExtTramp 215 - DevExtTramp 216 - DevExtTramp 217 - DevExtTramp 218 - DevExtTramp 219 - DevExtTramp 220 - DevExtTramp 221 - DevExtTramp 222 - DevExtTramp 223 - DevExtTramp 224 - DevExtTramp 225 - DevExtTramp 226 - DevExtTramp 227 - DevExtTramp 228 - DevExtTramp 229 - DevExtTramp 230 - DevExtTramp 231 - DevExtTramp 232 - DevExtTramp 233 - DevExtTramp 234 - DevExtTramp 235 - DevExtTramp 236 - DevExtTramp 237 - DevExtTramp 238 - DevExtTramp 239 - DevExtTramp 240 - DevExtTramp 241 - DevExtTramp 242 - DevExtTramp 243 - DevExtTramp 244 - DevExtTramp 245 - DevExtTramp 246 - DevExtTramp 247 - DevExtTramp 248 - DevExtTramp 249 diff --git a/loader/unknown_ext_chain_masm.asm b/loader/unknown_ext_chain_masm.asm deleted file mode 100644 index 34bc7c2f..00000000 --- a/loader/unknown_ext_chain_masm.asm +++ /dev/null @@ -1,883 +0,0 @@ -; -; Copyright (c) 2017 The Khronos Group Inc. -; Copyright (c) 2017 Valve Corporation -; Copyright (c) 2017 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Lenny Komow -; - -; This code is used to pass on device (including physical device) extensions through the call chain. It must do this without -; creating a stack frame, because the actual parameters of the call are not known. Since the first parameter is known to be a -; VkPhysicalDevice or a dispatchable object it can unwrap the object, possibly overwriting the wrapped physical device, and then -; jump to the next function in the call chain - -; Codegen defines a number of values, chiefly offsets of members within structs and sizes of data types within gen_defines.asm. -; Struct member offsets are defined in the format "XX_OFFSET_YY" where XX indicates the member within the struct and YY indicates -; the struct type that it is a member of. Data type sizes are defined in the format "XX_SIZE" where XX indicates the data type. -INCLUDE gen_defines.asm - -; 64-bit values and macro -IFDEF rax - -PhysDevExtTramp macro num:req -public vkPhysDevExtTramp&num& -vkPhysDevExtTramp&num&: - mov rax, qword ptr [rcx] ; Dereference the wrapped VkPhysicalDevice to get the dispatch table in rax - mov rcx, qword ptr [rcx + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP] ; Load the unwrapped VkPhysicalDevice into rcx - jmp qword ptr [rax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * num))] ; Jump to the next function in the chain, preserving the args in other registers -endm - -PhysDevExtTermin macro num -public vkPhysDevExtTermin&num& -vkPhysDevExtTermin&num&: - mov rax, qword ptr [rcx + ICD_TERM_OFFSET_PHYS_DEV_TERM] ; Store the loader_icd_term* in rax - cmp qword ptr [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))], 0 ; Check if the next function in the chain is NULL - je terminError&num& ; Go to the error section if it is NULL - mov rcx, qword ptr [rcx + PHYS_DEV_OFFSET_PHYS_DEV_TERM] ; Load the unwrapped VkPhysicalDevice into the first arg - jmp qword ptr [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))] ; Jump to the next function in the chain -terminError&num&: - sub rsp, 56 ; Create the stack frame - mov rcx, qword ptr [rax + INSTANCE_OFFSET_ICD_TERM] ; Load the loader_instance into rcx (first arg) - mov rax, qword ptr [rcx + (HASH_OFFSET_INSTANCE + (HASH_SIZE * num) + FUNC_NAME_OFFSET_HASH)] ; Load the func name into rax - lea r9, termin_error_string ; Load the error string into r9 (fourth arg) - xor r8d, r8d ; Set r8 to zero (third arg) - mov qword ptr [rsp + 32], rax ; Move the func name onto the stack (fifth arg) - lea edx, [r8 + VK_DEBUG_REPORT_ERROR_BIT_EXT] ; Write the error logging bit to rdx (second arg) - call loader_log ; Log the error message before we crash - add rsp, 56 ; Clean up the stack frame - mov rax, 0 - jmp rax ; Crash intentionally by jumping to address zero -endm - -DevExtTramp macro num -public vkdev_ext&num& -vkdev_ext&num&: - mov rax, qword ptr [rcx] ; Dereference the handle to get the dispatch table - jmp qword ptr [rax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * num))] ; Jump to the appropriate call chain -endm - -; 32-bit values and macro -ELSE - -PhysDevExtTramp macro num -public _vkPhysDevExtTramp&num&@4 -_vkPhysDevExtTramp&num&@4: - mov eax, dword ptr [esp + 4] ; Load the wrapped VkPhysicalDevice into eax - mov ecx, [eax + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP] ; Load the unwrapped VkPhysicalDevice into ecx - mov [esp + 4], ecx ; Overwrite the wrapped VkPhysicalDevice with the unwrapped one (on the stack) - mov eax, [eax] ; Dereference the wrapped VkPhysicalDevice to get the dispatch table in eax - jmp dword ptr [eax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * num))] ; Jump to the next function in the chain, preserving the args on the stack -endm - -PhysDevExtTermin macro num -public _vkPhysDevExtTermin&num&@4 -_vkPhysDevExtTermin&num&@4: - mov ecx, dword ptr [esp + 4] ; Move the wrapped VkPhysicalDevice into ecx - mov eax, dword ptr [ecx + ICD_TERM_OFFSET_PHYS_DEV_TERM] ; Store the loader_icd_term* in eax - cmp dword ptr [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))], 0 ; Check if the next function in the chain is NULL - je terminError&num& ; Go to the error section if it is NULL - mov ecx, dword ptr [ecx + PHYS_DEV_OFFSET_PHYS_DEV_TERM] ; Unwrap the VkPhysicalDevice in ecx - mov dword ptr [esp + 4], ecx ; Copy the unwrapped VkPhysicalDevice into the first arg - jmp dword ptr [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))] ; Jump to the next function in the chain -terminError&num&: - mov eax, dword ptr [eax + INSTANCE_OFFSET_ICD_TERM] ; Load the loader_instance into eax - push dword ptr [eax + (HASH_OFFSET_INSTANCE + (HASH_SIZE * num) + FUNC_NAME_OFFSET_HASH)] ; Push the func name (fifth arg) - push offset termin_error_string ; Push the error string (fourth arg) - push 0 ; Push zero (third arg) - push VK_DEBUG_REPORT_ERROR_BIT_EXT ; Push the error logging bit (second arg) - push eax ; Push the loader_instance (first arg) - call _loader_log ; Log the error message before we crash - add esp, 20 ; Clean up the args - mov eax, 0 - jmp eax ; Crash intentionally by jumping to address zero -endm - -DevExtTramp macro num -public _vkdev_ext&num&@4 -_vkdev_ext&num&@4: - mov eax, dword ptr [esp + 4] ; Dereference the handle to get the dispatch table - jmp dword ptr [eax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * num))] ; Jump to the appropriate call chain -endm - -; This is also needed for 32-bit only -.model flat - -ENDIF - -.const - termin_error_string db 'Extension %s not supported for this physical device', 0 - -.code - -IFDEF rax -extrn loader_log:near -ELSE -extrn _loader_log:near -ENDIF - - PhysDevExtTramp 0 - PhysDevExtTramp 1 - PhysDevExtTramp 2 - PhysDevExtTramp 3 - PhysDevExtTramp 4 - PhysDevExtTramp 5 - PhysDevExtTramp 6 - PhysDevExtTramp 7 - PhysDevExtTramp 8 - PhysDevExtTramp 9 - PhysDevExtTramp 10 - PhysDevExtTramp 11 - PhysDevExtTramp 12 - PhysDevExtTramp 13 - PhysDevExtTramp 14 - PhysDevExtTramp 15 - PhysDevExtTramp 16 - PhysDevExtTramp 17 - PhysDevExtTramp 18 - PhysDevExtTramp 19 - PhysDevExtTramp 20 - PhysDevExtTramp 21 - PhysDevExtTramp 22 - PhysDevExtTramp 23 - PhysDevExtTramp 24 - PhysDevExtTramp 25 - PhysDevExtTramp 26 - PhysDevExtTramp 27 - PhysDevExtTramp 28 - PhysDevExtTramp 29 - PhysDevExtTramp 30 - PhysDevExtTramp 31 - PhysDevExtTramp 32 - PhysDevExtTramp 33 - PhysDevExtTramp 34 - PhysDevExtTramp 35 - PhysDevExtTramp 36 - PhysDevExtTramp 37 - PhysDevExtTramp 38 - PhysDevExtTramp 39 - PhysDevExtTramp 40 - PhysDevExtTramp 41 - PhysDevExtTramp 42 - PhysDevExtTramp 43 - PhysDevExtTramp 44 - PhysDevExtTramp 45 - PhysDevExtTramp 46 - PhysDevExtTramp 47 - PhysDevExtTramp 48 - PhysDevExtTramp 49 - PhysDevExtTramp 50 - PhysDevExtTramp 51 - PhysDevExtTramp 52 - PhysDevExtTramp 53 - PhysDevExtTramp 54 - PhysDevExtTramp 55 - PhysDevExtTramp 56 - PhysDevExtTramp 57 - PhysDevExtTramp 58 - PhysDevExtTramp 59 - PhysDevExtTramp 60 - PhysDevExtTramp 61 - PhysDevExtTramp 62 - PhysDevExtTramp 63 - PhysDevExtTramp 64 - PhysDevExtTramp 65 - PhysDevExtTramp 66 - PhysDevExtTramp 67 - PhysDevExtTramp 68 - PhysDevExtTramp 69 - PhysDevExtTramp 70 - PhysDevExtTramp 71 - PhysDevExtTramp 72 - PhysDevExtTramp 73 - PhysDevExtTramp 74 - PhysDevExtTramp 75 - PhysDevExtTramp 76 - PhysDevExtTramp 77 - PhysDevExtTramp 78 - PhysDevExtTramp 79 - PhysDevExtTramp 80 - PhysDevExtTramp 81 - PhysDevExtTramp 82 - PhysDevExtTramp 83 - PhysDevExtTramp 84 - PhysDevExtTramp 85 - PhysDevExtTramp 86 - PhysDevExtTramp 87 - PhysDevExtTramp 88 - PhysDevExtTramp 89 - PhysDevExtTramp 90 - PhysDevExtTramp 91 - PhysDevExtTramp 92 - PhysDevExtTramp 93 - PhysDevExtTramp 94 - PhysDevExtTramp 95 - PhysDevExtTramp 96 - PhysDevExtTramp 97 - PhysDevExtTramp 98 - PhysDevExtTramp 99 - PhysDevExtTramp 100 - PhysDevExtTramp 101 - PhysDevExtTramp 102 - PhysDevExtTramp 103 - PhysDevExtTramp 104 - PhysDevExtTramp 105 - PhysDevExtTramp 106 - PhysDevExtTramp 107 - PhysDevExtTramp 108 - PhysDevExtTramp 109 - PhysDevExtTramp 110 - PhysDevExtTramp 111 - PhysDevExtTramp 112 - PhysDevExtTramp 113 - PhysDevExtTramp 114 - PhysDevExtTramp 115 - PhysDevExtTramp 116 - PhysDevExtTramp 117 - PhysDevExtTramp 118 - PhysDevExtTramp 119 - PhysDevExtTramp 120 - PhysDevExtTramp 121 - PhysDevExtTramp 122 - PhysDevExtTramp 123 - PhysDevExtTramp 124 - PhysDevExtTramp 125 - PhysDevExtTramp 126 - PhysDevExtTramp 127 - PhysDevExtTramp 128 - PhysDevExtTramp 129 - PhysDevExtTramp 130 - PhysDevExtTramp 131 - PhysDevExtTramp 132 - PhysDevExtTramp 133 - PhysDevExtTramp 134 - PhysDevExtTramp 135 - PhysDevExtTramp 136 - PhysDevExtTramp 137 - PhysDevExtTramp 138 - PhysDevExtTramp 139 - PhysDevExtTramp 140 - PhysDevExtTramp 141 - PhysDevExtTramp 142 - PhysDevExtTramp 143 - PhysDevExtTramp 144 - PhysDevExtTramp 145 - PhysDevExtTramp 146 - PhysDevExtTramp 147 - PhysDevExtTramp 148 - PhysDevExtTramp 149 - PhysDevExtTramp 150 - PhysDevExtTramp 151 - PhysDevExtTramp 152 - PhysDevExtTramp 153 - PhysDevExtTramp 154 - PhysDevExtTramp 155 - PhysDevExtTramp 156 - PhysDevExtTramp 157 - PhysDevExtTramp 158 - PhysDevExtTramp 159 - PhysDevExtTramp 160 - PhysDevExtTramp 161 - PhysDevExtTramp 162 - PhysDevExtTramp 163 - PhysDevExtTramp 164 - PhysDevExtTramp 165 - PhysDevExtTramp 166 - PhysDevExtTramp 167 - PhysDevExtTramp 168 - PhysDevExtTramp 169 - PhysDevExtTramp 170 - PhysDevExtTramp 171 - PhysDevExtTramp 172 - PhysDevExtTramp 173 - PhysDevExtTramp 174 - PhysDevExtTramp 175 - PhysDevExtTramp 176 - PhysDevExtTramp 177 - PhysDevExtTramp 178 - PhysDevExtTramp 179 - PhysDevExtTramp 180 - PhysDevExtTramp 181 - PhysDevExtTramp 182 - PhysDevExtTramp 183 - PhysDevExtTramp 184 - PhysDevExtTramp 185 - PhysDevExtTramp 186 - PhysDevExtTramp 187 - PhysDevExtTramp 188 - PhysDevExtTramp 189 - PhysDevExtTramp 190 - PhysDevExtTramp 191 - PhysDevExtTramp 192 - PhysDevExtTramp 193 - PhysDevExtTramp 194 - PhysDevExtTramp 195 - PhysDevExtTramp 196 - PhysDevExtTramp 197 - PhysDevExtTramp 198 - PhysDevExtTramp 199 - PhysDevExtTramp 200 - PhysDevExtTramp 201 - PhysDevExtTramp 202 - PhysDevExtTramp 203 - PhysDevExtTramp 204 - PhysDevExtTramp 205 - PhysDevExtTramp 206 - PhysDevExtTramp 207 - PhysDevExtTramp 208 - PhysDevExtTramp 209 - PhysDevExtTramp 210 - PhysDevExtTramp 211 - PhysDevExtTramp 212 - PhysDevExtTramp 213 - PhysDevExtTramp 214 - PhysDevExtTramp 215 - PhysDevExtTramp 216 - PhysDevExtTramp 217 - PhysDevExtTramp 218 - PhysDevExtTramp 219 - PhysDevExtTramp 220 - PhysDevExtTramp 221 - PhysDevExtTramp 222 - PhysDevExtTramp 223 - PhysDevExtTramp 224 - PhysDevExtTramp 225 - PhysDevExtTramp 226 - PhysDevExtTramp 227 - PhysDevExtTramp 228 - PhysDevExtTramp 229 - PhysDevExtTramp 230 - PhysDevExtTramp 231 - PhysDevExtTramp 232 - PhysDevExtTramp 233 - PhysDevExtTramp 234 - PhysDevExtTramp 235 - PhysDevExtTramp 236 - PhysDevExtTramp 237 - PhysDevExtTramp 238 - PhysDevExtTramp 239 - PhysDevExtTramp 240 - PhysDevExtTramp 241 - PhysDevExtTramp 242 - PhysDevExtTramp 243 - PhysDevExtTramp 244 - PhysDevExtTramp 245 - PhysDevExtTramp 246 - PhysDevExtTramp 247 - PhysDevExtTramp 248 - PhysDevExtTramp 249 - - PhysDevExtTermin 0 - PhysDevExtTermin 1 - PhysDevExtTermin 2 - PhysDevExtTermin 3 - PhysDevExtTermin 4 - PhysDevExtTermin 5 - PhysDevExtTermin 6 - PhysDevExtTermin 7 - PhysDevExtTermin 8 - PhysDevExtTermin 9 - PhysDevExtTermin 10 - PhysDevExtTermin 11 - PhysDevExtTermin 12 - PhysDevExtTermin 13 - PhysDevExtTermin 14 - PhysDevExtTermin 15 - PhysDevExtTermin 16 - PhysDevExtTermin 17 - PhysDevExtTermin 18 - PhysDevExtTermin 19 - PhysDevExtTermin 20 - PhysDevExtTermin 21 - PhysDevExtTermin 22 - PhysDevExtTermin 23 - PhysDevExtTermin 24 - PhysDevExtTermin 25 - PhysDevExtTermin 26 - PhysDevExtTermin 27 - PhysDevExtTermin 28 - PhysDevExtTermin 29 - PhysDevExtTermin 30 - PhysDevExtTermin 31 - PhysDevExtTermin 32 - PhysDevExtTermin 33 - PhysDevExtTermin 34 - PhysDevExtTermin 35 - PhysDevExtTermin 36 - PhysDevExtTermin 37 - PhysDevExtTermin 38 - PhysDevExtTermin 39 - PhysDevExtTermin 40 - PhysDevExtTermin 41 - PhysDevExtTermin 42 - PhysDevExtTermin 43 - PhysDevExtTermin 44 - PhysDevExtTermin 45 - PhysDevExtTermin 46 - PhysDevExtTermin 47 - PhysDevExtTermin 48 - PhysDevExtTermin 49 - PhysDevExtTermin 50 - PhysDevExtTermin 51 - PhysDevExtTermin 52 - PhysDevExtTermin 53 - PhysDevExtTermin 54 - PhysDevExtTermin 55 - PhysDevExtTermin 56 - PhysDevExtTermin 57 - PhysDevExtTermin 58 - PhysDevExtTermin 59 - PhysDevExtTermin 60 - PhysDevExtTermin 61 - PhysDevExtTermin 62 - PhysDevExtTermin 63 - PhysDevExtTermin 64 - PhysDevExtTermin 65 - PhysDevExtTermin 66 - PhysDevExtTermin 67 - PhysDevExtTermin 68 - PhysDevExtTermin 69 - PhysDevExtTermin 70 - PhysDevExtTermin 71 - PhysDevExtTermin 72 - PhysDevExtTermin 73 - PhysDevExtTermin 74 - PhysDevExtTermin 75 - PhysDevExtTermin 76 - PhysDevExtTermin 77 - PhysDevExtTermin 78 - PhysDevExtTermin 79 - PhysDevExtTermin 80 - PhysDevExtTermin 81 - PhysDevExtTermin 82 - PhysDevExtTermin 83 - PhysDevExtTermin 84 - PhysDevExtTermin 85 - PhysDevExtTermin 86 - PhysDevExtTermin 87 - PhysDevExtTermin 88 - PhysDevExtTermin 89 - PhysDevExtTermin 90 - PhysDevExtTermin 91 - PhysDevExtTermin 92 - PhysDevExtTermin 93 - PhysDevExtTermin 94 - PhysDevExtTermin 95 - PhysDevExtTermin 96 - PhysDevExtTermin 97 - PhysDevExtTermin 98 - PhysDevExtTermin 99 - PhysDevExtTermin 100 - PhysDevExtTermin 101 - PhysDevExtTermin 102 - PhysDevExtTermin 103 - PhysDevExtTermin 104 - PhysDevExtTermin 105 - PhysDevExtTermin 106 - PhysDevExtTermin 107 - PhysDevExtTermin 108 - PhysDevExtTermin 109 - PhysDevExtTermin 110 - PhysDevExtTermin 111 - PhysDevExtTermin 112 - PhysDevExtTermin 113 - PhysDevExtTermin 114 - PhysDevExtTermin 115 - PhysDevExtTermin 116 - PhysDevExtTermin 117 - PhysDevExtTermin 118 - PhysDevExtTermin 119 - PhysDevExtTermin 120 - PhysDevExtTermin 121 - PhysDevExtTermin 122 - PhysDevExtTermin 123 - PhysDevExtTermin 124 - PhysDevExtTermin 125 - PhysDevExtTermin 126 - PhysDevExtTermin 127 - PhysDevExtTermin 128 - PhysDevExtTermin 129 - PhysDevExtTermin 130 - PhysDevExtTermin 131 - PhysDevExtTermin 132 - PhysDevExtTermin 133 - PhysDevExtTermin 134 - PhysDevExtTermin 135 - PhysDevExtTermin 136 - PhysDevExtTermin 137 - PhysDevExtTermin 138 - PhysDevExtTermin 139 - PhysDevExtTermin 140 - PhysDevExtTermin 141 - PhysDevExtTermin 142 - PhysDevExtTermin 143 - PhysDevExtTermin 144 - PhysDevExtTermin 145 - PhysDevExtTermin 146 - PhysDevExtTermin 147 - PhysDevExtTermin 148 - PhysDevExtTermin 149 - PhysDevExtTermin 150 - PhysDevExtTermin 151 - PhysDevExtTermin 152 - PhysDevExtTermin 153 - PhysDevExtTermin 154 - PhysDevExtTermin 155 - PhysDevExtTermin 156 - PhysDevExtTermin 157 - PhysDevExtTermin 158 - PhysDevExtTermin 159 - PhysDevExtTermin 160 - PhysDevExtTermin 161 - PhysDevExtTermin 162 - PhysDevExtTermin 163 - PhysDevExtTermin 164 - PhysDevExtTermin 165 - PhysDevExtTermin 166 - PhysDevExtTermin 167 - PhysDevExtTermin 168 - PhysDevExtTermin 169 - PhysDevExtTermin 170 - PhysDevExtTermin 171 - PhysDevExtTermin 172 - PhysDevExtTermin 173 - PhysDevExtTermin 174 - PhysDevExtTermin 175 - PhysDevExtTermin 176 - PhysDevExtTermin 177 - PhysDevExtTermin 178 - PhysDevExtTermin 179 - PhysDevExtTermin 180 - PhysDevExtTermin 181 - PhysDevExtTermin 182 - PhysDevExtTermin 183 - PhysDevExtTermin 184 - PhysDevExtTermin 185 - PhysDevExtTermin 186 - PhysDevExtTermin 187 - PhysDevExtTermin 188 - PhysDevExtTermin 189 - PhysDevExtTermin 190 - PhysDevExtTermin 191 - PhysDevExtTermin 192 - PhysDevExtTermin 193 - PhysDevExtTermin 194 - PhysDevExtTermin 195 - PhysDevExtTermin 196 - PhysDevExtTermin 197 - PhysDevExtTermin 198 - PhysDevExtTermin 199 - PhysDevExtTermin 200 - PhysDevExtTermin 201 - PhysDevExtTermin 202 - PhysDevExtTermin 203 - PhysDevExtTermin 204 - PhysDevExtTermin 205 - PhysDevExtTermin 206 - PhysDevExtTermin 207 - PhysDevExtTermin 208 - PhysDevExtTermin 209 - PhysDevExtTermin 210 - PhysDevExtTermin 211 - PhysDevExtTermin 212 - PhysDevExtTermin 213 - PhysDevExtTermin 214 - PhysDevExtTermin 215 - PhysDevExtTermin 216 - PhysDevExtTermin 217 - PhysDevExtTermin 218 - PhysDevExtTermin 219 - PhysDevExtTermin 220 - PhysDevExtTermin 221 - PhysDevExtTermin 222 - PhysDevExtTermin 223 - PhysDevExtTermin 224 - PhysDevExtTermin 225 - PhysDevExtTermin 226 - PhysDevExtTermin 227 - PhysDevExtTermin 228 - PhysDevExtTermin 229 - PhysDevExtTermin 230 - PhysDevExtTermin 231 - PhysDevExtTermin 232 - PhysDevExtTermin 233 - PhysDevExtTermin 234 - PhysDevExtTermin 235 - PhysDevExtTermin 236 - PhysDevExtTermin 237 - PhysDevExtTermin 238 - PhysDevExtTermin 239 - PhysDevExtTermin 240 - PhysDevExtTermin 241 - PhysDevExtTermin 242 - PhysDevExtTermin 243 - PhysDevExtTermin 244 - PhysDevExtTermin 245 - PhysDevExtTermin 246 - PhysDevExtTermin 247 - PhysDevExtTermin 248 - PhysDevExtTermin 249 - - DevExtTramp 0 - DevExtTramp 1 - DevExtTramp 2 - DevExtTramp 3 - DevExtTramp 4 - DevExtTramp 5 - DevExtTramp 6 - DevExtTramp 7 - DevExtTramp 8 - DevExtTramp 9 - DevExtTramp 10 - DevExtTramp 11 - DevExtTramp 12 - DevExtTramp 13 - DevExtTramp 14 - DevExtTramp 15 - DevExtTramp 16 - DevExtTramp 17 - DevExtTramp 18 - DevExtTramp 19 - DevExtTramp 20 - DevExtTramp 21 - DevExtTramp 22 - DevExtTramp 23 - DevExtTramp 24 - DevExtTramp 25 - DevExtTramp 26 - DevExtTramp 27 - DevExtTramp 28 - DevExtTramp 29 - DevExtTramp 30 - DevExtTramp 31 - DevExtTramp 32 - DevExtTramp 33 - DevExtTramp 34 - DevExtTramp 35 - DevExtTramp 36 - DevExtTramp 37 - DevExtTramp 38 - DevExtTramp 39 - DevExtTramp 40 - DevExtTramp 41 - DevExtTramp 42 - DevExtTramp 43 - DevExtTramp 44 - DevExtTramp 45 - DevExtTramp 46 - DevExtTramp 47 - DevExtTramp 48 - DevExtTramp 49 - DevExtTramp 50 - DevExtTramp 51 - DevExtTramp 52 - DevExtTramp 53 - DevExtTramp 54 - DevExtTramp 55 - DevExtTramp 56 - DevExtTramp 57 - DevExtTramp 58 - DevExtTramp 59 - DevExtTramp 60 - DevExtTramp 61 - DevExtTramp 62 - DevExtTramp 63 - DevExtTramp 64 - DevExtTramp 65 - DevExtTramp 66 - DevExtTramp 67 - DevExtTramp 68 - DevExtTramp 69 - DevExtTramp 70 - DevExtTramp 71 - DevExtTramp 72 - DevExtTramp 73 - DevExtTramp 74 - DevExtTramp 75 - DevExtTramp 76 - DevExtTramp 77 - DevExtTramp 78 - DevExtTramp 79 - DevExtTramp 80 - DevExtTramp 81 - DevExtTramp 82 - DevExtTramp 83 - DevExtTramp 84 - DevExtTramp 85 - DevExtTramp 86 - DevExtTramp 87 - DevExtTramp 88 - DevExtTramp 89 - DevExtTramp 90 - DevExtTramp 91 - DevExtTramp 92 - DevExtTramp 93 - DevExtTramp 94 - DevExtTramp 95 - DevExtTramp 96 - DevExtTramp 97 - DevExtTramp 98 - DevExtTramp 99 - DevExtTramp 100 - DevExtTramp 101 - DevExtTramp 102 - DevExtTramp 103 - DevExtTramp 104 - DevExtTramp 105 - DevExtTramp 106 - DevExtTramp 107 - DevExtTramp 108 - DevExtTramp 109 - DevExtTramp 110 - DevExtTramp 111 - DevExtTramp 112 - DevExtTramp 113 - DevExtTramp 114 - DevExtTramp 115 - DevExtTramp 116 - DevExtTramp 117 - DevExtTramp 118 - DevExtTramp 119 - DevExtTramp 120 - DevExtTramp 121 - DevExtTramp 122 - DevExtTramp 123 - DevExtTramp 124 - DevExtTramp 125 - DevExtTramp 126 - DevExtTramp 127 - DevExtTramp 128 - DevExtTramp 129 - DevExtTramp 130 - DevExtTramp 131 - DevExtTramp 132 - DevExtTramp 133 - DevExtTramp 134 - DevExtTramp 135 - DevExtTramp 136 - DevExtTramp 137 - DevExtTramp 138 - DevExtTramp 139 - DevExtTramp 140 - DevExtTramp 141 - DevExtTramp 142 - DevExtTramp 143 - DevExtTramp 144 - DevExtTramp 145 - DevExtTramp 146 - DevExtTramp 147 - DevExtTramp 148 - DevExtTramp 149 - DevExtTramp 150 - DevExtTramp 151 - DevExtTramp 152 - DevExtTramp 153 - DevExtTramp 154 - DevExtTramp 155 - DevExtTramp 156 - DevExtTramp 157 - DevExtTramp 158 - DevExtTramp 159 - DevExtTramp 160 - DevExtTramp 161 - DevExtTramp 162 - DevExtTramp 163 - DevExtTramp 164 - DevExtTramp 165 - DevExtTramp 166 - DevExtTramp 167 - DevExtTramp 168 - DevExtTramp 169 - DevExtTramp 170 - DevExtTramp 171 - DevExtTramp 172 - DevExtTramp 173 - DevExtTramp 174 - DevExtTramp 175 - DevExtTramp 176 - DevExtTramp 177 - DevExtTramp 178 - DevExtTramp 179 - DevExtTramp 180 - DevExtTramp 181 - DevExtTramp 182 - DevExtTramp 183 - DevExtTramp 184 - DevExtTramp 185 - DevExtTramp 186 - DevExtTramp 187 - DevExtTramp 188 - DevExtTramp 189 - DevExtTramp 190 - DevExtTramp 191 - DevExtTramp 192 - DevExtTramp 193 - DevExtTramp 194 - DevExtTramp 195 - DevExtTramp 196 - DevExtTramp 197 - DevExtTramp 198 - DevExtTramp 199 - DevExtTramp 200 - DevExtTramp 201 - DevExtTramp 202 - DevExtTramp 203 - DevExtTramp 204 - DevExtTramp 205 - DevExtTramp 206 - DevExtTramp 207 - DevExtTramp 208 - DevExtTramp 209 - DevExtTramp 210 - DevExtTramp 211 - DevExtTramp 212 - DevExtTramp 213 - DevExtTramp 214 - DevExtTramp 215 - DevExtTramp 216 - DevExtTramp 217 - DevExtTramp 218 - DevExtTramp 219 - DevExtTramp 220 - DevExtTramp 221 - DevExtTramp 222 - DevExtTramp 223 - DevExtTramp 224 - DevExtTramp 225 - DevExtTramp 226 - DevExtTramp 227 - DevExtTramp 228 - DevExtTramp 229 - DevExtTramp 230 - DevExtTramp 231 - DevExtTramp 232 - DevExtTramp 233 - DevExtTramp 234 - DevExtTramp 235 - DevExtTramp 236 - DevExtTramp 237 - DevExtTramp 238 - DevExtTramp 239 - DevExtTramp 240 - DevExtTramp 241 - DevExtTramp 242 - DevExtTramp 243 - DevExtTramp 244 - DevExtTramp 245 - DevExtTramp 246 - DevExtTramp 247 - DevExtTramp 248 - DevExtTramp 249 - -end diff --git a/loader/vk_loader_layer.h b/loader/vk_loader_layer.h deleted file mode 100644 index dfcf5b2a..00000000 --- a/loader/vk_loader_layer.h +++ /dev/null @@ -1,46 +0,0 @@ -/* -* -* Copyright (c) 2016 The Khronos Group Inc. -* Copyright (c) 2016 Valve Corporation -* Copyright (c) 2016 LunarG, Inc. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -* -* Author: Mark Lobodzinski -* -*/ -#pragma once - -// Linked list node for tree of debug callbacks -typedef struct VkDebugReportContent { - VkDebugReportCallbackEXT msgCallback; - PFN_vkDebugReportCallbackEXT pfnMsgCallback; - VkFlags msgFlags; -} VkDebugReportContent; - -typedef struct VkDebugUtilsMessengerContent { - VkDebugUtilsMessengerEXT messenger; - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; - VkDebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; -} VkDebugUtilsMessengerContent; - -typedef struct VkLayerDbgFunctionNode_ { - bool is_messenger; - union { - VkDebugReportContent report; - VkDebugUtilsMessengerContent messenger; - }; - void *pUserData; - struct VkLayerDbgFunctionNode_ *pNext; -} VkLayerDbgFunctionNode; diff --git a/loader/vk_loader_platform.h b/loader/vk_loader_platform.h deleted file mode 100644 index 41625602..00000000 --- a/loader/vk_loader_platform.h +++ /dev/null @@ -1,367 +0,0 @@ -/* - * - * Copyright (c) 2015-2018 The Khronos Group Inc. - * Copyright (c) 2015-2018 Valve Corporation - * Copyright (c) 2015-2018 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Ian Elliot - * Author: Jon Ashburn - * Author: Lenny Komow - * - */ -#pragma once - -#if defined(_WIN32) -// WinSock2.h must be included *BEFORE* windows.h -#include -#endif // _WIN32 - -#include "vulkan/vk_platform.h" -#include "vulkan/vk_sdk_platform.h" - -#if defined(__linux__) || defined(__APPLE__) -/* Linux-specific common code: */ - -// Headers: -//#define _GNU_SOURCE 1 -// TBD: Are the contents of the following file used? -#include -// Note: The following file is for dynamic loading: -#include -#include -#include -#include -#include -#include -#include - -// VK Library Filenames, Paths, etc.: -#define PATH_SEPARATOR ':' -#define DIRECTORY_SYMBOL '/' - -#define VULKAN_DIR "/vulkan/" -#define VULKAN_ICDCONF_DIR "icd.d" -#define VULKAN_ICD_DIR "icd" -#define VULKAN_ELAYERCONF_DIR "explicit_layer.d" -#define VULKAN_ILAYERCONF_DIR "implicit_layer.d" -#define VULKAN_LAYER_DIR "layer" - -#define DEFAULT_VK_DRIVERS_INFO "" -#define DEFAULT_VK_ELAYERS_INFO "" -#define DEFAULT_VK_ILAYERS_INFO "" - -#define DEFAULT_VK_DRIVERS_PATH "" -#if !defined(DEFAULT_VK_LAYERS_PATH) -#define DEFAULT_VK_LAYERS_PATH "" -#endif - -#if !defined(LAYERS_SOURCE_PATH) -#define LAYERS_SOURCE_PATH NULL -#endif -#define LAYERS_PATH_ENV "VK_LAYER_PATH" -#define ENABLED_LAYERS_ENV "VK_INSTANCE_LAYERS" - -#define RELATIVE_VK_DRIVERS_INFO VULKAN_DIR VULKAN_ICDCONF_DIR -#define RELATIVE_VK_ELAYERS_INFO VULKAN_DIR VULKAN_ELAYERCONF_DIR -#define RELATIVE_VK_ILAYERS_INFO VULKAN_DIR VULKAN_ILAYERCONF_DIR - -// C99: -#define PRINTF_SIZE_T_SPECIFIER "%zu" - -// File IO -static inline bool loader_platform_file_exists(const char *path) { - if (access(path, F_OK)) - return false; - else - return true; -} - -static inline bool loader_platform_is_path_absolute(const char *path) { - if (path[0] == '/') - return true; - else - return false; -} - -static inline char *loader_platform_dirname(char *path) { return dirname(path); } - -// Dynamic Loading of libraries: -typedef void *loader_platform_dl_handle; -static inline loader_platform_dl_handle loader_platform_open_library(const char *libPath) { - // When loading the library, we use RTLD_LAZY so that not all symbols have to be - // resolved at this time (which improves performance). Note that if not all symbols - // can be resolved, this could cause crashes later. Use the LD_BIND_NOW environment - // variable to force all symbols to be resolved here. - return dlopen(libPath, RTLD_LAZY | RTLD_LOCAL); -} -static inline const char *loader_platform_open_library_error(const char *libPath) { return dlerror(); } -static inline void loader_platform_close_library(loader_platform_dl_handle library) { dlclose(library); } -static inline void *loader_platform_get_proc_address(loader_platform_dl_handle library, const char *name) { - assert(library); - assert(name); - return dlsym(library, name); -} -static inline const char *loader_platform_get_proc_address_error(const char *name) { return dlerror(); } - -// Threads: -typedef pthread_t loader_platform_thread; -#define THREAD_LOCAL_DECL __thread - -// The once init functionality is not used on Linux -#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) -#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) -#define LOADER_PLATFORM_THREAD_ONCE(ctl, func) - -// Thread IDs: -typedef pthread_t loader_platform_thread_id; -static inline loader_platform_thread_id loader_platform_get_thread_id() { return pthread_self(); } - -// Thread mutex: -typedef pthread_mutex_t loader_platform_thread_mutex; -static inline void loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_init(pMutex, NULL); } -static inline void loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_lock(pMutex); } -static inline void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_unlock(pMutex); } -static inline void loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_destroy(pMutex); } -typedef pthread_cond_t loader_platform_thread_cond; -static inline void loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) { pthread_cond_init(pCond, NULL); } -static inline void loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond, loader_platform_thread_mutex *pMutex) { - pthread_cond_wait(pCond, pMutex); -} -static inline void loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) { pthread_cond_broadcast(pCond); } - -#define loader_stack_alloc(size) alloca(size) - -#elif defined(_WIN32) // defined(__linux__) -/* Windows-specific common code: */ -// WinBase.h defines CreateSemaphore and synchapi.h defines CreateEvent -// undefine them to avoid conflicts with VkLayerDispatchTable struct members. -#ifdef CreateSemaphore -#undef CreateSemaphore -#endif -#ifdef CreateEvent -#undef CreateEvent -#endif -#include -#include -#include -#include -#include -#include -#ifdef __cplusplus -#include -#include -#endif // __cplusplus - -// VK Library Filenames, Paths, etc.: -#define PATH_SEPARATOR ';' -#define DIRECTORY_SYMBOL '\\' -#define DEFAULT_VK_REGISTRY_HIVE HKEY_LOCAL_MACHINE -#define DEFAULT_VK_REGISTRY_HIVE_STR "HKEY_LOCAL_MACHINE" -#define SECONDARY_VK_REGISTRY_HIVE HKEY_CURRENT_USER -#define SECONDARY_VK_REGISTRY_HIVE_STR "HKEY_CURRENT_USER" -#define DEFAULT_VK_DRIVERS_INFO "SOFTWARE\\Khronos\\" API_NAME "\\Drivers" -#define DEFAULT_VK_DRIVERS_PATH "" -#define DEFAULT_VK_ELAYERS_INFO "SOFTWARE\\Khronos\\" API_NAME "\\ExplicitLayers" -#define DEFAULT_VK_ILAYERS_INFO "SOFTWARE\\Khronos\\" API_NAME "\\ImplicitLayers" -#if !defined(DEFAULT_VK_LAYERS_PATH) -#define DEFAULT_VK_LAYERS_PATH "" -#endif -#if !defined(LAYERS_SOURCE_PATH) -#define LAYERS_SOURCE_PATH NULL -#endif -#define LAYERS_PATH_ENV "VK_LAYER_PATH" -#define ENABLED_LAYERS_ENV "VK_INSTANCE_LAYERS" -#define RELATIVE_VK_DRIVERS_INFO "" -#define RELATIVE_VK_ELAYERS_INFO "" -#define RELATIVE_VK_ILAYERS_INFO "" -#define PRINTF_SIZE_T_SPECIFIER "%Iu" - -#if defined(_WIN32) -// Get the key for the plug n play driver registry -// The string returned by this function should NOT be freed -static inline const char *LoaderPnpDriverRegistry() { - BOOL is_wow; - IsWow64Process(GetCurrentProcess(), &is_wow); - return is_wow ? (API_NAME "DriverNameWow") : (API_NAME "DriverName"); -} - -// Get the key for the plug 'n play explicit layer registry -// The string returned by this function should NOT be freed -static inline const char *LoaderPnpELayerRegistry() { - BOOL is_wow; - IsWow64Process(GetCurrentProcess(), &is_wow); - return is_wow ? (API_NAME "ExplicitLayersWow") : (API_NAME "ExplicitLayers"); -} -// Get the key for the plug 'n play implicit layer registry -// The string returned by this function should NOT be freed - -static inline const char *LoaderPnpILayerRegistry() { - BOOL is_wow; - IsWow64Process(GetCurrentProcess(), &is_wow); - return is_wow ? (API_NAME "ImplicitLayersWow") : (API_NAME "ImplicitLayers"); -} -#endif - -// File IO -static bool loader_platform_file_exists(const char *path) { - if ((_access(path, 0)) == -1) - return false; - else - return true; -} - -static bool loader_platform_is_path_absolute(const char *path) { - if (!path || !*path) { - return false; - } - if (*path == DIRECTORY_SYMBOL || path[1] == ':') { - return true; - } - return false; -} - -// WIN32 runtime doesn't have dirname(). -static inline char *loader_platform_dirname(char *path) { - char *current, *next; - - // TODO/TBD: Do we need to deal with the Windows's ":" character? - - for (current = path; *current != '\0'; current = next) { - next = strchr(current, DIRECTORY_SYMBOL); - if (next == NULL) { - if (current != path) *(current - 1) = '\0'; - return path; - } else { - // Point one character past the DIRECTORY_SYMBOL: - next++; - } - } - return path; -} - -// WIN32 runtime doesn't have basename(). -// Microsoft also doesn't have basename(). Paths are different on Windows, and -// so this is just a temporary solution in order to get us compiling, so that we -// can test some scenarios, and develop the correct solution for Windows. -// TODO: Develop a better, permanent solution for Windows, to replace this -// temporary code: -static char *loader_platform_basename(char *pathname) { - char *current, *next; - - // TODO/TBD: Do we need to deal with the Windows's ":" character? - - for (current = pathname; *current != '\0'; current = next) { - next = strchr(current, DIRECTORY_SYMBOL); - if (next == NULL) { - // No more DIRECTORY_SYMBOL's so return p: - return current; - } else { - // Point one character past the DIRECTORY_SYMBOL: - next++; - } - } - // We shouldn't get to here, but this makes the compiler happy: - return current; -} - -// Dynamic Loading: -typedef HMODULE loader_platform_dl_handle; -static loader_platform_dl_handle loader_platform_open_library(const char *lib_path) { - // Try loading the library the original way first. - loader_platform_dl_handle lib_handle = LoadLibrary(lib_path); - if (lib_handle == NULL && GetLastError() == ERROR_MOD_NOT_FOUND) { - // If that failed, then try loading it with broader search folders. - lib_handle = LoadLibraryEx(lib_path, NULL, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR); - } - return lib_handle; -} -static char *loader_platform_open_library_error(const char *libPath) { - static char errorMsg[164]; - (void)snprintf(errorMsg, 163, "Failed to open dynamic library \"%s\" with error %lu", libPath, GetLastError()); - return errorMsg; -} -static void loader_platform_close_library(loader_platform_dl_handle library) { FreeLibrary(library); } -static void *loader_platform_get_proc_address(loader_platform_dl_handle library, const char *name) { - assert(library); - assert(name); - return (void *)GetProcAddress(library, name); -} -static char *loader_platform_get_proc_address_error(const char *name) { - static char errorMsg[120]; - (void)snprintf(errorMsg, 119, "Failed to find function \"%s\" in dynamic library", name); - return errorMsg; -} - -// Threads: -typedef HANDLE loader_platform_thread; -#define THREAD_LOCAL_DECL __declspec(thread) - -// The once init functionality is not used when building a DLL on Windows. This is because there is no way to clean up the -// resources allocated by anything allocated by once init. This isn't a problem for static libraries, but it is for dynamic -// ones. When building a DLL, we use DllMain() instead to allow properly cleaning up resources. -#if defined(LOADER_DYNAMIC_LIB) -#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) -#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) -#define LOADER_PLATFORM_THREAD_ONCE(ctl, func) -#else -#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) INIT_ONCE var = INIT_ONCE_STATIC_INIT; -#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) INIT_ONCE var; -#define LOADER_PLATFORM_THREAD_ONCE(ctl, func) loader_platform_thread_once_fn(ctl, func) -static BOOL CALLBACK InitFuncWrapper(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *Context) { - void (*func)(void) = (void (*)(void))Parameter; - func(); - return TRUE; -} -static void loader_platform_thread_once_fn(void *ctl, void (*func)(void)) { - assert(func != NULL); - assert(ctl != NULL); - InitOnceExecuteOnce((PINIT_ONCE)ctl, InitFuncWrapper, (void *)func, NULL); -} -#endif - -// Thread IDs: -typedef DWORD loader_platform_thread_id; -static loader_platform_thread_id loader_platform_get_thread_id() { return GetCurrentThreadId(); } - -// Thread mutex: -typedef CRITICAL_SECTION loader_platform_thread_mutex; -static void loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) { InitializeCriticalSection(pMutex); } -static void loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) { EnterCriticalSection(pMutex); } -static void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) { LeaveCriticalSection(pMutex); } -static void loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) { DeleteCriticalSection(pMutex); } -typedef CONDITION_VARIABLE loader_platform_thread_cond; -static void loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) { InitializeConditionVariable(pCond); } -static void loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond, loader_platform_thread_mutex *pMutex) { - SleepConditionVariableCS(pCond, pMutex, INFINITE); -} -static void loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) { WakeAllConditionVariable(pCond); } - -#define loader_stack_alloc(size) _alloca(size) -#else // defined(_WIN32) - -#error The "loader_platform.h" file must be modified for this OS. - -// NOTE: In order to support another OS, an #elif needs to be added (above the -// "#else // defined(_WIN32)") for that OS, and OS-specific versions of the -// contents of this file must be created. - -// NOTE: Other OS-specific changes are also needed for this OS. Search for -// files with "WIN32" in it, as a quick way to find files that must be changed. - -#endif // defined(_WIN32) - -// returns true if the given string appears to be a relative or absolute -// path, as opposed to a bare filename. -static inline bool loader_platform_is_path(const char *path) { return strchr(path, DIRECTORY_SYMBOL) != NULL; } diff --git a/loader/vulkan-1.def b/loader/vulkan-1.def deleted file mode 100644 index 8c4d4faa..00000000 --- a/loader/vulkan-1.def +++ /dev/null @@ -1,213 +0,0 @@ - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; -; Copyright (c) 2015-2017 The Khronos Group Inc. -; Copyright (c) 2015-2017 Valve Corporation -; Copyright (c) 2015-2017 LunarG, Inc. -; -; Licensed under the Apache License, Version 2.0 (the "License"); -; you may not use this file except in compliance with the License. -; You may obtain a copy of the License at -; -; http://www.apache.org/licenses/LICENSE-2.0 -; -; Unless required by applicable law or agreed to in writing, software -; distributed under the License is distributed on an "AS IS" BASIS, -; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -; See the License for the specific language governing permissions and -; limitations under the License. -; -; Author: Courtney Goeltzenleuchter -; -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -LIBRARY vulkan-1.dll -EXPORTS - vkCreateInstance - vkDestroyInstance - vkEnumeratePhysicalDevices - vkGetPhysicalDeviceFeatures - vkGetPhysicalDeviceFormatProperties - vkGetPhysicalDeviceImageFormatProperties - vkGetPhysicalDeviceProperties - vkGetPhysicalDeviceQueueFamilyProperties - vkGetPhysicalDeviceMemoryProperties - vkGetInstanceProcAddr - vkGetDeviceProcAddr - vkCreateDevice - vkDestroyDevice - vkEnumerateInstanceExtensionProperties - vkEnumerateDeviceExtensionProperties - vkEnumerateInstanceLayerProperties - vkEnumerateDeviceLayerProperties - vkGetDeviceQueue - vkQueueSubmit - vkQueueWaitIdle - vkDeviceWaitIdle - vkAllocateMemory - vkFreeMemory - vkMapMemory - vkUnmapMemory - vkFlushMappedMemoryRanges - vkInvalidateMappedMemoryRanges - vkGetDeviceMemoryCommitment - vkBindBufferMemory - vkBindImageMemory - vkGetBufferMemoryRequirements - vkGetImageMemoryRequirements - vkGetImageSparseMemoryRequirements - vkGetPhysicalDeviceSparseImageFormatProperties - vkQueueBindSparse - vkCreateFence - vkDestroyFence - vkResetFences - vkGetFenceStatus - vkWaitForFences - vkCreateSemaphore - vkDestroySemaphore - vkCreateEvent - vkDestroyEvent - vkGetEventStatus - vkSetEvent - vkResetEvent - vkCreateQueryPool - vkDestroyQueryPool - vkGetQueryPoolResults - vkCreateBuffer - vkDestroyBuffer - vkCreateBufferView - vkDestroyBufferView - vkCreateImage - vkDestroyImage - vkGetImageSubresourceLayout - vkCreateImageView - vkDestroyImageView - vkCreateShaderModule - vkDestroyShaderModule - vkCreatePipelineCache - vkDestroyPipelineCache - vkGetPipelineCacheData - vkMergePipelineCaches - vkCreateGraphicsPipelines - vkCreateComputePipelines - vkDestroyPipeline - vkCreatePipelineLayout - vkDestroyPipelineLayout - vkCreateSampler - vkDestroySampler - vkCreateDescriptorSetLayout - vkDestroyDescriptorSetLayout - vkCreateDescriptorPool - vkDestroyDescriptorPool - vkResetDescriptorPool - vkAllocateDescriptorSets - vkFreeDescriptorSets - vkUpdateDescriptorSets - vkCreateFramebuffer - vkDestroyFramebuffer - vkCreateRenderPass - vkDestroyRenderPass - vkGetRenderAreaGranularity - vkCreateCommandPool - vkDestroyCommandPool - vkResetCommandPool - vkAllocateCommandBuffers - vkFreeCommandBuffers - vkBeginCommandBuffer - vkEndCommandBuffer - vkResetCommandBuffer - vkCmdBindPipeline - vkCmdSetViewport - vkCmdSetScissor - vkCmdSetLineWidth - vkCmdSetDepthBias - vkCmdSetBlendConstants - vkCmdSetDepthBounds - vkCmdSetStencilCompareMask - vkCmdSetStencilWriteMask - vkCmdSetStencilReference - vkCmdBindDescriptorSets - vkCmdBindIndexBuffer - vkCmdBindVertexBuffers - vkCmdDraw - vkCmdDrawIndexed - vkCmdDrawIndirect - vkCmdDrawIndexedIndirect - vkCmdDispatch - vkCmdDispatchIndirect - vkCmdCopyBuffer - vkCmdCopyImage - vkCmdBlitImage - vkCmdCopyBufferToImage - vkCmdCopyImageToBuffer - vkCmdUpdateBuffer - vkCmdFillBuffer - vkCmdClearColorImage - vkCmdClearDepthStencilImage - vkCmdClearAttachments - vkCmdResolveImage - vkCmdSetEvent - vkCmdResetEvent - vkCmdWaitEvents - vkCmdPipelineBarrier - vkCmdBeginQuery - vkCmdEndQuery - vkCmdResetQueryPool - vkCmdWriteTimestamp - vkCmdCopyQueryPoolResults - vkCmdPushConstants - vkCmdBeginRenderPass - vkCmdNextSubpass - vkCmdEndRenderPass - vkCmdExecuteCommands - vkDestroySurfaceKHR - vkGetPhysicalDeviceSurfaceSupportKHR - vkGetPhysicalDeviceSurfaceCapabilitiesKHR - vkGetPhysicalDeviceSurfaceFormatsKHR - vkGetPhysicalDeviceSurfacePresentModesKHR - vkCreateSwapchainKHR - vkDestroySwapchainKHR - vkGetSwapchainImagesKHR - vkAcquireNextImageKHR - vkQueuePresentKHR - vkGetPhysicalDeviceDisplayPropertiesKHR - vkGetPhysicalDeviceDisplayPlanePropertiesKHR - vkGetDisplayPlaneSupportedDisplaysKHR - vkGetDisplayModePropertiesKHR - vkCreateDisplayModeKHR - vkGetDisplayPlaneCapabilitiesKHR - vkCreateDisplayPlaneSurfaceKHR - vkCreateSharedSwapchainsKHR - vkCreateWin32SurfaceKHR - vkGetPhysicalDeviceWin32PresentationSupportKHR - - vkEnumerateInstanceVersion - vkEnumeratePhysicalDeviceGroups - vkGetPhysicalDeviceFeatures2 - vkGetPhysicalDeviceProperties2 - vkGetPhysicalDeviceFormatProperties2 - vkGetPhysicalDeviceQueueFamilyProperties2 - vkGetPhysicalDeviceMemoryProperties2 - vkGetPhysicalDeviceSparseImageFormatProperties2 - vkGetPhysicalDeviceExternalBufferProperties - vkGetPhysicalDeviceExternalSemaphoreProperties - vkGetPhysicalDeviceExternalFenceProperties - vkBindBufferMemory2 - vkBindImageMemory2 - vkGetDeviceGroupPeerMemoryFeatures - vkCmdSetDeviceMask - vkCmdDispatchBase - vkGetImageMemoryRequirements2 - vkGetBufferMemoryRequirements2 - vkTrimCommandPool - vkGetDeviceQueue2 - vkCreateSamplerYcbcrConversion - vkDestroySamplerYcbcrConversion - vkGetDescriptorSetLayoutSupport - vkGetDeviceGroupPresentCapabilitiesKHR - vkGetDeviceGroupSurfacePresentModesKHR - vkGetPhysicalDevicePresentRectanglesKHR - vkAcquireNextImage2KHR - vkCreateDescriptorUpdateTemplate - vkDestroyDescriptorUpdateTemplate - vkUpdateDescriptorSetWithTemplate diff --git a/loader/vulkan.pc.in b/loader/vulkan.pc.in deleted file mode 100644 index 2ce5aea4..00000000 --- a/loader/vulkan.pc.in +++ /dev/null @@ -1,12 +0,0 @@ -prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=@CMAKE_INSTALL_PREFIX@ -libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@ -includedir=${prefix}/include - -Name: @CMAKE_PROJECT_NAME@ -Description: Vulkan Loader -Version: @VK_API_VERSION@ -Libs: -L${libdir} -lvulkan -Libs.private: @PRIVATE_LIBS@ -Cflags: -I${includedir} - diff --git a/loader/wsi.c b/loader/wsi.c deleted file mode 100644 index e822fe7a..00000000 --- a/loader/wsi.c +++ /dev/null @@ -1,1791 +0,0 @@ -/* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Ian Elliott - * Author: Jon Ashburn - * Author: Ian Elliott - * Author: Mark Lobodzinski - */ - -#define _GNU_SOURCE -#include -#include -#include -#include "vk_loader_platform.h" -#include "loader.h" -#include "wsi.h" -#include - -// The first ICD/Loader interface that support querying the SurfaceKHR from -// the ICDs. -#define ICD_VER_SUPPORTS_ICD_SURFACE_KHR 3 - -void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) { - ptr_instance->wsi_surface_enabled = false; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - ptr_instance->wsi_win32_surface_enabled = false; -#endif // VK_USE_PLATFORM_WIN32_KHR -#ifdef VK_USE_PLATFORM_MIR_KHR - ptr_instance->wsi_mir_surface_enabled = false; -#endif // VK_USE_PLATFORM_MIR_KHR -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - ptr_instance->wsi_wayland_surface_enabled = false; -#endif // VK_USE_PLATFORM_WAYLAND_KHR -#ifdef VK_USE_PLATFORM_XCB_KHR - ptr_instance->wsi_xcb_surface_enabled = false; -#endif // VK_USE_PLATFORM_XCB_KHR -#ifdef VK_USE_PLATFORM_XLIB_KHR - ptr_instance->wsi_xlib_surface_enabled = false; -#endif // VK_USE_PLATFORM_XLIB_KHR -#ifdef VK_USE_PLATFORM_ANDROID_KHR - ptr_instance->wsi_android_surface_enabled = false; -#endif // VK_USE_PLATFORM_ANDROID_KHR -#ifdef VK_USE_PLATFORM_MACOS_MVK - ptr_instance->wsi_macos_surface_enabled = false; -#endif // VK_USE_PLATFORM_MACOS_MVK -#ifdef VK_USE_PLATFORM_IOS_MVK - ptr_instance->wsi_ios_surface_enabled = false; -#endif // VK_USE_PLATFORM_IOS_MVK - - ptr_instance->wsi_display_enabled = false; - - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_surface_enabled = true; - continue; - } -#ifdef VK_USE_PLATFORM_WIN32_KHR - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_win32_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_WIN32_KHR -#ifdef VK_USE_PLATFORM_MIR_KHR - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_mir_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_MIR_KHR -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_wayland_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_WAYLAND_KHR -#ifdef VK_USE_PLATFORM_XCB_KHR - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_xcb_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_XCB_KHR -#ifdef VK_USE_PLATFORM_XLIB_KHR - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_xlib_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_XLIB_KHR -#ifdef VK_USE_PLATFORM_ANDROID_KHR - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_android_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_ANDROID_KHR -#ifdef VK_USE_PLATFORM_MACOS_MVK - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_MVK_MACOS_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_macos_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_MACOS_MVK -#ifdef VK_USE_PLATFORM_IOS_MVK - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_MVK_IOS_SURFACE_EXTENSION_NAME) == 0) { - ptr_instance->wsi_ios_surface_enabled = true; - continue; - } -#endif // VK_USE_PLATFORM_IOS_MVK - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) { - ptr_instance->wsi_display_enabled = true; - continue; - } - } -} - -// Linux WSI surface extensions are not always compiled into the loader. (Assume -// for Windows the KHR_win32_surface is always compiled into loader). A given -// Linux build environment might not have the headers required for building one -// of the four extensions (Xlib, Xcb, Mir, Wayland). Thus, need to check if -// the built loader actually supports the particular Linux surface extension. -// If not supported by the built loader it will not be included in the list of -// enumerated instance extensions. This solves the issue where an ICD or layer -// advertises support for a given Linux surface extension but the loader was not -// built to support the extension. -bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop) { -#ifndef VK_USE_PLATFORM_MIR_KHR - if (!strcmp(ext_prop->extensionName, "VK_KHR_mir_surface")) return true; -#endif // VK_USE_PLATFORM_MIR_KHR -#ifndef VK_USE_PLATFORM_WAYLAND_KHR - if (!strcmp(ext_prop->extensionName, "VK_KHR_wayland_surface")) return true; -#endif // VK_USE_PLATFORM_WAYLAND_KHR -#ifndef VK_USE_PLATFORM_XCB_KHR - if (!strcmp(ext_prop->extensionName, "VK_KHR_xcb_surface")) return true; -#endif // VK_USE_PLATFORM_XCB_KHR -#ifndef VK_USE_PLATFORM_XLIB_KHR - if (!strcmp(ext_prop->extensionName, "VK_KHR_xlib_surface")) return true; -#endif // VK_USE_PLATFORM_XLIB_KHR - - return false; -} - -// Functions for the VK_KHR_surface extension: - -// This is the trampoline entrypoint for DestroySurfaceKHR -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, - const VkAllocationCallbacks *pAllocator) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - disp->DestroySurfaceKHR(instance, surface, pAllocator); -} - -// TODO probably need to lock around all the loader_get_instance() calls. - -// This is the instance chain terminator function for DestroySurfaceKHR -VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, - const VkAllocationCallbacks *pAllocator) { - struct loader_instance *ptr_instance = loader_get_instance(instance); - - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface; - if (NULL != icd_surface) { - if (NULL != icd_surface->real_icd_surfaces) { - uint32_t i = 0; - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.DestroySurfaceKHR && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[i]) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, icd_surface->real_icd_surfaces[i], pAllocator); - icd_surface->real_icd_surfaces[i] = (VkSurfaceKHR)NULL; - } - } else { - // The real_icd_surface for any ICD not supporting the - // proper interface version should be NULL. If not, then - // we have a problem. - assert((VkSurfaceKHR)NULL == icd_surface->real_icd_surfaces[i]); - } - } - loader_instance_heap_free(ptr_instance, icd_surface->real_icd_surfaces); - } - - loader_instance_heap_free(ptr_instance, (void *)(uintptr_t)surface); - } -} - -// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceSupportKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, VkSurfaceKHR surface, - VkBool32 *pSupported) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetPhysicalDeviceSurfaceSupportKHR(unwrapped_phys_dev, queueFamilyIndex, surface, pSupported); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceSurfaceSupportKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, VkSurfaceKHR surface, - VkBool32 *pSupported) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfaceSupportKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == pSupported) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "NULL pointer passed into vkGetPhysicalDeviceSurfaceSupportKHR for pSupported!\n"); - assert(false && "GetPhysicalDeviceSurfaceSupportKHR: Error, null pSupported"); - } - *pSupported = false; - - if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfaceSupportKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceSurfaceSupportKHR ICD pointer"); - } - - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface; - if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) { - return icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR( - phys_dev_term->phys_dev, queueFamilyIndex, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pSupported); - } - - return icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, surface, pSupported); -} - -// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceCapabilitiesKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetPhysicalDeviceSurfaceCapabilitiesKHR(unwrapped_phys_dev, surface, pSurfaceCapabilities); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceSurfaceCapabilitiesKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == pSurfaceCapabilities) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "NULL pointer passed into vkGetPhysicalDeviceSurfaceCapabilitiesKHR for pSurfaceCapabilities!\n"); - assert(false && "GetPhysicalDeviceSurfaceCapabilitiesKHR: Error, null pSurfaceCapabilities"); - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfaceCapabilitiesKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceSurfaceCapabilitiesKHR ICD pointer"); - } - - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface; - if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) { - return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR( - phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pSurfaceCapabilities); - } - - return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, surface, pSurfaceCapabilities); -} - -// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceFormatsKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormatKHR *pSurfaceFormats) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetPhysicalDeviceSurfaceFormatsKHR(unwrapped_phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceSurfaceFormatsKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormatKHR *pSurfaceFormats) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfaceFormatsKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == pSurfaceFormatCount) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "NULL pointer passed into vkGetPhysicalDeviceSurfaceFormatsKHR for pSurfaceFormatCount!\n"); - assert(false && "GetPhysicalDeviceSurfaceFormatsKHR(: Error, null pSurfaceFormatCount"); - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfaceCapabilitiesKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceSurfaceFormatsKHR ICD pointer"); - } - - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface; - if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) { - return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, - icd_surface->real_icd_surfaces[phys_dev_term->icd_index], - pSurfaceFormatCount, pSurfaceFormats); - } - - return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, pSurfaceFormatCount, - pSurfaceFormats); -} - -// This is the trampoline entrypoint for GetPhysicalDeviceSurfacePresentModesKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t *pPresentModeCount, - VkPresentModeKHR *pPresentModes) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetPhysicalDeviceSurfacePresentModesKHR(unwrapped_phys_dev, surface, pPresentModeCount, pPresentModes); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceSurfacePresentModesKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, uint32_t *pPresentModeCount, - VkPresentModeKHR *pPresentModes) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfacePresentModesKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == pPresentModeCount) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "NULL pointer passed into vkGetPhysicalDeviceSurfacePresentModesKHR for pPresentModeCount!\n"); - assert(false && "GetPhysicalDeviceSurfacePresentModesKHR(: Error, null pPresentModeCount"); - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfacePresentModesKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceSurfacePresentModesKHR ICD pointer"); - } - - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface; - if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) { - return icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR( - phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pPresentModeCount, pPresentModes); - } - - return icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR(phys_dev_term->phys_dev, surface, pPresentModeCount, - pPresentModes); -} - -// Functions for the VK_KHR_swapchain extension: - -// This is the trampoline entrypoint for CreateSwapchainKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSwapchainKHR *pSwapchain) { - const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(device); - return disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { - uint32_t icd_index = 0; - struct loader_device *dev; - struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index); - if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) { - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pCreateInfo->surface; - if (NULL != icd_surface->real_icd_surfaces) { - if ((VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) { - // We found the ICD, and there is an ICD KHR surface - // associated with it, so copy the CreateInfo struct - // and point it at the ICD's surface. - VkSwapchainCreateInfoKHR *pCreateCopy = loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR)); - if (NULL == pCreateCopy) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memcpy(pCreateCopy, pCreateInfo, sizeof(VkSwapchainCreateInfoKHR)); - pCreateCopy->surface = icd_surface->real_icd_surfaces[icd_index]; - return icd_term->dispatch.CreateSwapchainKHR(device, pCreateCopy, pAllocator, pSwapchain); - } - } - return icd_term->dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); - } - return VK_SUCCESS; -} - -// This is the trampoline entrypoint for DestroySwapchainKHR -LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, - const VkAllocationCallbacks *pAllocator) { - const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(device); - disp->DestroySwapchainKHR(device, swapchain, pAllocator); -} - -// This is the trampoline entrypoint for GetSwapchainImagesKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, - uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { - const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(device); - return disp->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); -} - -// This is the trampoline entrypoint for AcquireNextImageKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, - VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { - const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(device); - return disp->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); -} - -// This is the trampoline entrypoint for QueuePresentKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { - const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(queue); - return disp->QueuePresentKHR(queue, pPresentInfo); -} - -static VkIcdSurface *AllocateIcdSurfaceStruct(struct loader_instance *instance, size_t base_size, size_t platform_size) { - // Next, if so, proceed with the implementation of this function: - VkIcdSurface *pIcdSurface = loader_instance_heap_alloc(instance, sizeof(VkIcdSurface), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - if (pIcdSurface != NULL) { - // Setup the new sizes and offsets so we can grow the structures in the - // future without having problems - pIcdSurface->base_size = (uint32_t)base_size; - pIcdSurface->platform_size = (uint32_t)platform_size; - pIcdSurface->non_platform_offset = (uint32_t)((uint8_t *)(&pIcdSurface->base_size) - (uint8_t *)pIcdSurface); - pIcdSurface->entire_size = sizeof(VkIcdSurface); - - pIcdSurface->real_icd_surfaces = loader_instance_heap_alloc(instance, sizeof(VkSurfaceKHR) * instance->total_icd_count, - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - if (pIcdSurface->real_icd_surfaces == NULL) { - loader_instance_heap_free(instance, pIcdSurface); - pIcdSurface = NULL; - } else { - memset(pIcdSurface->real_icd_surfaces, 0, sizeof(VkSurfaceKHR) * instance->total_icd_count); - } - } - return pIcdSurface; -} - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -// Functions for the VK_KHR_win32_surface extension: - -// This is the trampoline entrypoint for CreateWin32SurfaceKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, - const VkWin32SurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateWin32SurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - VkResult vkRes = VK_SUCCESS; - VkIcdSurface *pIcdSurface = NULL; - uint32_t i = 0; - - // Initialize pSurface to NULL just to be safe. - *pSurface = VK_NULL_HANDLE; - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_win32_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_win32_surface extension not enabled. vkCreateWin32SurfaceKHR not executed!\n"); - vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Next, if so, proceed with the implementation of this function: - pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->win_surf.base), sizeof(pIcdSurface->win_surf)); - if (pIcdSurface == NULL) { - vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - pIcdSurface->win_surf.base.platform = VK_ICD_WSI_PLATFORM_WIN32; - pIcdSurface->win_surf.hinstance = pCreateInfo->hinstance; - pIcdSurface->win_surf.hwnd = pCreateInfo->hwnd; - - // Loop through each ICD and determine if they need to create a surface - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.CreateWin32SurfaceKHR) { - vkRes = icd_term->dispatch.CreateWin32SurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, - &pIcdSurface->real_icd_surfaces[i]); - if (VK_SUCCESS != vkRes) { - goto out; - } - } - } - } - - *pSurface = (VkSurfaceKHR)(pIcdSurface); - -out: - - if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { - if (NULL != pIcdSurface->real_icd_surfaces) { - i = 0; - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); - } - } - loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces); - } - loader_instance_heap_free(ptr_instance, pIcdSurface); - } - - return vkRes; -} - -// This is the trampoline entrypoint for -// GetPhysicalDeviceWin32PresentationSupportKHR -LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkBool32 res = disp->GetPhysicalDeviceWin32PresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceWin32PresentationSupportKHR -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_win32_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_win32_surface extension not enabled. vkGetPhysicalDeviceWin32PresentationSupportKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceWin32PresentationSupportKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceWin32PresentationSupportKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceWin32PresentationSupportKHR ICD pointer"); - } - - return icd_term->dispatch.GetPhysicalDeviceWin32PresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex); -} -#endif // VK_USE_PLATFORM_WIN32_KHR - -#ifdef VK_USE_PLATFORM_MIR_KHR - -// Functions for the VK_KHR_mir_surface extension: - -// This is the trampoline entrypoint for CreateMirSurfaceKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(VkInstance instance, - const VkMirSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateMirSurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - VkResult vkRes = VK_SUCCESS; - VkIcdSurface *pIcdSurface = NULL; - uint32_t i = 0; - - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_mir_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_mir_surface extension not enabled. vkCreateMirSurfaceKHR not executed!\n"); - vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Next, if so, proceed with the implementation of this function: - pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->mir_surf.base), sizeof(pIcdSurface->mir_surf)); - if (pIcdSurface == NULL) { - vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - pIcdSurface->mir_surf.base.platform = VK_ICD_WSI_PLATFORM_MIR; - pIcdSurface->mir_surf.connection = pCreateInfo->connection; - pIcdSurface->mir_surf.mirSurface = pCreateInfo->mirSurface; - - // Loop through each ICD and determine if they need to create a surface - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.CreateMirSurfaceKHR) { - vkRes = icd_term->dispatch.CreateMirSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, - &pIcdSurface->real_icd_surfaces[i]); - if (VK_SUCCESS != vkRes) { - goto out; - } - } - } - } - - *pSurface = (VkSurfaceKHR)pIcdSurface; - -out: - - if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { - if (NULL != pIcdSurface->real_icd_surfaces) { - i = 0; - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); - } - } - loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces); - } - loader_instance_heap_free(ptr_instance, pIcdSurface); - } - - return vkRes; -} - -// This is the trampoline entrypoint for -// GetPhysicalDeviceMirPresentationSupportKHR -LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - MirConnection *connection) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkBool32 res = disp->GetPhysicalDeviceMirPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, connection); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceMirPresentationSupportKHR -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - MirConnection *connection) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_mir_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_mir_surface extension not enabled. vkGetPhysicalDeviceMirPresentationSupportKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceMirPresentationSupportKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceMirPresentationSupportKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceMirPresentationSupportKHR ICD pointer"); - } - - return icd_term->dispatch.GetPhysicalDeviceMirPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, connection); -} -#endif // VK_USE_PLATFORM_MIR_KHR - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - -// This is the trampoline entrypoint for CreateWaylandSurfaceKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateWaylandSurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - VkResult vkRes = VK_SUCCESS; - VkIcdSurface *pIcdSurface = NULL; - uint32_t i = 0; - - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_wayland_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_wayland_surface extension not enabled. vkCreateWaylandSurfaceKHR not executed!\n"); - vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Next, if so, proceed with the implementation of this function: - pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->wayland_surf.base), sizeof(pIcdSurface->wayland_surf)); - if (pIcdSurface == NULL) { - vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - pIcdSurface->wayland_surf.base.platform = VK_ICD_WSI_PLATFORM_WAYLAND; - pIcdSurface->wayland_surf.display = pCreateInfo->display; - pIcdSurface->wayland_surf.surface = pCreateInfo->surface; - - // Loop through each ICD and determine if they need to create a surface - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.CreateWaylandSurfaceKHR) { - vkRes = icd_term->dispatch.CreateWaylandSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, - &pIcdSurface->real_icd_surfaces[i]); - if (VK_SUCCESS != vkRes) { - goto out; - } - } - } - } - - *pSurface = (VkSurfaceKHR)pIcdSurface; - -out: - - if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { - if (NULL != pIcdSurface->real_icd_surfaces) { - i = 0; - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); - } - } - loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces); - } - loader_instance_heap_free(ptr_instance, pIcdSurface); - } - - return vkRes; -} - -// This is the trampoline entrypoint for -// GetPhysicalDeviceWaylandPresentationSupportKHR -LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display *display) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkBool32 res = disp->GetPhysicalDeviceWaylandPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, display); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceWaylandPresentationSupportKHR -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display *display) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_wayland_surface_enabled) { - loader_log( - ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_wayland_surface extension not enabled. vkGetPhysicalDeviceWaylandPresentationSupportKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceWaylandPresentationSupportKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceWaylandPresentationSupportKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceWaylandPresentationSupportKHR ICD pointer"); - } - - return icd_term->dispatch.GetPhysicalDeviceWaylandPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, display); -} -#endif // VK_USE_PLATFORM_WAYLAND_KHR - -#ifdef VK_USE_PLATFORM_XCB_KHR - -// Functions for the VK_KHR_xcb_surface extension: - -// This is the trampoline entrypoint for CreateXcbSurfaceKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, - const VkXcbSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateXcbSurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - VkResult vkRes = VK_SUCCESS; - VkIcdSurface *pIcdSurface = NULL; - uint32_t i = 0; - - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_xcb_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_xcb_surface extension not enabled. vkCreateXcbSurfaceKHR not executed!\n"); - vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Next, if so, proceed with the implementation of this function: - pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->xcb_surf.base), sizeof(pIcdSurface->xcb_surf)); - if (pIcdSurface == NULL) { - vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - pIcdSurface->xcb_surf.base.platform = VK_ICD_WSI_PLATFORM_XCB; - pIcdSurface->xcb_surf.connection = pCreateInfo->connection; - pIcdSurface->xcb_surf.window = pCreateInfo->window; - - // Loop through each ICD and determine if they need to create a surface - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.CreateXcbSurfaceKHR) { - vkRes = icd_term->dispatch.CreateXcbSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, - &pIcdSurface->real_icd_surfaces[i]); - if (VK_SUCCESS != vkRes) { - goto out; - } - } - } - } - - *pSurface = (VkSurfaceKHR)pIcdSurface; - -out: - - if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { - if (NULL != pIcdSurface->real_icd_surfaces) { - i = 0; - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); - } - } - loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces); - } - loader_instance_heap_free(ptr_instance, pIcdSurface); - } - - return vkRes; -} - -// This is the trampoline entrypoint for -// GetPhysicalDeviceXcbPresentationSupportKHR -LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t *connection, - xcb_visualid_t visual_id) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkBool32 res = disp->GetPhysicalDeviceXcbPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, connection, visual_id); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceXcbPresentationSupportKHR -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t *connection, - xcb_visualid_t visual_id) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_xcb_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_xcb_surface extension not enabled. vkGetPhysicalDeviceXcbPresentationSupportKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceXcbPresentationSupportKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceXcbPresentationSupportKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceXcbPresentationSupportKHR ICD pointer"); - } - - return icd_term->dispatch.GetPhysicalDeviceXcbPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, connection, - visual_id); -} -#endif // VK_USE_PLATFORM_XCB_KHR - -#ifdef VK_USE_PLATFORM_XLIB_KHR - -// Functions for the VK_KHR_xlib_surface extension: - -// This is the trampoline entrypoint for CreateXlibSurfaceKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, - const VkXlibSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateXlibSurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - VkResult vkRes = VK_SUCCESS; - VkIcdSurface *pIcdSurface = NULL; - uint32_t i = 0; - - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_xlib_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_xlib_surface extension not enabled. vkCreateXlibSurfaceKHR not executed!\n"); - vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Next, if so, proceed with the implementation of this function: - pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->xlib_surf.base), sizeof(pIcdSurface->xlib_surf)); - if (pIcdSurface == NULL) { - vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - pIcdSurface->xlib_surf.base.platform = VK_ICD_WSI_PLATFORM_XLIB; - pIcdSurface->xlib_surf.dpy = pCreateInfo->dpy; - pIcdSurface->xlib_surf.window = pCreateInfo->window; - - // Loop through each ICD and determine if they need to create a surface - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.CreateXlibSurfaceKHR) { - vkRes = icd_term->dispatch.CreateXlibSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, - &pIcdSurface->real_icd_surfaces[i]); - if (VK_SUCCESS != vkRes) { - goto out; - } - } - } - } - - *pSurface = (VkSurfaceKHR)pIcdSurface; - -out: - - if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { - if (NULL != pIcdSurface->real_icd_surfaces) { - i = 0; - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); - } - } - loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces); - } - loader_instance_heap_free(ptr_instance, pIcdSurface); - } - - return vkRes; -} - -// This is the trampoline entrypoint for -// GetPhysicalDeviceXlibPresentationSupportKHR -LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, Display *dpy, - VisualID visualID) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkBool32 res = disp->GetPhysicalDeviceXlibPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, dpy, visualID); - return res; -} - -// This is the instance chain terminator function for -// GetPhysicalDeviceXlibPresentationSupportKHR -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, Display *dpy, - VisualID visualID) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_xlib_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_xlib_surface extension not enabled. vkGetPhysicalDeviceXlibPresentationSupportKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceXlibPresentationSupportKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceXlibPresentationSupportKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceXlibPresentationSupportKHR ICD pointer"); - } - - return icd_term->dispatch.GetPhysicalDeviceXlibPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, dpy, visualID); -} -#endif // VK_USE_PLATFORM_XLIB_KHR - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - -// Functions for the VK_KHR_android_surface extension: - -// This is the trampoline entrypoint for CreateAndroidSurfaceKHR -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, ANativeWindow *window, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateAndroidSurfaceKHR(instance, window, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateAndroidSurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(VkInstance instance, Window window, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_display_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_display extension not enabled. vkCreateAndroidSurfaceKHR not executed!\n"); - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - - // Next, if so, proceed with the implementation of this function: - VkIcdSurfaceAndroid *pIcdSurface = - loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceAndroid), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - if (pIcdSurface == NULL) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_ANDROID; - pIcdSurface->window = window; - - *pSurface = (VkSurfaceKHR)pIcdSurface; - - return VK_SUCCESS; -} - -#endif // VK_USE_PLATFORM_ANDROID_KHR - -#ifdef VK_USE_PLATFORM_MACOS_MVK - -// Functions for the VK_MVK_macos_surface extension: - -// This is the trampoline entrypoint for CreateMacOSSurfaceMVK -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateMacOSSurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - VkResult vkRes = VK_SUCCESS; - VkIcdSurface *pIcdSurface = NULL; - uint32_t i = 0; - - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_macos_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_MVK_macos_surface extension not enabled. vkCreateMacOSSurfaceMVK not executed!\n"); - vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Next, if so, proceed with the implementation of this function: - pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->macos_surf.base), sizeof(pIcdSurface->macos_surf)); - if (pIcdSurface == NULL) { - vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - pIcdSurface->macos_surf.base.platform = VK_ICD_WSI_PLATFORM_MACOS; - pIcdSurface->macos_surf.pView = pCreateInfo->pView; - - // Loop through each ICD and determine if they need to create a surface - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.CreateMacOSSurfaceMVK) { - vkRes = icd_term->dispatch.CreateMacOSSurfaceMVK(icd_term->instance, pCreateInfo, pAllocator, - &pIcdSurface->real_icd_surfaces[i]); - if (VK_SUCCESS != vkRes) { - goto out; - } - } - } - } - - *pSurface = (VkSurfaceKHR)pIcdSurface; - -out: - - if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { - if (NULL != pIcdSurface->real_icd_surfaces) { - i = 0; - for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); - } - } - loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces); - } - loader_instance_heap_free(ptr_instance, pIcdSurface); - } - - return vkRes; -} - -#endif // VK_USE_PLATFORM_MACOS_MVK - -#ifdef VK_USE_PLATFORM_IOS_MVK - -// Functions for the VK_MVK_ios_surface extension: - -// This is the trampoline entrypoint for CreateIOSSurfaceMVK -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, - const VkIOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -// This is the instance chain terminator function for CreateIOSSurfaceKHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { - // First, check to ensure the appropriate extension was enabled: - struct loader_instance *ptr_instance = loader_get_instance(instance); - if (!ptr_instance->wsi_ios_surface_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_MVK_ios_surface extension not enabled. vkCreateIOSSurfaceMVK not executed!\n"); - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - - // Next, if so, proceed with the implementation of this function: - VkIcdSurfaceIOS *pIcdSurface = - loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceIOS), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); - if (pIcdSurface == NULL) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_IOS; - pIcdSurface->pView = pCreateInfo->pView; - - *pSurface = (VkSurfaceKHR)pIcdSurface; - - return VK_SUCCESS; -} - -#endif // VK_USE_PLATFORM_IOS_MVK - -// Functions for the VK_KHR_display instance extension: -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, - uint32_t *pPropertyCount, - VkDisplayPropertiesKHR *pProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetPhysicalDeviceDisplayPropertiesKHR(unwrapped_phys_dev, pPropertyCount, pProperties); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, - uint32_t *pPropertyCount, - VkDisplayPropertiesKHR *pProperties) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_display_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_display extension not enabled. vkGetPhysicalDeviceDisplayPropertiesKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceDisplayPropertiesKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceDisplayPropertiesKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceDisplayPropertiesKHR ICD pointer"); - } - - return icd_term->dispatch.GetPhysicalDeviceDisplayPropertiesKHR(phys_dev_term->phys_dev, pPropertyCount, pProperties); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetPhysicalDeviceDisplayPlanePropertiesKHR(unwrapped_phys_dev, pPropertyCount, pProperties); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, - uint32_t *pPropertyCount, - VkDisplayPlanePropertiesKHR *pProperties) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_display_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_display extension not enabled. vkGetPhysicalDeviceDisplayPlanePropertiesKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetPhysicalDeviceDisplayPlanePropertiesKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetPhysicalDeviceDisplayPlanePropertiesKHR!\n"); - assert(false && "loader: null GetPhysicalDeviceDisplayPlanePropertiesKHR ICD pointer"); - } - - return icd_term->dispatch.GetPhysicalDeviceDisplayPlanePropertiesKHR(phys_dev_term->phys_dev, pPropertyCount, pProperties); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, - uint32_t planeIndex, uint32_t *pDisplayCount, - VkDisplayKHR *pDisplays) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetDisplayPlaneSupportedDisplaysKHR(unwrapped_phys_dev, planeIndex, pDisplayCount, pDisplays); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, - uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_display_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_display extension not enabled. vkGetDisplayPlaneSupportedDisplaysKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetDisplayPlaneSupportedDisplaysKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetDisplayPlaneSupportedDisplaysKHR!\n"); - assert(false && "loader: null GetDisplayPlaneSupportedDisplaysKHR ICD pointer"); - } - - return icd_term->dispatch.GetDisplayPlaneSupportedDisplaysKHR(phys_dev_term->phys_dev, planeIndex, pDisplayCount, pDisplays); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - uint32_t *pPropertyCount, - VkDisplayModePropertiesKHR *pProperties) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetDisplayModePropertiesKHR(unwrapped_phys_dev, display, pPropertyCount, pProperties); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - uint32_t *pPropertyCount, - VkDisplayModePropertiesKHR *pProperties) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_display_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_display extension not enabled. vkGetDisplayModePropertiesKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetDisplayModePropertiesKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetDisplayModePropertiesKHR!\n"); - assert(false && "loader: null GetDisplayModePropertiesKHR ICD pointer"); - } - - return icd_term->dispatch.GetDisplayModePropertiesKHR(phys_dev_term->phys_dev, display, pPropertyCount, pProperties); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDisplayModeKHR *pMode) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->CreateDisplayModeKHR(unwrapped_phys_dev, display, pCreateInfo, pAllocator, pMode); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_display_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_display extension not enabled. vkCreateDisplayModeKHR not executed!\n"); - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - - if (NULL == icd_term->dispatch.CreateDisplayModeKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkCreateDisplayModeKHR!\n"); - assert(false && "loader: null CreateDisplayModeKHR ICD pointer"); - } - - return icd_term->dispatch.CreateDisplayModeKHR(phys_dev_term->phys_dev, display, pCreateInfo, pAllocator, pMode); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR *pCapabilities) { - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(physicalDevice); - VkResult res = disp->GetDisplayPlaneCapabilitiesKHR(unwrapped_phys_dev, mode, planeIndex, pCapabilities); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR *pCapabilities) { - // First, check to ensure the appropriate extension was enabled: - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; - if (!ptr_instance->wsi_display_enabled) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_display extension not enabled. vkGetDisplayPlaneCapabilitiesKHR not executed!\n"); - return VK_SUCCESS; - } - - if (NULL == icd_term->dispatch.GetDisplayPlaneCapabilitiesKHR) { - loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD for selected physical device is not exporting vkGetDisplayPlaneCapabilitiesKHR!\n"); - assert(false && "loader: null GetDisplayPlaneCapabilitiesKHR ICD pointer"); - } - - return icd_term->dispatch.GetDisplayPlaneCapabilitiesKHR(phys_dev_term->phys_dev, mode, planeIndex, pCapabilities); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - const VkLayerInstanceDispatchTable *disp; - disp = loader_get_instance_layer_dispatch(instance); - VkResult res; - - res = disp->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - return res; -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface) { - struct loader_instance *inst = loader_get_instance(instance); - VkIcdSurface *pIcdSurface = NULL; - VkResult vkRes = VK_SUCCESS; - uint32_t i = 0; - - if (!inst->wsi_display_enabled) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "VK_KHR_surface extension not enabled. vkCreateDisplayPlaneSurfaceKHR not executed!\n"); - vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; - goto out; - } - - // Next, if so, proceed with the implementation of this function: - pIcdSurface = AllocateIcdSurfaceStruct(inst, sizeof(pIcdSurface->display_surf.base), sizeof(pIcdSurface->display_surf)); - if (pIcdSurface == NULL) { - vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } - - pIcdSurface->display_surf.base.platform = VK_ICD_WSI_PLATFORM_DISPLAY; - pIcdSurface->display_surf.displayMode = pCreateInfo->displayMode; - pIcdSurface->display_surf.planeIndex = pCreateInfo->planeIndex; - pIcdSurface->display_surf.planeStackIndex = pCreateInfo->planeStackIndex; - pIcdSurface->display_surf.transform = pCreateInfo->transform; - pIcdSurface->display_surf.globalAlpha = pCreateInfo->globalAlpha; - pIcdSurface->display_surf.alphaMode = pCreateInfo->alphaMode; - pIcdSurface->display_surf.imageExtent = pCreateInfo->imageExtent; - - // Loop through each ICD and determine if they need to create a surface - for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { - if (NULL != icd_term->dispatch.CreateDisplayPlaneSurfaceKHR) { - vkRes = icd_term->dispatch.CreateDisplayPlaneSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, - &pIcdSurface->real_icd_surfaces[i]); - if (VK_SUCCESS != vkRes) { - goto out; - } - } - } - } - - *pSurface = (VkSurfaceKHR)pIcdSurface; - -out: - - if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { - if (NULL != pIcdSurface->real_icd_surfaces) { - i = 0; - for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { - if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { - icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); - } - } - loader_instance_heap_free(inst, pIcdSurface->real_icd_surfaces); - } - loader_instance_heap_free(inst, pIcdSurface); - } - - return vkRes; -} - -// EXT_display_swapchain Extension command - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR *pCreateInfos, - const VkAllocationCallbacks *pAllocator, - VkSwapchainKHR *pSwapchains) { - const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(device); - return disp->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR *pCreateInfos, - const VkAllocationCallbacks *pAllocator, - VkSwapchainKHR *pSwapchains) { - uint32_t icd_index = 0; - struct loader_device *dev; - struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index); - if (NULL != icd_term && NULL != icd_term->dispatch.CreateSharedSwapchainsKHR) { - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pCreateInfos->surface; - if (NULL != icd_surface->real_icd_surfaces) { - if ((VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) { - // We found the ICD, and there is an ICD KHR surface - // associated with it, so copy the CreateInfo struct - // and point it at the ICD's surface. - VkSwapchainCreateInfoKHR *pCreateCopy = loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR) * swapchainCount); - if (NULL == pCreateCopy) { - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - memcpy(pCreateCopy, pCreateInfos, sizeof(VkSwapchainCreateInfoKHR) * swapchainCount); - for (uint32_t sc = 0; sc < swapchainCount; sc++) { - pCreateCopy[sc].surface = icd_surface->real_icd_surfaces[icd_index]; - } - return icd_term->dispatch.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateCopy, pAllocator, pSwapchains); - } - } - return icd_term->dispatch.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); - } - return VK_SUCCESS; -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes) { - uint32_t icd_index = 0; - struct loader_device *dev; - struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index); - if (NULL != icd_term && NULL != icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHR) { - VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface; - if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) { - return icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHR(device, icd_surface->real_icd_surfaces[icd_index], pModes); - } - return icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); - } - return VK_SUCCESS; -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetPhysicalDevicePresentRectanglesKHR(unwrapped_phys_dev, surface, pRectCount, pRects); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDevicePresentRectanglesKHX"); - } - VkIcdSurface *icd_surface = (VkIcdSurface *)(surface); - uint8_t icd_index = phys_dev_term->icd_index; - if (NULL != icd_surface->real_icd_surfaces && NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) { - return icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHR(phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[icd_index], pRectCount, pRects); - } - return icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHR(phys_dev_term->phys_dev, surface, pRectCount, pRects); -} - -LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - uint32_t* pImageIndex) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); -} - -bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) { - *addr = NULL; - - // Functions for the VK_KHR_surface extension: - if (!strcmp("vkDestroySurfaceKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkDestroySurfaceKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceSupportKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceCapabilitiesKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceFormatsKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfacePresentModesKHR : NULL; - return true; - } - - if (!strcmp("vkGetDeviceGroupPresentCapabilitiesKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetDeviceGroupPresentCapabilitiesKHR : NULL; - return true; - } - - if (!strcmp("vkGetDeviceGroupSurfacePresentModesKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetDeviceGroupSurfacePresentModesKHR : NULL; - return true; - } - - if (!strcmp("vkGetPhysicalDevicePresentRectanglesKHR", name)) { - *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDevicePresentRectanglesKHR : NULL; - return true; - } - - // Functions for the VK_KHR_swapchain extension: - - // Note: This is a device extension, and its functions are statically - // exported from the loader. Per Khronos decisions, the loader's GIPA - // function will return the trampoline function for such device-extension - // functions, regardless of whether the extension has been enabled. - if (!strcmp("vkCreateSwapchainKHR", name)) { - *addr = (void *)vkCreateSwapchainKHR; - return true; - } - if (!strcmp("vkDestroySwapchainKHR", name)) { - *addr = (void *)vkDestroySwapchainKHR; - return true; - } - if (!strcmp("vkGetSwapchainImagesKHR", name)) { - *addr = (void *)vkGetSwapchainImagesKHR; - return true; - } - if (!strcmp("vkAcquireNextImageKHR", name)) { - *addr = (void *)vkAcquireNextImageKHR; - return true; - } - if (!strcmp("vkQueuePresentKHR", name)) { - *addr = (void *)vkQueuePresentKHR; - return true; - } - if (!strcmp("vkAcquireNextImage2KHR", name)) { - *addr = (void *)vkAcquireNextImage2KHR; - return true; - } - -#ifdef VK_USE_PLATFORM_WIN32_KHR - - // Functions for the VK_KHR_win32_surface extension: - if (!strcmp("vkCreateWin32SurfaceKHR", name)) { - *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkCreateWin32SurfaceKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceWin32PresentationSupportKHR", name)) { - *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkGetPhysicalDeviceWin32PresentationSupportKHR : NULL; - return true; - } -#endif // VK_USE_PLATFORM_WIN32_KHR -#ifdef VK_USE_PLATFORM_MIR_KHR - - // Functions for the VK_KHR_mir_surface extension: - if (!strcmp("vkCreateMirSurfaceKHR", name)) { - *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkCreateMirSurfaceKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceMirPresentationSupportKHR", name)) { - *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkGetPhysicalDeviceMirPresentationSupportKHR : NULL; - return true; - } -#endif // VK_USE_PLATFORM_MIR_KHR -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - - // Functions for the VK_KHR_wayland_surface extension: - if (!strcmp("vkCreateWaylandSurfaceKHR", name)) { - *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkCreateWaylandSurfaceKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceWaylandPresentationSupportKHR", name)) { - *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkGetPhysicalDeviceWaylandPresentationSupportKHR : NULL; - return true; - } -#endif // VK_USE_PLATFORM_WAYLAND_KHR -#ifdef VK_USE_PLATFORM_XCB_KHR - - // Functions for the VK_KHR_xcb_surface extension: - if (!strcmp("vkCreateXcbSurfaceKHR", name)) { - *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkCreateXcbSurfaceKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceXcbPresentationSupportKHR", name)) { - *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkGetPhysicalDeviceXcbPresentationSupportKHR : NULL; - return true; - } -#endif // VK_USE_PLATFORM_XCB_KHR -#ifdef VK_USE_PLATFORM_XLIB_KHR - - // Functions for the VK_KHR_xlib_surface extension: - if (!strcmp("vkCreateXlibSurfaceKHR", name)) { - *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkCreateXlibSurfaceKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceXlibPresentationSupportKHR", name)) { - *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkGetPhysicalDeviceXlibPresentationSupportKHR : NULL; - return true; - } -#endif // VK_USE_PLATFORM_XLIB_KHR -#ifdef VK_USE_PLATFORM_ANDROID_KHR - - // Functions for the VK_KHR_android_surface extension: - if (!strcmp("vkCreateAndroidSurfaceKHR", name)) { - *addr = ptr_instance->wsi_android_surface_enabled ? (void *)vkCreateAndroidSurfaceKHR : NULL; - return true; - } -#endif // VK_USE_PLATFORM_ANDROID_KHR -#ifdef VK_USE_PLATFORM_MACOS_MVK - - // Functions for the VK_MVK_macos_surface extension: - if (!strcmp("vkCreateMacOSSurfaceMVK", name)) { - *addr = ptr_instance->wsi_macos_surface_enabled ? (void *)vkCreateMacOSSurfaceMVK : NULL; - return true; - } -#endif // VK_USE_PLATFORM_MACOS_MVK -#ifdef VK_USE_PLATFORM_IOS_MVK - - // Functions for the VK_MVK_ios_surface extension: - if (!strcmp("vkCreateIOSSurfaceMVK", name)) { - *addr = ptr_instance->wsi_ios_surface_enabled ? (void *)vkCreateIOSSurfaceMVK : NULL; - return true; - } -#endif // VK_USE_PLATFORM_IOS_MVK - - // Functions for VK_KHR_display extension: - if (!strcmp("vkGetPhysicalDeviceDisplayPropertiesKHR", name)) { - *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR : NULL; - return true; - } - if (!strcmp("vkGetPhysicalDeviceDisplayPlanePropertiesKHR", name)) { - *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPlanePropertiesKHR : NULL; - return true; - } - if (!strcmp("vkGetDisplayPlaneSupportedDisplaysKHR", name)) { - *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneSupportedDisplaysKHR : NULL; - return true; - } - if (!strcmp("vkGetDisplayModePropertiesKHR", name)) { - *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayModePropertiesKHR : NULL; - return true; - } - if (!strcmp("vkCreateDisplayModeKHR", name)) { - *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayModeKHR : NULL; - return true; - } - if (!strcmp("vkGetDisplayPlaneCapabilitiesKHR", name)) { - *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneCapabilitiesKHR : NULL; - return true; - } - if (!strcmp("vkCreateDisplayPlaneSurfaceKHR", name)) { - *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayPlaneSurfaceKHR : NULL; - return true; - } - - // Functions for KHR_display_swapchain extension: - if (!strcmp("vkCreateSharedSwapchainsKHR", name)) { - *addr = (void *)vkCreateSharedSwapchainsKHR; - return true; - } - - return false; -} diff --git a/loader/wsi.h b/loader/wsi.h deleted file mode 100644 index cc8abed6..00000000 --- a/loader/wsi.h +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Ian Elliott - * - */ - -#ifndef WSI_H -#define WSI_H - -#include "vk_loader_platform.h" -#include "loader.h" - -typedef struct { - union { -#ifdef VK_USE_PLATFORM_MIR_KHR - VkIcdSurfaceMir mir_surf; -#endif // VK_USE_PLATFORM_MIR_KHR -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VkIcdSurfaceWayland wayland_surf; -#endif // VK_USE_PLATFORM_WAYLAND_KHR -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkIcdSurfaceWin32 win_surf; -#endif // VK_USE_PLATFORM_WIN32_KHR -#ifdef VK_USE_PLATFORM_XCB_KHR - VkIcdSurfaceXcb xcb_surf; -#endif // VK_USE_PLATFORM_XCB_KHR -#ifdef VK_USE_PLATFORM_XLIB_KHR - VkIcdSurfaceXlib xlib_surf; -#endif // VK_USE_PLATFORM_XLIB_KHR -#ifdef VK_USE_PLATFORM_MACOS_MVK - VkIcdSurfaceMacOS macos_surf; -#endif // VK_USE_PLATFORM_MACOS_MVK - VkIcdSurfaceDisplay display_surf; - }; - uint32_t base_size; // Size of VkIcdSurfaceBase - uint32_t platform_size; // Size of corresponding VkIcdSurfaceXXX - uint32_t non_platform_offset; // Start offset to base_size - uint32_t entire_size; // Size of entire VkIcdSurface - VkSurfaceKHR *real_icd_surfaces; -} VkIcdSurface; - -bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr); - -void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo); -bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain); - -VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, - const VkAllocationCallbacks *pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, VkSurfaceKHR surface, - VkBool32 *pSupported); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR *pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormatKHR *pSurfaceFormats); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, uint32_t *pPresentModeCount, - VkPresentModeKHR *pPresentModes); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes); - -#ifdef VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex); -#endif -#ifdef VK_USE_PLATFORM_MIR_KHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - MirConnection *connection); -#endif -#ifdef VK_USE_PLATFORM_WAYLAND_KHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display *display); -#endif -#ifdef VK_USE_PLATFORM_XCB_KHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); - -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t *connection, - xcb_visualid_t visual_id); -#endif -#ifdef VK_USE_PLATFORM_XLIB_KHR -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); -VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, Display *dpy, - VisualID visualID); -#endif -#ifdef VK_USE_PLATFORM_MACOS_MVK -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); -#endif -#ifdef VK_USE_PLATFORM_IOS_MVK -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); -#endif -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, - uint32_t *pPropertyCount, - VkDisplayPropertiesKHR *pProperties); -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, - uint32_t *pPropertyCount, - VkDisplayPlanePropertiesKHR *pProperties); -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, - uint32_t *pDisplayCount, VkDisplayKHR *pDisplays); -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - uint32_t *pPropertyCount, - VkDisplayModePropertiesKHR *pProperties); -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode); -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR *pCapabilities); -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkSurfaceKHR *pSurface); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR *pCreateInfos, - const VkAllocationCallbacks *pAllocator, - VkSwapchainKHR *pSwapchains); - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects); - -#endif // WSI_H diff --git a/windowsRuntimeInstaller/ConfigureRT.vcxproj b/windowsRuntimeInstaller/ConfigureRT.vcxproj deleted file mode 100644 index 9fe0c447..00000000 --- a/windowsRuntimeInstaller/ConfigureRT.vcxproj +++ /dev/null @@ -1,80 +0,0 @@ - - - - - Debug - Win32 - - - Release - Win32 - - - - {09753397-FB1C-469E-9BCA-8F0A19B9A8DA} - ConfigureRT - - - - Application - true - v140 - MultiByte - - - Application - false - v140 - true - MultiByte - - - - - - - - - - - - - - - Level2 - Disabled - false - MultiThreadedDebug - Guard - - - true - Windows - mainCRTStartup - - - - - Level2 - MaxSpeed - true - true - false - MultiThreaded - Guard - - - true - true - true - Windows - mainCRTStartup - - - - - - - - - \ No newline at end of file diff --git a/windowsRuntimeInstaller/CreateInstallerRT.sh b/windowsRuntimeInstaller/CreateInstallerRT.sh deleted file mode 100755 index f272d98e..00000000 --- a/windowsRuntimeInstaller/CreateInstallerRT.sh +++ /dev/null @@ -1,16 +0,0 @@ -#!/bin/bash -# Bash script to create the Vulkan Runtime Installer. - -# Create the uinstaller -makensis /DUNINSTALLER InstallerRT.nsi -$TEMP/tempinstaller.exe -mv $TEMP/UninstallVulkanRT.exe . - -# Sign the Uninstaller -# Replace SIGNFILE with your command and necessary args for -# signing an executable. If you don't need to sign the uninstaller, -# you can comment out this line. -./SIGNFILE ./UninstallVulkanRT.exe - -# Create the RT Installer, using the signed uninstaller -makensis InstallerRT.nsi diff --git a/windowsRuntimeInstaller/InstallerRT.nsi b/windowsRuntimeInstaller/InstallerRT.nsi deleted file mode 100644 index fd05914d..00000000 --- a/windowsRuntimeInstaller/InstallerRT.nsi +++ /dev/null @@ -1,868 +0,0 @@ -# NSIS Script for creating the Windows Vulkan RT installer. -# -# Copyright (c) 2015-2016 The Khronos Group Inc. -# Copyright (c) 2015-2016 Valve Corporation -# Copyright (c) 2015-2016 LunarG, Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Author: David Pinedo -# Author: Mark Young -# - - -# Version information -# Set VERSION_BUILDNO to: -# x.devbuild.z for development builds -# x for releases -# - -# Set the default name to "Vulkan", but allow this to be overriden -!ifndef APINAME - !define APINAME "Vulkan" - !define APILOWER "vulkan" -!endif - -!define PRODUCTNAME "${APINAME}RT" - -!ifndef HIDE_VERSION - !define VERSION_ABI_MAJOR "1" - !define VERSION_API_MAJOR "1" - !define VERSION_MINOR "0" - !define VERSION_PATCH "12" - !define VERSION_BUILDNO "0.devbuild.1" -!endif -!ifndef HIDE_PUBLISHER - !define PUBLISHER "YourCompany, Inc." -!endif -!ifndef COPYRIGHT - !define COPYRIGHT "" -!endif -#!define VERSION_BUILDNO "0" -!define PRODUCTVERSION "${VERSION_API_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}.${VERSION_BUILDNO}" - -# Includes -!include LogicLib.nsh - -# This number is determined by doing an install, and then from Windows Explorer, -# doing a "Properties" on the install directory. Add to this the size of the -# files installed to C:\Windows\System32. And then add a little bit more. -# The units are 1K bytes. -!define ESTIMATEDSIZE "1700" - -# This is used for the error message if a problem occurs during install. -!define errorMessage1 "Installation of ${PRODUCTNAME} failed!$\r$\n" -!define errorMessage1un "Uninstall of ${PRODUCTNAME} failed!$\r$\n" -!define errorMessage2 "Uninstalling any installed items and exiting.$\r$\n" - -# Set the icon -!define ICOFILE "V.ico" -Icon ${ICOFILE} -UninstallIcon ${ICOFILE} -WindowIcon off - -# If /DUNINSTALLER was specified, Create the uinstaller -!ifdef UNINSTALLER - !echo "Creating RT uninstaller...." - OutFile "$%TEMP%\tempinstaller.exe" - SetCompress off -!else - !echo "Creating RT installer...." - - # Define name of installer - OutFile "${PRODUCTNAME}-${PRODUCTVERSION}-Installer.exe" - SetCompressor /SOLID lzma - -!endif - -# Define default installation directory -InstallDir "$PROGRAMFILES\${PRODUCTNAME}\${PRODUCTVERSION}" - -# Version string used in file names -Var FileVersion - -# Directory RT was installed to. -# The uninstaller can't just use $INSTDIR because it is set to the -# directory the uninstaller exe file is located in. -!ifdef UNINSTALLER -Var IDir -!endif - -# Install count -Var IC - -############################################# -# StrRep - string replace - -!define StrRep "!insertmacro StrRep" -!macro StrRep output string old new - Push `${string}` - Push `${old}` - Push `${new}` - !ifdef __UNINSTALL__ - Call un.StrRep - !else - Call StrRep - !endif - Pop ${output} -!macroend - -!macro Func_StrRep un - Function ${un}StrRep - Exch $R2 ;new - Exch 1 - Exch $R1 ;old - Exch 2 - Exch $R0 ;string - Push $R3 - Push $R4 - Push $R5 - Push $R6 - Push $R7 - Push $R8 - Push $R9 - - StrCpy $R3 0 - StrLen $R4 $R1 - StrLen $R6 $R0 - StrLen $R9 $R2 - loop: - StrCpy $R5 $R0 $R4 $R3 - StrCmp $R5 $R1 found - StrCmp $R3 $R6 done - IntOp $R3 $R3 + 1 ;move offset by 1 to check the next character - Goto loop - found: - StrCpy $R5 $R0 $R3 - IntOp $R8 $R3 + $R4 - StrCpy $R7 $R0 "" $R8 - StrCpy $R0 $R5$R2$R7 - StrLen $R6 $R0 - IntOp $R3 $R3 + $R9 ;move offset by length of the replacement string - Goto loop - done: - - Pop $R9 - Pop $R8 - Pop $R7 - Pop $R6 - Pop $R5 - Pop $R4 - Pop $R3 - Push $R0 - Push $R1 - Pop $R0 - Pop $R1 - Pop $R0 - Pop $R2 - Exch $R1 - FunctionEnd -!macroend -!insertmacro Func_StrRep "" -!insertmacro Func_StrRep "un." - -############################################# -# x64 macros - -!define IsWow64 `"" IsWow64 ""` -!macro _IsWow64 _a _b _t _f - !insertmacro _LOGICLIB_TEMP - System::Call kernel32::GetCurrentProcess()p.s - System::Call kernel32::IsWow64Process(ps,*i0s) - Pop $_LOGICLIB_TEMP - !insertmacro _!= $_LOGICLIB_TEMP 0 `${_t}` `${_f}` -!macroend - -!define RunningX64 `"" RunningX64 ""` -!macro _RunningX64 _a _b _t _f - !if ${NSIS_PTR_SIZE} > 4 - !insertmacro LogicLib_JumpToBranch `${_t}` `${_f}` - !else - !insertmacro _IsWow64 `${_a}` `${_b}` `${_t}` `${_f}` - !endif -!macroend - -!define DisableX64FSRedirection "!insertmacro DisableX64FSRedirection" -!macro DisableX64FSRedirection - System::Call kernel32::Wow64EnableWow64FsRedirection(i0) -!macroend - -!define EnableX64FSRedirection "!insertmacro EnableX64FSRedirection" -!macro EnableX64FSRedirection - System::Call kernel32::Wow64EnableWow64FsRedirection(i1) -!macroend - - -# Need admin to write to C:\Windows\System32 and install dir -RequestExecutionLevel admin - -Function .onInit - -!ifdef UNINSTALLER - ; Write out the uinstaller and quit - WriteUninstaller "$%TEMP%\Uninstall${PRODUCTNAME}.exe" - Quit -!endif - -FunctionEnd - -; Initialize Explode variables -Var /GLOBAL explString -Var /GLOBAL explSeparator -Var /GLOBAL explStrLen -Var /GLOBAL explSepLen -Var /GLOBAL explOffset -Var /GLOBAL explTmp -Var /GLOBAL explTmp2 -Var /GLOBAL explTmp3 -Var /GLOBAL explArrCount - -!macro Func_Explode un -Function ${un}Explode - ; Get input from user - Pop $explString - Pop $explSeparator - - ; Calculates initial values - StrLen $explStrLen $explString - StrLen $explSepLen $explSeparator - StrCpy $explArrCount 1 - - ${If} $explStrLen <= 1 ; If we got a single character - ${OrIf} $explSepLen > $explStrLen ; or separator is larger than the string, - Push $explString ; then we return initial string with no change - Push 1 ; and set array's length to 1 - Return - ${EndIf} - - ; Set offset to the last symbol of the string - StrCpy $explOffset $explStrLen - IntOp $explOffset $explOffset - 1 - - ; Clear temp string to exclude the possibility of appearance of occasional data - StrCpy $explTmp "" - StrCpy $explTmp2 "" - StrCpy $explTmp3 "" - - ; Loop until the offset becomes negative - ${Do} - ; If offset becomes negative, it is time to leave the function - ${IfThen} $explOffset == -1 ${|} ${ExitDo} ${|} - - ; Remove everything before and after the searched part ("TempStr") - StrCpy $explTmp $explString $explSepLen $explOffset - - ${If} $explTmp == $explSeparator - ; Calculating offset to start copy from - IntOp $explTmp2 $explOffset + $explSepLen ; Offset equals to the current offset plus length of separator - StrCpy $explTmp3 $explString "" $explTmp2 - - Push $explTmp3 ; Throwing array item to the stack - IntOp $explArrCount $explArrCount + 1 ; Increasing array's counter - - StrCpy $explString $explString $explOffset 0 ; Cutting all characters beginning with the separator entry - StrLen $explStrLen $explString - ${EndIf} - - ${If} $explOffset = 0 ; If the beginning of the line met and there is no separator, - ; copying the rest of the string - ${If} $explSeparator == "" ; Fix for the empty separator - IntOp $explArrCount $explArrCount - 1 - ${Else} - Push $explString - ${EndIf} - ${EndIf} - - IntOp $explOffset $explOffset - 1 - ${Loop} - - Push $explArrCount -FunctionEnd -!macroend -!insertmacro Func_Explode "" -!insertmacro Func_Explode "un." - -AddBrandingImage left 150 -Caption "${PRODUCTNAME} ${PRODUCTVERSION} Setup" -Name "${PRODUCTNAME} ${PRODUCTVERSION}" -LIcenseData "VULKANRT_LICENSE.rtf" -Page custom brandimage "" ": Brand Image" -Page license -Page directory -Page instfiles -UninstallCaption "\${PRODUCTNAME} ${PRODUCTVERSION} Uninstall" -UninstallText "This wizard will uninstall ${PRODUCTNAME} ${PRODUCTVERSION} from your computer. Click Uninstall to start the uninstallation." -UninstPage custom un.brandimage "" ": Brand Image" -UninstPage uninstConfirm -UninstPage instFiles - -# File Properties -VIProductVersion "${PRODUCTVERSION}" -VIAddVersionKey "ProductName" "${APINAME} Runtime" -VIAddVersionKey "FileVersion" "${PRODUCTVERSION}" -VIAddVersionKey "ProductVersion" "${PRODUCTVERSION}" -VIAddVersionKey "LegalCopyright" "${COPYRIGHT}" - -!ifdef UNINSTALLER - VIAddVersionKey "FileDescription" "${APINAME} Runtime Uninstaller" -!else - VIAddVersionKey "FileDescription" "${APINAME} Runtime Installer" -!endif - - -# Function to run ConfigureRT program. -# Return value is in $0 - 0 is success, all else is failure. -!macro ConfigLayersAndVulkanDLL un -Function ${un}ConfigLayersAndVulkanDLL - - # Execute the configuration program - nsExec::ExecToStack 'ConfigureRT.exe --abi-major ${VERSION_ABI_MAJOR} --api-name ${APINAME}' - Delete "$TEMP\VulkanRT\configure_rt.log" - Rename "configure_rt.log" "$TEMP\VulkanRT\configure_rt.log" - pop $0 - - ${IF} $0 == 0 - Pop $1 - LogText "Output from ConfigureRT: $1" - Push ";" - Push "$1" - Call ${un}Explode - Pop $2 - ${For} $4 1 $2 - Pop $3 - Push ">" - Push "$3" - Call ${un}Explode - Pop $5 - ${IF} "$5" == "2" - Pop $6 - Pop $7 - CopyFiles /SILENT "$6" "$7" - ${ENDIF} - ${Next} - ${ENDIF} - - # Ignore errors. If something went wrong, the return value will indicate it. - ClearErrors - -FunctionEnd -!macroend -!insertmacro ConfigLayersAndVulkanDLL "" -!insertmacro ConfigLayersAndVulkanDLL "un." - - -# Function to run diagnostics if ConfigureRT program failed. -# On entry $0, contains the return value from ConfigureRT.exe. It shouldn't be changed. -!macro DiagConfigLayersAndVulkanDLL un -Function ${un}DiagConfigLayersAndVulkanDLL - # Report the failure - LogText "ConfigureRT.exe failed with return code $0" - - # Ignore errors - ClearErrors - -FunctionEnd -!macroend -!insertmacro DiagConfigLayersAndVulkanDLL "" -!insertmacro DiagConfigLayersAndVulkanDLL "un." - -# Start default section -Section - - # Turn on logging - LogSet on - - # If running on a 64-bit OS machine, disable registry re-direct since we're running as a 32-bit executable. - ${If} ${RunningX64} - - ${DisableX64FSRedirection} - SetRegView 64 - - ${Endif} - - # Create our temp directory, with minimal permissions - RmDir /R "$TEMP\VulkanRT" - SetOutPath "$TEMP\VulkanRT" - AccessControl::DisableFileInheritance $TEMP\VulkanRT - AccessControl::SetFileOwner $TEMP\VulkanRT "Administrators" - AccessControl::ClearOnFile $TEMP\VulkanRT "Administrators" "FullAccess" - AccessControl::SetOnFile $TEMP\VulkanRT "SYSTEM" "FullAccess" - AccessControl::GrantOnFile $TEMP\VulkanRT "Everyone" "ListDirectory" - AccessControl::GrantOnFile $TEMP\VulkanRT "Everyone" "GenericExecute" - AccessControl::GrantOnFile $TEMP\VulkanRT "Everyone" "GenericRead" - AccessControl::GrantOnFile $TEMP\VulkanRT "Everyone" "ReadAttributes" - StrCpy $1 10 - Call CheckForError - - # Check the registry to see if we are already installed - ReadRegStr $0 HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "InstallDir" - - # If the registry entry isn't there, it will throw an error as well as return a blank value. So, clear the errors. - ${If} ${Errors} - - # Nothing else to do since there is no previous install - ClearErrors - - ${Else} - - # Use the previous install directory, so we don't have to keep tracking every possible runtime install. - strcmp $INSTDIR $0 notinstalled - - ${If} $0 != "" - MessageBox MB_OK "The Windows ${APINAME} Runtime is already installed to $0. It will be re-installed to the same folder." /SD IDOK - Strcpy $INSTDIR $0 - ${Endif} - - notinstalled: - - ${EndIf} - - SetOutPath "$INSTDIR" - AccessControl::DisableFileInheritance $INSTDIR - AccessControl::SetFileOwner $INSTDIR "Administrators" - AccessControl::ClearOnFile $INSTDIR "Administrators" "FullAccess" - AccessControl::SetOnFile $INSTDIR "SYSTEM" "FullAccess" - AccessControl::GrantOnFile $INSTDIR "Everyone" "ListDirectory" - AccessControl::GrantOnFile $INSTDIR "Everyone" "GenericExecute" - AccessControl::GrantOnFile $INSTDIR "Everyone" "GenericRead" - AccessControl::GrantOnFile $INSTDIR "Everyone" "ReadAttributes" - File ${ICOFILE} - File VULKANRT_LICENSE.RTF - File /oname=LICENSE.txt ..\COPYRIGHT.txt - File Release\ConfigureRT.exe - StrCpy $1 15 - Call CheckForError - - # Add the signed uninstaller - !ifndef UNINSTALLER - SetOutPath $INSTDIR - File "Uninstall${PRODUCTNAME}.exe" - !endif - - StrCpy $1 20 - Call CheckForError - - # Reference count the number of times we have been installed. - # The reference count is stored in the registry value InstallCount - ReadRegDword $1 HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "InstallCount" - IntOp $1 $1 + 1 - StrCpy $IC $1 - - # We need to create a new folder for each install. Since we are using counted installs, - # an uninstall when the count is greater than one would result in the install - # count being decremented and nothing being removed. But Windows Add/Remove Programs - # generates a warning Window if the install dir for a package that is removed is not - # deleted. So we create a unique folder for each counted install. - # We fudge it a little and only create one folder, and rename it after each - # install/uninstall. - - # Create the install instance folder. We rename the install instance folder if it already exists. - # Then copy the uninstaller to it. - ${If} $IC > 2 - IntOp $1 $IC - 1 - Rename "$INSTDIR\Instance_$1" "$INSTDIR\Instance_$IC" - CopyFiles /SILENT "$INSTDIR\Uninstall${PRODUCTNAME}.exe" "$INSTDIR\Instance_$IC" - ${ElseIf} $IC = 2 - CreateDirectory "$INSTDIR\Instance_$IC" - CopyFiles /SILENT "$INSTDIR\Uninstall${PRODUCTNAME}.exe" "$INSTDIR\Instance_$IC" - ${EndIf} - - - # If the registry entry isn't there, it will throw an error as well as return a blank value. So, clear the errors. - ${If} ${Errors} - ClearErrors - ${EndIf} - - # Modify registry for Programs and Features - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "DisplayName" "${APINAME} Run Time Libraries ${PRODUCTVERSION}" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "UninstallString" "$INSTDIR\Uninstall${PRODUCTNAME}.exe" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "Publisher" "${PUBLISHER}" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "DisplayVersion" "${PRODUCTVERSION}" - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "EstimatedSize" ${ESTIMATEDSIZE} - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "DisplayIcon" "$\"$INSTDIR\${ICOFILE}$\"" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "InstallDir" "$INSTDIR" - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "InstallCount" $IC - - ${If} $IC > 1 - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "DisplayName" "${APINAME} Run Time Libraries ${PRODUCTVERSION}" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "UninstallString" "$INSTDIR\Instance_$IC\Uninstall${PRODUCTNAME}.exe" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "Publisher" "${PUBLISHER}" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "DisplayVersion" "${PRODUCTVERSION}" - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "EstimatedSize" ${ESTIMATEDSIZE} - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "DisplayIcon" "$\"$INSTDIR\${ICOFILE}$\"" - WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "InstallDir" "$INSTDIR\Instance_$IC" - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "InstallCount" $IC - ${EndIf} - - # Set SystemComponent to 1 for those instances that are not to be visible to Add/Remove Programs. - # Set SystemComponent to 0 for the instance that is to be visible to Add/Remove Programs. - ${If} $IC > 1 - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "SystemComponent" 1 - ${Else} - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "SystemComponent" 1 - ${EndIf} - - StrCpy $1 25 - Call CheckForError - - # Set up version number for file names - ${StrRep} $0 ${VERSION_BUILDNO} "." "-" - StrCpy $FileVersion ${VERSION_ABI_MAJOR}-${VERSION_API_MAJOR}-${VERSION_MINOR}-${VERSION_PATCH}-$0 - - # Complete remove the Vulkan Start Menu. Prior version of the Vulkan RT - # created Start Menu items, we don't do that anymore. - SetShellVarContext all - RmDir /R "$SMPROGRAMS\Vulkan" - ClearErrors - - # If running on a 64-bit OS machine - ${If} ${RunningX64} - - # 32-bit DLLs/EXEs destined for SysWOW64 - ########################################## - SetOutPath $WINDIR\SysWow64 - File /oname=${APILOWER}-$FileVersion.dll ..\build32\loader\RelWithDebInfo\${APILOWER}-${VERSION_ABI_MAJOR}.dll - File /oname=${APILOWER}info-$FileVersion.exe ..\build32\demos\RelWithDebInfo\${APILOWER}info.exe - StrCpy $1 30 - Call CheckForError - - # 64-bit DLLs/EXEs - ########################################## - SetOutPath $WINDIR\System32 - File /oname=${APILOWER}-$FileVersion.dll ..\build\loader\RelWithDebInfo\${APILOWER}-${VERSION_ABI_MAJOR}.dll - StrCpy $1 35 - Call CheckForError - - # vulkaninfo.exe - File /oname=${APILOWER}info-$FileVersion.exe ..\build\demos\RelWithDebInfo\${APILOWER}info.exe - SetOutPath "$INSTDIR" - File /oname=${APILOWER}info.exe ..\build\demos\RelWithDebInfo\${APILOWER}info.exe - File /oname=${APILOWER}info32.exe ..\build32\demos\RelWithDebInfo\${APILOWER}info.exe - StrCpy $1 40 - Call CheckForError - - # Else, running on a 32-bit OS machine - ${Else} - - # 32-bit DLLs/EXEs destined for SysWOW64 - ########################################## - SetOutPath $WINDIR\System32 - File /oname=${APILOWER}-$FileVersion.dll ..\build32\loader\RelWithDebInfo\${APILOWER}-${VERSION_ABI_MAJOR}.dll - StrCpy $1 50 - Call CheckForError - - # vulkaninfo.exe - File /oname=${APILOWER}info-$FileVersion.exe ..\build32\demos\RelWithDebInfo\${APILOWER}info.exe - SetOutPath "$INSTDIR" - File /oname=${APILOWER}info.exe ..\build32\demos\RelWithDebInfo\${APILOWER}info.exe - StrCpy $1 55 - Call CheckForError - - ${Endif} - - # Run the ConfigureRT program to copy the most recent version of - # vulkan--*.dll to vulkan-.dll, and to set up layer registry - # entries to use layers from the corresponding SDK - SetOutPath "$INSTDIR" - Call ConfigLayersAndVulkanDLL - ${If} $0 != 0 - SetOutPath "$INSTDIR" - Call DiagConfigLayersAndVulkanDLL - - # The program failed, and we don't know why. - # Simply configure system to use our loader and vulkaninfo. - MessageBox MB_OK "Warning!$\n$\nConfigureRT program called by VulkanRT Installer failed with error $0. This may result in an incomplete installation.$\n$\nWill configure system with Vulkan $FileVersion." /SD IDOK - ${If} ${RunningX64} - Delete $WINDIR\SysWow64\${APILOWER}-${VERSION_ABI_MAJOR}.dll - Delete $WINDIR\SysWow64\${APILOWER}info.exe - CopyFiles /SILENT $WINDIR\SysWow64\${APILOWER}-$FileVersion.dll $WINDIR\SysWow64\${APILOWER}-${VERSION_ABI_MAJOR}.dll - CopyFiles /SILENT $WINDIR\SysWow64\${APILOWER}info-$FileVersion.exe $WINDIR\SysWow64\${APILOWER}info.exe - ${Endif} - Delete $WINDIR\System32\${APILOWER}-${VERSION_ABI_MAJOR}.dll - Delete $WINDIR\System32\${APILOWER}info.exe - CopyFiles /SILENT $WINDIR\System32\${APILOWER}-$FileVersion.dll $WINDIR\System32\${APILOWER}-${VERSION_ABI_MAJOR}.dll - CopyFiles /SILENT $WINDIR\System32\${APILOWER}info-$FileVersion.exe $WINDIR\System32\${APILOWER}info.exe - ClearErrors - ${Endif} - StrCpy $1 60 - Call CheckForError - - # We are done using ConfigureRT.exe, delete it. It will be re-installed - # by the uninstaller when it needs to be run again during uninstall. - Delete ConfigureRT.exe - - # Finish logging and move log file to TEMP dir - LogSet off - Rename "$INSTDIR\install.log" "$TEMP\VulkanRT\installer.log" - -SectionEnd - -# Uninstaller section start -!ifdef UNINSTALLER -Section "uninstall" - # Turn on logging - SetOutPath "$TEMP\VulkanRT" - StrCpy $INSTDIR "$TEMP\VulkanRT" - LogSet on - - # If running on a 64-bit OS machine, disable registry re-direct since we're running as a 32-bit executable. - ${If} ${RunningX64} - - ${DisableX64FSRedirection} - SetRegView 64 - - ${Endif} - - # Look up the install dir and remove files from that directory. - ReadRegStr $0 HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "InstallDir" - StrCpy $IDir $0 - - StrCpy $1 65 - Call un.CheckForError - - SetOutPath "$IDir" - - # Set up version number for file names - ${StrRep} $0 ${VERSION_BUILDNO} "." "-" - StrCpy $FileVersion ${VERSION_ABI_MAJOR}-${VERSION_API_MAJOR}-${VERSION_MINOR}-${VERSION_PATCH}-$0 - - # Decrement the number of times we have been installed. - ReadRegDword $IC HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "InstallCount" - IntOp $1 $IC - 1 - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "InstallCount" $1 - - # Rename the install dir for this instance if is not the last uninstall - ${If} $IC > 2 - IntOp $1 $IC - 1 - Rename "$IDir\Instance_$IC" "$IDir\Instance_$1" - ${ElseIf} $IC = 2 - Delete /REBOOTOK "$IDir\Instance_$IC\Uninstall${PRODUCTNAME}.exe" - Rmdir /REBOOTOK "$IDir\Instance_$IC" - ${Endif} - StrCpy $1 70 - Call un.CheckForError - - # Modify registry for Programs and Features - - ${If} $IC > 1 - DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" - ${EndIf} - ${If} $IC > 2 - IntOp $IC $IC - 1 - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}-$IC" "SystemComponent" 1 - ${ElseIf} $IC = 2 - WriteRegDword HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" "SystemComponent" 1 - ${Else} - # Last uninstall - IntOp $IC $IC - 1 - DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}${PRODUCTVERSION}" - ${EndIf} - StrCpy $1 75 - Call un.CheckForError - - - # Install ConfigureRT.exe so we can run it. - # It will be deleted later when we remove the install directory. - File Release\ConfigureRT.exe - - # If running on a 64-bit OS machine - ${If} ${RunningX64} - - # Delete vulkaninfo.exe in C:\Windows\System32 and C:\Windows\SysWOW64 - Delete /REBOOTOK $WINDIR\SysWow64\${APILOWER}info.exe - Delete /REBOOTOK $WINDIR\System32\${APILOWER}info.exe - - # Delete vulkan-.dll in C:\Windows\System32 and C:\Windows\SysWOW64 - Delete /REBOOTOK $WINDIR\SysWow64\${APILOWER}-${VERSION_ABI_MAJOR}.dll - Delete /REBOOTOK $WINDIR\System32\${APILOWER}-${VERSION_ABI_MAJOR}.dll - - # Else, running on a 32-bit OS machine - ${Else} - - # Delete vulkaninfo.exe in C:\Windows\System32 - Delete /REBOOTOK $WINDIR\System32\${APILOWER}info.exe - - # Delete vulkan-.dll in C:\Windows\System32 - Delete /REBOOTOK $WINDIR\System32\${APILOWER}-${VERSION_ABI_MAJOR}.dll - - ${EndIf} - StrCpy $1 80 - Call un.CheckForError - - # If Ref Count is zero, remove files in C:\Windows\System32 and C:\Windows\SysWow64 - ${If} $IC <= 0 - - ${If} ${RunningX64} - # Delete vulkaninfo.exe in C:\Windows\System32 and C:\Windows\SysWOW64 - Delete /REBOOTOK "$WINDIR\SysWow64\${APILOWER}info-$FileVersion.exe" - Delete /REBOOTOK "$WINDIR\System32\${APILOWER}info-$FileVersion.exe" - # Delete vulkan-----.dll from sys dirs - Delete /REBOOTOK $WINDIR\SysWow64\${APILOWER}-$FileVersion.dll - Delete /REBOOTOK $WINDIR\System32\${APILOWER}-$FileVersion.dll - ${Else} - # Delete vulkaninfo.exe in C:\Windows\System32 - Delete /REBOOTOK "$WINDIR\System32\${APILOWER}info-$FileVersion.exe" - # Delete vulkan-----.dll from sys dir - Delete /REBOOTOK $WINDIR\System32\${APILOWER}-$FileVersion.dll - ${EndIf} - - ${Endif} - - # Run the ConfigureRT.exe program to copy the most recent version of - # vulkan--*.dll to vulkan-.dll, and to set up layer registry - # entries to use layers from the corresponding SDK - SetOutPath "$IDir" - Call un.ConfigLayersAndVulkanDLL - ${If} $0 != 0 - SetOutPath "$IDir" - Call un.DiagConfigLayersAndVulkanDLL - MessageBox MB_OK "Warning!$\n$\nConfigureRT program called by ${APILOWER} Runtime Installer failed with error $0. This may result in an incomplete uninstall.$\n$\nVulkan $FileVersion has been uninstalled from your system." /SD IDOK - ${If} ${RunningX64} - Delete $WINDIR\SysWow64\${APILOWER}-${VERSION_ABI_MAJOR}.dll - Delete $WINDIR\SysWow64\${APILOWER}info.exe - ${Endif} - Delete $WINDIR\System32\${APILOWER}-${VERSION_ABI_MAJOR}.dll - Delete $WINDIR\System32\${APILOWER}info.exe - ClearErrors - ${Else} - StrCpy $1 85 - ${Endif} - Call un.CheckForError - - # Remove ConfigureRT regardless of the ref count - Delete /REBOOTOK "$IDir\ConfigureRT.exe" - - # If Ref Count is zero, remove install dir - ${If} $IC <= 0 - - # Remove files in install dir - Delete /REBOOTOK "$IDir\VULKANRT_LICENSE.rtf" - Delete /REBOOTOK "$IDir\LICENSE.txt" - Delete /REBOOTOK "$IDir\Uninstall${PRODUCTNAME}.exe" - Delete /REBOOTOK "$IDir\V.ico" - Delete /REBOOTOK "$IDir\${APILOWER}info.exe" - - # If running on a 64-bit OS machine - ${If} ${RunningX64} - Delete /REBOOTOK "$IDir\${APILOWER}info32.exe" - ${EndIf} - - StrCpy $1 90 - Call un.CheckForError - - # Need to do a SetOutPath to something outside of install dir, - # or the uninstall will think install dir is busy - SetOutPath "$TEMP" - - # Remove install directories - StrCpy $0 "$IDir" - Call un.DeleteDirIfEmpty - StrCpy $0 "$PROGRAMFILES\${PRODUCTNAME}" - Call un.DeleteDirIfEmpty - ClearErrors - - # If any of the remove commands failed, request a reboot - IfRebootFlag 0 noreboot - MessageBox MB_YESNO "A reboot is required to finish the uninstall. Do you wish to reboot now?" /SD IDNO IDNO returnerror - Reboot - - returnerror: - - # Set an error message to output because we should reboot but didn't (whether because silent uninstall or user choice) - SetErrorLevel 3 # ERROR_TOO_MANY_OPEN_FILES - - noreboot: - - ${Endif} - - StrCpy $1 95 - Call un.CheckForError - - # Finish logging - LogSet off - Rename "$INSTDIR\install.log" "$TEMP\VulkanRT\uninstaller.log" - -SectionEnd -!endif - -Function brandimage - SetOutPath "$TEMP" - SetFileAttributes V.bmp temporary - File V.bmp - SetBrandingImage "$TEMP/V.bmp" -Functionend - - -Function un.brandimage - SetOutPath "$TEMP" - SetFileAttributes V.bmp temporary - File V.bmp - SetBrandingImage "$TEMP/V.bmp" -Functionend - -Function un.DeleteDirIfEmpty - FindFirst $R0 $R1 "$0\*.*" - strcmp $R1 "." 0 NoDelete - FindNext $R0 $R1 - strcmp $R1 ".." 0 NoDelete - ClearErrors - FindNext $R0 $R1 - IfErrors 0 NoDelete - FindClose $R0 - Sleep 1000 - RMDir "$0" - NoDelete: - FindClose $R0 -FunctionEnd - -# Check for errors during install. If we hit an error, stop, uninstall what we've put in so far, and quit. -# NOTE: We return a non-zero error code as well. -Function CheckForError - ${If} ${Errors} - # IHV's using this install may want no message box. - MessageBox MB_OK|MB_ICONSTOP "${errorMessage1}${errorMessage2}Errorcode: $1$\r$\n" /SD IDOK - - # Finish logging and move log file to TEMP dir - LogSet off - Rename "$INSTDIR\install.log" "$TEMP\VulkanRT\installer.log" - - # Copy the uninstaller to a temp folder of our own creation so we can completely - # delete the old contents. - SetOutPath "$TEMP\VulkanRT" - CopyFiles "$INSTDIR\Uninstall${PRODUCTNAME}.exe" "$TEMP\VulkanRT" - - # Do uninstall using the version in the temporary folder. - ExecWait '"$TEMP\VulkanRT\Uninstall${PRODUCTNAME}.exe" /S _?=$INSTDIR' - - # Delete the copy of the uninstaller we ran - Delete /REBOOTOK "$TEMP\VulkanRT\Uninstall${PRODUCTNAME}.exe" - - # Set an error message to output - SetErrorLevel $1 - - Quit - ${EndIf} -FunctionEnd - -# Check for errors during uninstall. If we hit an error, don't attempt -# to do anything. Just set a non-zero return code and continue. -Function un.CheckForError - ${If} ${Errors} - # IHV's using this install may want no message box. - MessageBox MB_OK|MB_ICONSTOP "${errorMessage1un}${errorMessage2}Errorcode: $1$\r$\n" /SD IDOK - - # Set an error message to output - SetErrorLevel $1 - - ${EndIf} -FunctionEnd diff --git a/windowsRuntimeInstaller/NSIS_Security.patch b/windowsRuntimeInstaller/NSIS_Security.patch deleted file mode 100644 index b275aae0..00000000 --- a/windowsRuntimeInstaller/NSIS_Security.patch +++ /dev/null @@ -1,58 +0,0 @@ -diff --git a/nsis-3.0b3-src/SCons/Config/ms b/nsis-3.0b3-src/SCons/Config/ms -index 32d3d33..d2c4d25 100644 ---- a/nsis-3.0b3-src/SCons/Config/ms -+++ b/nsis-3.0b3-src/SCons/Config/ms -@@ -16,7 +16,7 @@ def entry(x,u): - - defenv['ENTRY_FLAG'] = entry - defenv['MAP_FLAG'] = '/map' --defenv['NODEFLIBS_FLAG'] = '/NODEFAULTLIB' -+#defenv['NODEFLIBS_FLAG'] = '/NODEFAULTLIB' - defenv['C_FLAG'] = '/TC' - defenv['CPP_FLAG'] = '/TP' - defenv['CPP_REQUIRES_STDLIB'] = 0 -@@ -29,7 +29,7 @@ defenv['STDCALL'] = '__stdcall' - msvs_version = float(defenv['MSVS_VERSION'].replace('Exp','')) - if msvs_version >= 8.0: - defenv['EXCEPTION_FLAG'] = '/EHsc' -- defenv.Append(CCFLAGS = ['/GS-']) -+ defenv.Append(CCFLAGS = ['/GS']) - defenv.Append(CPPDEFINES = ['_CRT_SECURE_NO_WARNINGS', '_CRT_NONSTDC_NO_WARNINGS', '_CRT_SECURE_NO_DEPRECATE', '_CRT_NON_CONFORMING_SWPRINTFS']) - defenv['MSVCRT_FLAG'] = '/MT' # Avoid msvcr?0.dll dependency - else: -@@ -43,6 +43,10 @@ if msvs_version >= 11.0: - defenv['SUBSYS_CON'] = '/subsystem:console,5.01' # support windows xp - defenv['SUBSYS_WIN'] = '/subsystem:windows,5.01' # support windows xp - -+if msvs_version >= 14.0: -+ defenv.Append(CCFLAGS = ['/guard:cf']) -+ defenv.Append(LINKFLAGS = ['/guard:cf']) -+ - ### defines - - defenv.Append(CPPDEFINES = [('NSISCALL', '$STDCALL')]) -@@ -143,9 +147,9 @@ stub_env.Append(CCFLAGS = ['/Fa${TARGET}.lst']) # listing file name - stub_env.Append(LINKFLAGS = ['$NODEFLIBS_FLAG']) # no default libraries - stub_env.Append(LINKFLAGS = ['$MAP_FLAG']) # generate map file - --if msvs_version >= 10.0: -- # no relocations that our resource editor ignores -- stub_env.Append(LINKFLAGS = ['/FIXED']) -+#if msvs_version >= 10.0: -+# # no relocations that our resource editor ignores -+# stub_env.Append(LINKFLAGS = ['/FIXED']) - - stub_uenv = stub_env.Clone() - stub_uenv.Append(CPPDEFINES = ['_UNICODE', 'UNICODE']) -diff --git a/nsis-3.0b3-src/Source/exehead/Main.c b/nsis-3.0b3-src/Source/exehead/Main.c -index eb231e7..e4642ce 100644 ---- a/nsis-3.0b3-src/Source/exehead/Main.c -+++ b/nsis-3.0b3-src/Source/exehead/Main.c -@@ -84,6 +84,7 @@ void *g_SHGetFolderPath; - NSIS_ENTRYPOINT_GUINOCRT - EXTERN_C void NSISWinMainNOCRT() - { -+ __security_init_cookie(); - int ret = 0; - const TCHAR *m_Err = _LANG_ERRORWRITINGTEMP; - diff --git a/windowsRuntimeInstaller/README.txt b/windowsRuntimeInstaller/README.txt deleted file mode 100644 index 4b1f189d..00000000 --- a/windowsRuntimeInstaller/README.txt +++ /dev/null @@ -1,153 +0,0 @@ -This folder contains the files required for building the Windows Vulkan -Runtime Installer Package. - -To build the Vulkan Runtime Installer: - - 1. Install Nullsoft Install System (NSIS) version 3.0b3. The - version of NSIS needed for building the Vulkan Runtime Installer - must support logging (i.e. must have been built with NSIS_CONFIG_LOG=yes - set), and must support long strings (i.e. NSIS_MAX_STRLEN=8192 must be - set). The NSIS AccessControl plug-in should also be installed. (Available - from http://nsis.sourceforge.net/AccessControl_plug-in.) - - 1a. Note that the NSIS binary version available at - http://nsis.sourceforge.net/Download is not built with - NSIS_CONFIG_LOG=yes and NSIS_MAX_STRLEN=8192 set. Also, changes to need - to be made to NSIS to increase the security of the Runtime Installer. - - The source for NSIS 3.0.b3 can be downloaded from - https://sourceforge.net/projects/nsis/files/NSIS%203%20Pre-release/3.0b3/nsis-3.0b3-src.tar.bz2/download - - Instructions for building NSIS are available at - http://nsis//sourceforge.net/Docs/AppendixG.html. - - The security changes to NSIS involve adding the /DYMANICBASE, /GS and - /guard:cf options to the NSIS compile/link steps, so that the Runtime - Installer and Uninstaller are built with address space layout randomization, - buffer overrun checks and control flow guard. - - The security changes to NSIS can be made by applying the patch in the - NSIS_Security.patch file in this folder. - - After you have applied the security patch, build NSIS with this command: - - scons SKIPUTILS="NSIS Menu","MakeLangId" UNICODE=yes \ - ZLIB_W32=\zlib-1.2.7-win32-x86 NSIS_MAX_STRLEN=8192 \ - NSIS_CONFIG_LOG=yes NSIS_CONFIG_LOG_TIMESTAMP=yes \ - APPEND_CCFLAGS="/DYNAMICBASE /Zi" APPEND_LINKFLAGS="/DYNAMICBASE \ - /DEBUG /OPT:REF /OPT:ICF" SKIPDOC=all dist-zip - - This will create a zip file in the nsis-3.0.b3-src directory. Unpack - the zip file anywhere on your system. The resulting tree will contain a - Plugins directory. Install the NSIS AccessControl plugin in this directory. - Add the Bin directory to your PATH enviroment variable so that the - CreateInstaller.sh step below will use your custom-built version of - NSIS. - - Before using NSIS and creating the installer, make sure that all shared - libraries in your custom-built version of NSIS have the DYNAMIC_BASE and NX_COMPAT - flags set. If they are not set, you will have to rebuild those libraries with - those options enabled. - - 2. Build Vulkan-LoaderAndValidationLayers as described in ../BUILD.md. - - 3. Edit the InstallerRT.nsi file in this folder and modify the following - lines to match the version of the Windows Vulkan Runtime you wish to - build: - - !define VERSION_ABI_MAJOR - !define VERSION_API_MAJOR - !define VERSION_MINOR - !define VERSION_PATCH - !define VERSION_BUILDNO - !define PUBLISHER - - 4. Edit the CreateInstaller.sh file and replace SIGNFILE with your - command and necessary args for signing an executable. If you don't - wish to sign the uninstaller, you can comment out that line. - - 5. Run the CreateInstaller.sh script from a Cygwin bash command prompt. - The Cygwin bash shell must be running as Administrator. The Windows - Vulkan Runtime Installer will be created in this folder. The name - of the installer file is VulkanRT--Installer.exe. - - -Some notes on the behavior of the Windows Vulkan Runtime Installer: - - o When VulkanRT--Installer.exe is run on a 64-bit version - of Windows, it will install both the 32 and 64 bit versions of - the Vulkan runtime. When it is run on a 32-bit version of - Windows, it will install the 32 bit version of the Vulkan runtime. - - o The VulkanRT--Installer.exe created with the above steps - can be run in silent mode by using the /S command line option when - invoking the installer. - - o If the Vulkan Runtime is already installed on the system, - subsequent installs of the same version of the Vulkan Runtime - will be installed to the same folder to which it is was - previously installed. - - o The Vulkan Runtime Installer uses "counted" installs. If the - same version of the Vulkan Runtime is installed multiple times - on a system, the Vulkan Runtime must be uninstalled the same - number of times before it is completely removed from the system. - - o If the Vulkan Runtime is already installed on a system and a - different version is subsequently installed, both versions will - then co-exist on the system. The Vulkan Runtime Installer does - not remove prior versions of the Vulkan Runtime when a newer - version is installed. - - o The Vulkan Runtime can be uninstalled from Control Panel -> - Programs and Features. It can also be uninstalled by running - UninstallVulkanRT.exe in the install folder. The uninstall can - be run in silent mode by using the /S command line option - when invoking the uninstaller. The location of the the - UninstallVulkanRT.exe can be found in the registry value - HKLM\Software\Microsoft\Windows\CurrentVersion\Uninstall\ - VulkanRT\UninstallString - - o The Vulkan Runtime Installer installs the Vulkan loader as - C:\Windows\System32\vulkan-.dll. It then runs the - program ConfigureRT.exe (the source for which is included), that - compares versions of the loader in C:\Windows\System32 that have - the same VERSION_ABI_MAJOR as the version being installed. The - script selects the most recent one of these loader files and - copies it to C:\Windows\System32\vulkan-.dll. - For example, during the install of Vulkan Runtime version 2.0.1.1, - the following files might be present in C:\Windows\System32: - - vulkan-1-1-0-2-3.dll - vulkan-1-2-0-1-0.dll - vulkan-1-2-0-1-1.dll - - [Note that the first "1" in the above files is VERSION_ABI_MAJOR. - The other numbers identify the release version.] The script - will copy the most recent one of these files (in this case - vulkan-1-2-0-1-1.dll) to vulkan-1.dll. This is repeated for - C:\Windows\SYSWOW64 on 64-bit Windows systems to set up the - 32-bit loader. - - o The Vulkan Runtime Uninstaller returns an exit code of 0-9 - to indicate success. An exit code of 3 indicates success, but - a reboot is required to complete the uninstall. All other - exit codes indicate failure. If the Uninstaller returns a - failure exit code, it will have simply exited when the failure - was detected and will not have attempted to do further uninstall - work. - - o The ProductVersion of the installer executable (right click on - the executable, Properties, then the Details tab) can be used - by other installers/uninstallers to find the path to the - uninstaller for the Vulkan Runtime in the Windows registry. - This ProductVersion should always be identical to in: - - HKLM\Software\Microsoft\Windows\CurrentVersion\Uninstall\VulkanRT\UninstallString - - o The Installer and Uninstaller create log files, which can be - found in the VulkanRT folder in the current TEMP folder. - (The TEMP folder is generally identified by the TEMP environment - variable). In addition to installer/uninstaller logs files, - the folder also contains a log from the last run of the - ConfigureRT.exe program. diff --git a/windowsRuntimeInstaller/V.bmp b/windowsRuntimeInstaller/V.bmp deleted file mode 100644 index dea3353c..00000000 Binary files a/windowsRuntimeInstaller/V.bmp and /dev/null differ diff --git a/windowsRuntimeInstaller/V.ico b/windowsRuntimeInstaller/V.ico deleted file mode 100644 index 61166983..00000000 Binary files a/windowsRuntimeInstaller/V.ico and /dev/null differ diff --git a/windowsRuntimeInstaller/VULKANRT_LICENSE.rtf b/windowsRuntimeInstaller/VULKANRT_LICENSE.rtf deleted file mode 100644 index c23139b2..00000000 Binary files a/windowsRuntimeInstaller/VULKANRT_LICENSE.rtf and /dev/null differ diff --git a/windowsRuntimeInstaller/configure_runtime.c b/windowsRuntimeInstaller/configure_runtime.c deleted file mode 100644 index ebf67748..00000000 --- a/windowsRuntimeInstaller/configure_runtime.c +++ /dev/null @@ -1,764 +0,0 @@ -/****************************************************************************** - * Copyright (c) 2016 The Khronos Group - * Copyright (c) 2016 Valve Corporation - * Copyright (c) 2016 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you man not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is destributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language govering permissions and - * limitations under the License. - * - * Author: Lenny Komow - * - *****************************************************************************/ - -/* - * This program is used by the Vulkan Runtime Installer/Uninstaller to: - * - Copy the most recent vulkan-*.dll in C:\Windows\System32 - * to vulkan.dll - * - Copy the most recent version of vulkaninfo--*.exe in - * C:\Windows\System32 to vulkaninfo.exe - * - The same thing is done for those files in C:\Windows\SysWOW64, but - * only on a 64-bit target - * - Set the layer registry entried to point to the layer json files in - * the Vulkan SDK associated with the most recent vulkan*.dll - * - * The program must be called with the following parameters: - * --major-abi: A single number specifying the major abi version - */ - -// Compile with: `cl.exe configure_runtime.c /link advapi32.lib` -// Be sure to use the x86 version of cl.exe - -#include -#include -#include -#include -#include -#include - -// This hack gets Visual Studio 2013 to handle C99 stuff properly -// If we drop support for 2013, it would be a good idea to remove this -#if _MSC_VER < 1900 -#define inline __inline -#define snprintf _snprintf -#endif - -#if defined(_WIN64) -#error "This program is designed only as a 32-bit program. It should not be built as 64-bit." -#endif - -#define COPY_BUFFER_SIZE (1024) -#define CHECK_ERROR(statement) { int error = (statement); if(error) return error; } -#define CHECK_ERROR_HANDLED(statement, handler) { int error = (statement); if(error) { { handler } return error; } } -#define SDK_VERSION_BUFFER_SIZE (64) - -enum Platform -{ - PLATFORM_X64, - PLATFORM_X86, -}; - -#pragma pack(1) -struct SDKVersion -{ - long major; - long minor; - long patch; - long build; - char extended[SDK_VERSION_BUFFER_SIZE]; -}; - -const char* FLAG_ABI_MAJOR = "--abi-major"; -const char* FLAG_API_NAME = "--api-name"; -const char* PATH_SYSTEM32 = "\\SYSTEM32\\"; -const char* PATH_SYSWOW64 = "\\SysWOW64\\"; - -inline size_t max_s(size_t a, size_t b) { return a > b ? a : b; } -inline size_t min_s(size_t a, size_t b) { return a > b ? a : b; } - -// Add the registry entries for all explicit layers -// -// log (input) - Logging file stream -// install_path (input) - The installation path of the SDK which provides the layers -// platform (input) - The platform to set the installation for (x64 or x86) -// api_name (input) - The api name to use when working with registries -// Returns: Zero on success, an error code on failure -int add_explicit_layers(FILE* log, const char* install_path, enum Platform platform, const char* api_name); - -// Compare two sdk versions -// -// Returns: Zero if they are equal, below zero if a predates b, greater than zero if b predates a -int compare_versions(const struct SDKVersion* a, const struct SDKVersion* b); - -// Locate all of the SDK installations -// -// api_name (input) - The api name to use when working with registries -// install_paths (output) - A poiner to an array of the installations paths -// install_versions (output) - A pointer to an array of the SDK versions -// count (output) - A pointer to the number of items in each array -// Returns: Zero on success, an error code on failure -// -// Both install_paths and install_versions are allocated on the heap. To free them properly, -// call free_installations(), even if this function returned an error code. The orders of -// install_paths and install_versions match, so (*install_paths)[2] is guaranteed to match -// (*install_versions)[2] -int find_installations(const char* api_name, char*** install_paths, struct SDKVersion** install_versions, - size_t* count); - -// Free the memory allocated by find_installations() -void free_installations(char** install_paths, struct SDKVersion* install_versions, size_t count); - -// Parse command line arguments for the program -// -// log (input) - Logging file stream -// argc (input) - The argument count -// argv (input) - An array of argument strings -// abi_major (output) - The major abi version from the arguments -// api_name (output) - The api name to use when working with registries and system files -// Returns: Zero on success, an error code on failure -int parse_arguments(FILE* log, int argc, char** argv, long* abi_major, const char** api_name); - -// Read the version from a string -// -// version_string (input) - A string in the format ..... -// version (output) - The version indicated by the input string -// Returns: Zero on success, an error code on failure -int read_version(const char* version_string, struct SDKVersion* version); - -// Read the version from a filename -// -// filename (input) - The name of a .dll or .exe file, in the format -// somename------.dll -// version (output) - The versions indicated by the input string -// Returns: Zero on success, an error code on failure -int read_version_from_filename(const char* filename, struct SDKVersion* version); - -// Remove explicit layers from the Windows registry -// -// log (input) - Loggin file stream -// install_paths (input) - An array of every vulkan installation path -// count (input) - The number of vulkan installations -// platform (input) - The platform (x64 or x86) of the registry to use (both exist on x64) -// api_name (input) - The api name to use when working with registries -// Returns: Zero on success, an error code on failure -int remove_explicit_layers(FILE* log, const char** install_paths, size_t count, enum Platform platform, - const char* api_name); - -// Update all explicity layers in the windows registry -// -// log (input) - Logging file stream -// platform (input) - The platform of the OS (both registries will be modified if this is x64) -// version (input) - The version that should be set to current (if it exists) -// api_name (input) - The api name to use when working with registries -// Returns: Zero on success, an error code on failure -int update_registry_layers(FILE* log, enum Platform platform, const struct SDKVersion* version, - const char* api_name); - -// Update a single vulkan system file (vulkan.dll or vulkaninfo.exe) -// -// log (input) - Loggin file stream -// name (input) - The name (excuding file extension) of the file to be updated -// extension (input) - The file extensions of the file to be updated -// path (input) - The directory of the file (usually System32 or SysWOW64) -// abi_major (input) - The ABI major version to be updated -// append_abi_major (input) - Whether or not the ABI number should be appended to the filename -// latest_version (output) - The version of the runtime which the file was updated to -// Returns: Zero on success, an error code on failure -int update_system_file(FILE* log, const char* name, const char* extension, const char* path, - long abi_major, bool append_abi_major, struct SDKVersion* latest_version); - -// Update vulkan.dll and vulkaninfo.exe in all of the windows directories (System32 and SysWOW64) -// -// log (input) - Loging file stream -// abi_major (input) - The ABI major version of the files that should be used -// platform (input) - The platform for the current OS -// api_name (input) - The api name to use when working with system files -// latest_runtime_version (output) - The version that the runtime files were updated to -int update_windows_directories(FILE* log, long abi_major, enum Platform platform, const char* api_name, - struct SDKVersion* latest_runtime_version); - -int main(int argc, char** argv) -{ - // Get the OS platform (x86 or x64) - BOOL is_64_bit; - IsWow64Process(GetCurrentProcess(), &is_64_bit); - enum Platform platform = is_64_bit ? PLATFORM_X64 : PLATFORM_X86; - - FILE* log = fopen("configure_rt.log", "w"); - if(log == NULL) { - return 10; - } - - // Parse the arguments to get the abi version and the number of bits of the OS - long abi_major; - const char* api_name; - CHECK_ERROR_HANDLED(parse_arguments(log, argc, argv, &abi_major, &api_name), { fclose(log); }); - - fprintf(log, "API Name: %s\n", api_name); - - // This makes System32 and SysWOW64 not do any redirection (well, until 128-bit is a thing) - PVOID useless; - Wow64DisableWow64FsRedirection(&useless); - - // Update System32 (on all systems) and SysWOW64 on 64-bit system - struct SDKVersion latest_runtime_version; - CHECK_ERROR_HANDLED(update_windows_directories(log, abi_major, platform, api_name, - &latest_runtime_version), { fclose(log); }); - - // Update the explicit layers that are set in the windows registry - CHECK_ERROR_HANDLED(update_registry_layers(log, platform, &latest_runtime_version, api_name), - { fclose(log); }); - - fclose(log); - return 0; -} - -int add_explicit_layers(FILE* log, const char* install_path, enum Platform platform, const char* api_name) -{ - switch(platform) - { - case PLATFORM_X64: - fprintf(log, "Updating x64 explicit layers to path: %s\n", install_path); - break; - case PLATFORM_X86: - fprintf(log, "Updating x86 explicit layers to path: %s\n", install_path); - break; - } - - const char* registry_pattern = "SOFTWARE\\Khronos\\%s\\ExplicitLayers"; - int registry_size = snprintf(NULL, 0, registry_pattern, api_name) + 1; - char* registry_key = malloc(registry_size); - snprintf(registry_key, registry_size, registry_pattern, api_name); - - // If this is a 32 bit system, we allow redirection to point this at the 32-bit registries. - // If not, we add the flag KEY_WOW64_64KEY, to disable redirection for this node. - HKEY hKey; - REGSAM flags = KEY_ALL_ACCESS; - if(platform == PLATFORM_X64) { - flags |= KEY_WOW64_64KEY; - } - - // Create (if needed) and open the explicit layer key - if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, registry_key, 0, NULL, REG_OPTION_NON_VOLATILE, flags, - NULL, &hKey, NULL) != ERROR_SUCCESS) { - free(registry_key); - return 20; - } - - const char* pattern = platform == PLATFORM_X64 ? "%s\\Bin\\VkLayer*.json" : "%s\\Bin32\\VkLayer*.json"; - int filter_size = snprintf(NULL, 0, pattern, install_path) + 1; - if(filter_size < 0) { - return 30; - } - char* filter = malloc(filter_size); - snprintf(filter, filter_size, pattern, install_path); - - WIN32_FIND_DATA find_data; - HANDLE find = FindFirstFile(filter, &find_data); - free(filter); - for(bool at_end = (find != INVALID_HANDLE_VALUE); at_end; - at_end = FindNextFile(find, &find_data)) { - - const char* layer_pattern = platform == PLATFORM_X64 ? "%s\\Bin\\%s" : "%s\\Bin32\\%s"; - int layer_size = snprintf(NULL, 0, layer_pattern, install_path, find_data.cFileName) + 1; - if(layer_size < 0) { - free(registry_key); - return 40; - } - char* layer = malloc(layer_size); - snprintf(layer, layer_size, layer_pattern, install_path, find_data.cFileName); - - fprintf(log, "Adding explicit layer: %s\n", layer); - - DWORD zero = 0; - LSTATUS err = RegSetValueEx(hKey, layer, zero, REG_DWORD, (BYTE*) &zero, sizeof(DWORD)); - free(layer); - if(err != ERROR_SUCCESS) { - free(registry_key); - return 50; - } - } - - RegCloseKey(hKey); - free(registry_key); - return 0; -} - -int compare_versions(const struct SDKVersion* a, const struct SDKVersion* b) -{ - // Compare numerical versions - for(int i = 0; i < 4; ++i) { - long* a_current = ((long*) a) + i; - long* b_current = ((long*) b) + i; - - if(*a_current < *b_current) { - return -4 + i; - } else if(*b_current < *a_current) { - return 4 - i; - } - } - - // An empty string should be considered greater (and therefore more recent) than one with test - if(a->extended[0] == '\0' && b->extended[0] != '\0') { - return 1; - } else if(b->extended[0] == '\0' && a->extended[0] != '\0') { - return -1; - } - - // Otherwise, just do a strncmp - return strncmp(a->extended, b->extended, SDK_VERSION_BUFFER_SIZE); -} - -int find_installations(const char* api_name, char*** install_paths, struct SDKVersion** install_versions, size_t* count) -{ - *install_paths = malloc(sizeof(char*) * 64); - *install_versions = malloc(sizeof(struct SDKVersion) * 64); - *count = 0; - - // We want the 64-bit registries on 64-bit windows, and the 32-bit registries on 32-bit Windows. - // KEY_WOW64_64KEY accomplishes this because it gets ignored on 32-bit Windows. - HKEY hKey; - if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", - 0, KEY_READ | KEY_WOW64_64KEY, &hKey) != ERROR_SUCCESS) { - return 90; - } - - size_t api_len = strlen(api_name); - char* sdk_id = malloc(api_len + 4); - strcpy(sdk_id, api_name); - strcpy(sdk_id + api_len, "SDK"); - - DWORD keyCount, keyLen; - RegQueryInfoKey(hKey, NULL, NULL, NULL, &keyCount, NULL, NULL, NULL, NULL, NULL, NULL, NULL); - for(int i = 0; i < keyCount; ++i) { - TCHAR name[COPY_BUFFER_SIZE]; - DWORD nameSize = COPY_BUFFER_SIZE; - RegEnumKeyEx(hKey, i, name, &nameSize, NULL, NULL, NULL, NULL); - - if(strncmp(sdk_id, name, api_len + 3)) { - continue; - } - - HKEY subKey; - if(RegOpenKeyEx(hKey, name, 0, KEY_READ | KEY_WOW64_64KEY, &subKey) != ERROR_SUCCESS) { - continue; - } - - bool found_installation = false, found_version = false; - DWORD valueCount; - RegQueryInfoKey(subKey, NULL, NULL, NULL, NULL, NULL, NULL, &valueCount, NULL, NULL, NULL, NULL); - for(int j = 0; j < valueCount; ++j) { - - TCHAR name[COPY_BUFFER_SIZE], value[COPY_BUFFER_SIZE]; - DWORD type, nameSize = COPY_BUFFER_SIZE, valSize = COPY_BUFFER_SIZE; - LSTATUS ret = RegEnumValue(subKey, j, name, &nameSize, NULL, &type, value, &valSize); - if(type == REG_SZ && !strcmp("InstallDir", name)) { - *install_paths = realloc(*install_paths, sizeof(char*) * ((*count) + 1)); - (*install_paths)[*count] = malloc(sizeof(char) * COPY_BUFFER_SIZE); - strcpy((*install_paths)[*count], value); - found_installation = true; - } else if(type == REG_SZ && !strcmp("DisplayVersion", name)) { - *install_versions = realloc(*install_versions, sizeof(struct SDKVersion) * ((*count) + 1)); - CHECK_ERROR(read_version(value, (*install_versions) + *count)); - found_version = true; - } - - if(found_installation && found_version) { - ++(*count); - break; - } - } - RegCloseKey(subKey); - - if(!(found_installation && found_version)) { - RegCloseKey(hKey); - free(sdk_id); - return 100; - } - } - RegCloseKey(hKey); - free(sdk_id); - - return 0; -} - -void free_installations(char** install_paths, struct SDKVersion* install_versions, size_t count) -{ - for(size_t i = 0; i < count; ++i) { - free(install_paths[i]); - } - free(install_paths); - free(install_versions); -} - -int parse_arguments(FILE* log, int argc, char** argv, long* abi_major, const char** api_name) -{ - *abi_major = 0; - *api_name = "Vulkan"; - - // Parse arguments - for(int i = 0; i < argc; ++i) { - if(!strcmp(argv[i], FLAG_ABI_MAJOR)) { - if(i + 1 == argc) { - fprintf(log, "ERROR: No value given for flag %s.\n", FLAG_ABI_MAJOR); - return 110; - } - *abi_major = strtol(argv[++i], NULL, 10); - if(*abi_major == 0) { - fprintf(log, "ERROR: Unable to parse ABI major version as integer.\n"); - return 120; - } - } - if(!strcmp(argv[i], FLAG_API_NAME)) { - if(i + 1 == argc) { - fprintf(log, "ERROR: No value given for flag %s.\n", FLAG_API_NAME); - return 124; - } - *api_name = argv[++i]; - } - } - - // Check that we have everything we need - if(*abi_major == 0 ) { - fprintf(log, "ERROR: Flag %s must be provided.\n", FLAG_ABI_MAJOR); - return 130; - } - - // It all worked fine - fprintf(log, "Found ABI: %ld\n\n", *abi_major); - return 0; -} - -int read_version(const char* version_string, struct SDKVersion* version) -{ - size_t borders[4], dot_count = 0, i; - for(i = 0; dot_count < 3 && version_string[i] != '\0'; ++i) { - if(version_string[i] == '.') { - borders[dot_count++] = i + 1; - } - } - borders[3] = i + 1; - - if(dot_count < 3) { - return 140; - } - - // Read the version number - version->major = strtol(version_string, NULL, 10); - version->minor = strtol(version_string + borders[0], NULL, 10); - version->patch = strtol(version_string + borders[1], NULL, 10); - version->build = strtol(version_string + borders[2], NULL, 10); - - strncpy(version->extended, version_string + borders[3] + 1, - min_s(SDK_VERSION_BUFFER_SIZE - 1, strlen(version_string + borders[3] + 1))); - - return 0; -} - -int read_version_from_filename(const char* filename, struct SDKVersion* version) -{ - size_t borders[5], dash_count = 0; - - // Locate all of the dashes that divides different version numbers - size_t i; - for(i = 0; dash_count < 5; ++i) { - if(filename[i] == '-' && dash_count == 0) { - ++dash_count; - } else if(filename[i] == '-') { - borders[dash_count++ - 1] = i + 1; - } else if(filename[i] == '\0') { - return 150; - } - } - borders[4] = i + 1; - - // Read the version number - version->major = strtol(filename + borders[0], NULL, 10); - version->minor = strtol(filename + borders[1], NULL, 10); - version->patch = strtol(filename + borders[2], NULL, 10); - version->build = strtol(filename + borders[3], NULL, 10); - - if(strcmp(filename + borders[4] + 1, "dll") && strcmp(filename + borders[4] + 1, "exe")) { - strncpy(version->extended, filename + borders[4] + 1, SDK_VERSION_BUFFER_SIZE - 1); - size_t file_len = strlen(filename + borders[4] + 1); - if(file_len - 4 < SDK_VERSION_BUFFER_SIZE) { - version->extended[file_len - 4] = '\0'; - } - } else { - version->extended[0] = '\0'; - } - - for(size_t i = 0; version->extended[i] != '\0' && i < SDK_VERSION_BUFFER_SIZE; ++i) { - if(version->extended[i] == '-') { - version->extended[i] = '.'; - } - } - - return 0; -} - -int remove_explicit_layers(FILE* log, const char** install_paths, size_t count, enum Platform platform, - const char* api_name) -{ - switch(platform) - { - case PLATFORM_X64: - fprintf(log, "Removing x64 explicit layers from registry\n"); - break; - case PLATFORM_X86: - fprintf(log, "Removing x86 explicit layers from registry\n"); - break; - } - - const char* pattern = "SOFTWARE\\Khronos\\%s\\ExplicitLayers"; - int registry_size = snprintf(NULL, 0, pattern, api_name) + 1; - char* registry_key = malloc(registry_size); - snprintf(registry_key, registry_size, pattern, api_name); - - bool removed_one; - do { - // If this is a 32 bit system, we allow redirection to point this at the 32-bit registries. - // If not, we add the flag KEY_WOW64_64KEY, to disable redirection for this node. - HKEY hKey; - REGSAM flags = KEY_ALL_ACCESS; - if(platform == PLATFORM_X64) { - flags |= KEY_WOW64_64KEY; - } - - // Create (if needed) and open the explicit layer key - if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, registry_key, 0, NULL, REG_OPTION_NON_VOLATILE, flags, - NULL, &hKey, NULL) != ERROR_SUCCESS) { - free(registry_key); - return 160; - } - - removed_one = false; - DWORD valueCount; - RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &valueCount, NULL, NULL, NULL, NULL); - for(DWORD i = 0; i < valueCount; ++i) { - TCHAR name[COPY_BUFFER_SIZE]; - DWORD type, buffSize = COPY_BUFFER_SIZE; - RegEnumValue(hKey, i, name, &buffSize, NULL, &type, NULL, NULL); - - for(size_t j = 0; j < count; ++j) { - if(strncmp(install_paths[j], name, strlen(install_paths[j])) == 0) { - fprintf(log, "Removing explicit layer entry: %s\n", name); - LSTATUS err = RegDeleteValue(hKey, name); - if(err != ERROR_SUCCESS) { - free(registry_key); - return 170; - } - removed_one = true; - break; - } - } - if(removed_one) { - break; - } - } - - RegCloseKey(hKey); - } while(removed_one); - - free(registry_key); - return 0; -} - -int update_registry_layers(FILE* log, enum Platform platform, const struct SDKVersion* version, - const char* api_name) -{ - char** install_paths; - struct SDKVersion* install_versions; - size_t count; - CHECK_ERROR_HANDLED(find_installations(api_name, &install_paths, &install_versions, &count), - { free_installations(install_paths, install_versions, count); }); - for(size_t i = 0; i < count; ++i) { - fprintf(log, "Found installation of %ld.%ld.%ld.%ld in: %s\n", install_versions[i].major, - install_versions[i].minor, install_versions[i].patch, install_versions[i].build, install_paths[i]); - } - fprintf(log, "\n"); - if(platform == PLATFORM_X64) { - CHECK_ERROR_HANDLED(remove_explicit_layers(log, install_paths, count, PLATFORM_X64, api_name), - { free_installations(install_paths, install_versions, count); }); - fprintf(log, "\n"); - } - CHECK_ERROR_HANDLED(remove_explicit_layers(log, install_paths, count, PLATFORM_X86, api_name), - { free_installations(install_paths, install_versions, count); }); - fprintf(log, "\n"); - - if(version->major == 0 && version->minor == 0 && version->patch == 0 && version->build == 0) { - free_installations(install_paths, install_versions, count); - return 0; - } - - size_t preferred_sdk = count; - for(size_t i = 0; i < count; ++i) { - int cmp = compare_versions(install_versions + i, version); - if(cmp <= 0 && cmp >= -2) { - if(preferred_sdk == count || - (compare_versions(install_versions + i, install_versions + preferred_sdk) > 0)) { - preferred_sdk = i; - } - } - } - - if(preferred_sdk < count) { - if(platform == PLATFORM_X64) { - CHECK_ERROR_HANDLED(add_explicit_layers(log, install_paths[preferred_sdk], PLATFORM_X64, api_name), - { free_installations(install_paths, install_versions, count); }); - fprintf(log, "\n"); - } - CHECK_ERROR_HANDLED(add_explicit_layers(log, install_paths[preferred_sdk], PLATFORM_X86, api_name), - { free_installations(install_paths, install_versions, count); }); - } - - free_installations(install_paths, install_versions, count); - return 0; -} - -//int update_system_file(FILE* log, const char* name, const char* extension, const char* path, -// long abi_major, bool append_abi_major, struct SDKVersion* latest_version) -int update_system_file(FILE* log, const char* name, const char* extension, const char* path, - long abi_major, bool leave_abi_major, struct SDKVersion* latest_version) -{ - // Generate the filter string - const char* pattern = "%s%s-%ld-*-*-*-*%s"; - int filter_size = snprintf(NULL, 0, pattern, path, name, abi_major, extension) + 1; - if(filter_size < 0) { - return 180; - } - char* filter = malloc(filter_size); - snprintf(filter, filter_size, pattern, path, name, abi_major, extension); - - // Find all of the files that match the pattern - char* latest_filename = malloc(64); - memset(latest_version, 0, sizeof(struct SDKVersion)); - WIN32_FIND_DATA find_data; - HANDLE find = FindFirstFile(filter, &find_data); - free(filter); - for(bool at_end = (find != INVALID_HANDLE_VALUE); at_end; - at_end = FindNextFile(find, &find_data)) { - - struct SDKVersion version; - CHECK_ERROR_HANDLED(read_version_from_filename(find_data.cFileName, &version), { free(latest_filename); }); - - // Decide if this is the latest file - if(compare_versions(latest_version, &version) < 0) { - *latest_version = version; - const char* latestPattern = "%s%s"; - int size = snprintf(NULL, 0, latestPattern, path, find_data.cFileName) + 1; - if(size < 0) { - free(latest_filename); - return 200; - } - latest_filename = realloc(latest_filename, size); - snprintf(latest_filename, size, latestPattern, path, find_data.cFileName); - } - } - FindClose(find); - - // Make sure something was found - if(latest_version->major == 0 && latest_version->minor == 0 && latest_version->patch == 0 && - latest_version->build == 0) { - fprintf(log, "Didn't find any version of %s%s\n", name, extension); - return 0; - } - - fprintf(log, "Found latest version of %s%s: %ld.%ld.%ld.%ld\n", name, extension, latest_version->major, - latest_version->minor, latest_version->patch, latest_version->build); - - // Generate output filename - char* output_filename; - if(leave_abi_major) { - const char* outPattern = "%s%s-%ld%s"; - int out_size = snprintf(NULL, 0, outPattern, path, name, abi_major, extension) + 1; - if(out_size < 0) { - free(latest_filename); - return 205; - } - output_filename = malloc(out_size); - snprintf(output_filename, out_size, outPattern, path, name, abi_major, extension); - } else { - const char* outPattern = "%s%s%s"; - int out_size = snprintf(NULL, 0, outPattern, path, name, extension) + 1; - if(out_size < 0) { - free(latest_filename); - return 210; - } - output_filename = malloc(out_size); - snprintf(output_filename, out_size, outPattern, path, name, extension); - } - - fprintf(stdout, "%s>%s;", latest_filename, output_filename); - free(latest_filename); - free(output_filename); - return 0; -} - -int update_windows_directories(FILE* log, long abi_major, enum Platform platform, const char* api_name, - struct SDKVersion* latest_runtime_version) -{ - size_t api_len = strlen(api_name); - char* vulkan_name = malloc(api_len + 1); - char* vulkan_info_name = malloc(api_len + 5); - for(size_t i = 0; i < api_len; ++i) { - vulkan_name[i] = tolower(api_name[i]); - } - vulkan_name[api_len] = '\0'; - strcpy(vulkan_info_name, vulkan_name); - strcpy(vulkan_info_name + api_len, "info"); - - struct SDKVersion version; - unsigned windows_path_size = GetWindowsDirectory(NULL, 0); // Size includes null terminator - char* system_path = malloc(windows_path_size + - max_s(strlen(PATH_SYSTEM32), strlen(PATH_SYSWOW64))); - GetWindowsDirectory(system_path, windows_path_size); - - strcpy(system_path + windows_path_size - 1, PATH_SYSTEM32); - fprintf(log, "Updating system directory: %s\n", system_path); - CHECK_ERROR_HANDLED(update_system_file(log, vulkan_name, ".dll", system_path, abi_major, true, - latest_runtime_version), { free(system_path); }); - CHECK_ERROR_HANDLED(update_system_file(log, vulkan_info_name, ".exe", system_path, abi_major, false, - &version), { free(system_path); free(vulkan_info_name); free(vulkan_name);}); - if(compare_versions(latest_runtime_version, &version) != 0) { - free(system_path); - free(vulkan_info_name); - free(vulkan_name); - return 220; - } - - if(platform == PLATFORM_X64) { - strcpy(system_path + windows_path_size - 1, PATH_SYSWOW64); - fprintf(log, "\nUpdating system directory: %s\n", system_path); - CHECK_ERROR_HANDLED(update_system_file(log, vulkan_name, ".dll", system_path, abi_major, - true, &version), { free(system_path); free(vulkan_info_name); free(vulkan_name); }); - if(compare_versions(latest_runtime_version, &version) != 0) { - free(system_path); - free(vulkan_info_name); - free(vulkan_name); - return 230; - } - CHECK_ERROR_HANDLED(update_system_file(log, vulkan_info_name, ".exe", system_path, abi_major, - false, &version), { free(system_path); free(vulkan_info_name); free(vulkan_name); }); - if(compare_versions(latest_runtime_version, &version) != 0) { - free(system_path); - free(vulkan_info_name); - free(vulkan_name); - return 240; - } - } - - free(system_path); - free(vulkan_info_name); - free(vulkan_name); - fprintf(log, "\nUpdate of system directories succeeded.\n\n"); - return 0; -} -- cgit v1.2.3