Reland "Merge tag 'vulkan-sdk-1.4.350.1' into main" This is a reland of commit 6e0f3dca09c63ceca9bf926ba9c0cef2a5d980b3 Original change's description: > Merge tag 'vulkan-sdk-1.4.350.1' into main > > Bug: 510484520 > Change-Id: I034975bb3c51f8c0bcd2e2e61528c69801bcc8fe > Reviewed-on: https://fuchsia-review.googlesource.com/c/third_party/Vulkan-Tools/+/1708872 > Reviewed-by: Craig Stout <cstout@google.com> Bug: 510484520 Change-Id: I74cb273619532f0116725d538a0f150d6737a21e Reviewed-on: https://fuchsia-review.googlesource.com/c/third_party/Vulkan-Tools/+/1720934 Reviewed-by: Craig Stout <cstout@google.com>
diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml index 6a1d6f1..6a11a04 100644 --- a/.github/workflows/tools.yml +++ b/.github/workflows/tools.yml
@@ -29,10 +29,10 @@ cancel-in-progress: true jobs: - linux: + linux: needs: tools_codegen runs-on: ${{matrix.os}} - + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name strategy: matrix: cc: [ gcc ] @@ -53,16 +53,13 @@ steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 - with: - python-version: '3.10' + - uses: actions/checkout@v6 - run: | sudo apt-get -qq update sudo apt install --yes libwayland-dev xorg-dev wayland-protocols - uses: lukka/get-cmake@latest with: - cmakeVersion: 3.17.2 + cmakeVersion: 3.22.1 - name: Setup ccache uses: hendrikmuhs/ccache-action@v1.2 with: @@ -98,13 +95,14 @@ codegen: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - run: scripts/update_deps.py --dir ext --no-build - run: scripts/generate_source.py --verify ext/Vulkan-Headers/registry/ - windows: + windows: needs: tools_codegen runs-on: ${{matrix.os}} + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name strategy: matrix: @@ -113,10 +111,7 @@ os: [ windows-latest ] steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 - with: - python-version: '3.10' + - uses: actions/checkout@v6 - uses: lukka/get-cmake@latest - uses: ilammy/msvc-dev-cmd@v1 with: @@ -139,11 +134,9 @@ # mac is 10x expensive to run on GitHub machines, so only run if we know something else fast/simple passed as well needs: chromium runs-on: macos-latest + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 - with: - python-version: '3.8' + - uses: actions/checkout@v6 - uses: lukka/get-cmake@latest - name: Setup ccache @@ -155,7 +148,7 @@ - name: Add ccache to PATH run: echo "/usr/lib/ccache:/usr/local/opt/ccache/libexec" >> $GITHUB_PATH - - run: cmake -S. -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -D UPDATE_DEPS=ON -D INSTALL_ICD=ON -D BUILD_TESTS=ON -D ENABLE_ADDRESS_SANITIZER=ON -D BUILD_WERROR=ON + - run: cmake -S. -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -D UPDATE_DEPS=ON -D INSTALL_ICD=ON -D BUILD_TESTS=ON -D ENABLE_ADDRESS_SANITIZER=ON -D BUILD_WERROR=OFF # Disable warnings as unavoidable deprecation notice causes CI to fail - run: cmake --build build @@ -163,15 +156,16 @@ - run: cmake --install build --prefix /tmp - android: + android: needs: tools_codegen runs-on: ubuntu-22.04 + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name strategy: matrix: abi: [ armeabi-v7a, arm64-v8a ] steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 with: python-version: '3.8' - uses: lukka/get-cmake@latest @@ -197,19 +191,17 @@ mingw: needs: tools_codegen + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name runs-on: windows-latest defaults: run: shell: bash steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - name: Setup ccache uses: hendrikmuhs/ccache-action@v1.2 with: key: mingw-ccache - - uses: actions/setup-python@v5 - with: - python-version: '3.10' - uses: lukka/get-cmake@latest - name: GCC Version run: gcc --version # If this fails MINGW is not setup correctly @@ -225,12 +217,14 @@ tools_codegen: needs: codegen + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 with: python-version: '3.10' + - run: pip install pyparsing - run: sudo apt-get -qq update && sudo apt install --yes libwayland-dev xorg-dev wayland-protocols - run: cmake -S . -B build/ -D UPDATE_DEPS=ON -D UPDATE_DEPS_DIR=external -D TOOLS_CODEGEN=ON - run: cmake --build build --target tools_codegen @@ -238,7 +232,11 @@ chromium: needs: tools_codegen + if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 + with: + python-version: '3.10' - run: scripts/gn/gn.py
diff --git a/BUILD.md b/BUILD.md index 12cdd27..ef64350 100644 --- a/BUILD.md +++ b/BUILD.md
@@ -12,7 +12,7 @@ ## Requirements -1. CMake >= 3.17.2 +1. CMake >= 3.22.1 1. C++17 compatible toolchain 1. Git 1. Python >= 3.10 @@ -179,7 +179,7 @@ ## Building For Android -- CMake 3.21+ +- CMake 3.22.1+ - NDK r25+ - Ninja 1.10+ - Android SDK Build-Tools 34.0.0+
diff --git a/CMakeLists.txt b/CMakeLists.txt index f35f79b..9aced51 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt
@@ -15,9 +15,10 @@ # See the License for the specific language governing permissions and # limitations under the License. # ~~~ -cmake_minimum_required(VERSION 3.17.2) +cmake_minimum_required(VERSION 3.22.1) -project(Vulkan-Tools) +# The VERSION field is generated with the "--generated-version" flag in the generate_source.py script +project(Vulkan-Tools VERSION 1.4.350) # This variable enables downstream users to customize the target API # variant (e.g. Vulkan SC) @@ -55,8 +56,7 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON) -find_package(VulkanHeaders QUIET REQUIRED CONFIG) -find_package(volk QUIET REQUIRED CONFIG) +find_package(VulkanHeaders ${PROJECT_VERSION} QUIET REQUIRED CONFIG) if ((APPLE OR BUILD_TESTS) AND NOT ANDROID) find_package(VulkanLoader QUIET REQUIRED CONFIG) endif()
diff --git a/GOVERNANCE.md b/GOVERNANCE.md index 60fc12c..7dd2c11 100644 --- a/GOVERNANCE.md +++ b/GOVERNANCE.md
@@ -1,6 +1,6 @@ ## Khronos Group Vulkan-Tools Repository Management -# **Open Source Project Objectives** +# **Open Source Project - Objectives** * Assist Vulkan Users - The goal is for tool and utility behavior to assist in the development of vulkan applications.
diff --git a/cube/BUILD.gn b/cube/BUILD.gn index c44aa9d..e81f14d 100644 --- a/cube/BUILD.gn +++ b/cube/BUILD.gn
@@ -1,4 +1,4 @@ -# Copyright (C) 2020 The Fuchsia Authors. +# Copyright (C) 2025 The Fuchsia Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +assert(is_fuchsia, "This build file works on Fuchsia GN build only.") import("//build/compiled_action.gni") import("//build/components.gni") import("//build_overrides/vulkan_tools.gni") @@ -112,7 +113,6 @@ environments = [] } } - config("cube_config") { cube_frag_inc = "$target_gen_dir/cube.frag.inc" cube_vert_inc = "$target_gen_dir/cube.vert.inc" @@ -167,6 +167,7 @@ "//sdk/lib/ui/scenic/cpp", "//third_party/Vulkan-Headers/src:vulkan_headers", "//third_party/Vulkan-Loader:libvulkan", + ] }
diff --git a/cube/CMakeLists.txt b/cube/CMakeLists.txt index 4ecd3e3..7c9b778 100644 --- a/cube/CMakeLists.txt +++ b/cube/CMakeLists.txt
@@ -16,36 +16,42 @@ # ~~~ if(APPLE) - set(MOLTENVK_REPO_ROOT "MOLTENVK-NOTFOUND" CACHE PATH "Absolute path to a MoltenVK repo directory") - if(NOT MOLTENVK_REPO_ROOT) - message(FATAL_ERROR "Must define location of MoltenVK repo -- see BUILD.md") + option(APPLE_USE_SYSTEM_ICD "Use system Vulkan ICD discovery instead of bundling MoltenVK" OFF) + + if(APPLE_USE_SYSTEM_ICD) + message(STATUS "Using system Vulkan loader for ICD discovery") + else() + set(MOLTENVK_REPO_ROOT "MOLTENVK-NOTFOUND" CACHE PATH "Absolute path to a MoltenVK repo directory") + if(NOT MOLTENVK_REPO_ROOT) + message(FATAL_ERROR "Must define location of MoltenVK repo -- see BUILD.md") + endif() + message(STATUS "Using MoltenVK repo location at ${MOLTENVK_REPO_ROOT}") + + # Source for the MoltenVK ICD library and JSON file + set(MOLTENVK_DIR ${MOLTENVK_REPO_ROOT}) + + # MoltenVK JSON File + execute_process(COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json) + execute_process(COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$" + ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json + OUTPUT_FILE ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json) + + # ~~~ + # Modify the ICD JSON file to adjust the library path. + # The ICD JSON file goes in the Resources/vulkan/icd.d directory, so adjust the + # library_path to the relative path to the Frameworks directory in the bundle. + # The regex does: substitute ':<whitespace>"<whitespace><all occurences of . and />' with: + # ': "../../../Frameworks/' + # ~~~ + add_custom_target(MoltenVK_icd-staging-json ALL + COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json + COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$" + ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json > ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json + VERBATIM + DEPENDS "${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json" + ) + set_source_files_properties(${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json PROPERTIES GENERATED TRUE) endif() - message(STATUS "Using MoltenVK repo location at ${MOLTENVK_REPO_ROOT}") - - # Source for the MoltenVK ICD library and JSON file - set(MOLTENVK_DIR ${MOLTENVK_REPO_ROOT}) - - # MoltenVK JSON File - execute_process(COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json) - execute_process(COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$" - ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json - OUTPUT_FILE ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json) - - # ~~~ - # Modify the ICD JSON file to adjust the library path. - # The ICD JSON file goes in the Resources/vulkan/icd.d directory, so adjust the - # library_path to the relative path to the Frameworks directory in the bundle. - # The regex does: substitute ':<whitespace>"<whitespace><all occurences of . and />' with: - # ': "../../../Frameworks/' - # ~~~ - add_custom_target(MoltenVK_icd-staging-json ALL - COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json - COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$" - ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json > ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json - VERBATIM - DEPENDS "${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json" - ) - set_source_files_properties(${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json PROPERTIES GENERATED TRUE) find_library(COCOA NAMES Cocoa) @@ -93,6 +99,7 @@ pkg_check_modules(WAYLAND_CLIENT REQUIRED IMPORTED_TARGET wayland-client) pkg_get_variable(WAYLAND_INCLUDE_DIRS wayland-client includedir) + pkg_check_modules(WAYLAND_SCANNER REQUIRED wayland-scanner) pkg_get_variable(WAYLAND_SCANNER_EXECUTABLE wayland-scanner wayland_scanner) message(DEBUG "WAYLAND_SCANNER_EXECUTABLE = ${WAYLAND_SCANNER_EXECUTABLE}") @@ -100,6 +107,7 @@ message(DEBUG "WAYLAND_CLIENT_PATH = ${WAYLAND_CLIENT_PATH}") set(WAYLAND_CODE_PROTOCOL ${WAYLAND_CLIENT_PATH}/wayland.xml) + pkg_check_modules(WAYLAND_PROTOCOLS REQUIRED wayland-protocols) pkg_get_variable(WAYLAND_PROTOCOLS_PATH wayland-protocols pkgdatadir) message(DEBUG "WAYLAND_PROTOCOLS_PATH = ${WAYLAND_PROTOCOLS_PATH}") set(XDG_SHELL_PROTOCOL ${WAYLAND_PROTOCOLS_PATH}/stable/xdg-shell/xdg-shell.xml) @@ -283,7 +291,7 @@ target_compile_definitions(vkcube PRIVATE ${ENABLED_CUBE_PLATFORMS}) target_include_directories(vkcube PRIVATE .) -target_link_libraries(vkcube Vulkan::Headers volk::volk_headers) +target_link_libraries(vkcube ${CMAKE_DL_LIBS} Vulkan::Headers) if (ANDROID) install(TARGETS vkcube DESTINATION ${CMAKE_INSTALL_LIBDIR}) @@ -305,16 +313,6 @@ return() endif() -if (XCB_LINK_LIBRARIES) - target_compile_definitions(vkcube PRIVATE "XCB_LIBRARY=\"${XCB_LINK_LIBRARIES}\"") -endif() -if (X11_LINK_LIBRARIES) - target_compile_definitions(vkcube PRIVATE "XLIB_LIBRARY=\"${X11_LINK_LIBRARIES}\"") -endif() -if (WAYLAND_CLIENT_LINK_LIBRARIES) - target_compile_definitions(vkcube PRIVATE "WAYLAND_LIBRARY=\"${WAYLAND_CLIENT_LINK_LIBRARIES}\"") -endif() - # ---------------------------------------------------------------------------- # vkcubepp @@ -356,17 +354,7 @@ target_include_directories(vkcubepp PRIVATE .) target_compile_definitions(vkcubepp PRIVATE ${ENABLED_CUBE_PLATFORMS}) -target_link_libraries(vkcubepp Vulkan::Headers volk::volk_headers) - -if (XCB_LINK_LIBRARIES ) - target_compile_definitions(vkcubepp PUBLIC "XCB_LIBRARY=\"${XCB_LINK_LIBRARIES}\"") -endif() -if (X11_LINK_LIBRARIES) - target_compile_definitions(vkcubepp PUBLIC "XLIB_LIBRARY=\"${X11_LINK_LIBRARIES}\"") -endif() -if (WAYLAND_CLIENT_LINK_LIBRARIES) - target_compile_definitions(vkcubepp PUBLIC "WAYLAND_LIBRARY=\"${WAYLAND_CLIENT_LINK_LIBRARIES}\"") -endif() +target_link_libraries(vkcubepp ${CMAKE_DL_LIBS} Vulkan::Headers) if(APPLE) install(
diff --git a/cube/cube.c b/cube/cube.c index 3c6d329..d28285d 100644 --- a/cube/cube.c +++ b/cube/cube.c
@@ -55,11 +55,9 @@ #define APP_NAME_STR_LEN 80 #endif // _WIN32 -// Volk requires VK_NO_PROTOTYPES before including vulkan.h -#define VK_NO_PROTOTYPES +#include "cube_functions.h" + #include <vulkan/vulkan.h> -#define VOLK_IMPLEMENTATION -#include "volk.h" #include "linmath.h" #include "object_type_string_helper.h" @@ -75,6 +73,8 @@ // Allow a maximum of two outstanding presentation operations. #define FRAME_LAG 2 +// Need to know how big of a buffer of swapchain images, image views, and semaphores are needed +#define MAX_SWAPCHAIN_IMAGE_COUNT 8 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) @@ -388,15 +388,22 @@ }; typedef struct { - VkImage image; + VkFence fence; + VkSemaphore image_acquired_semaphore; VkCommandBuffer cmd; VkCommandBuffer graphics_to_present_cmd; - VkImageView view; VkBuffer uniform_buffer; VkDeviceMemory uniform_memory; void *uniform_memory_ptr; - VkFramebuffer framebuffer; VkDescriptorSet descriptor_set; +} SubmissionResources; + +typedef struct { + VkImage image; + VkImageView view; + VkFramebuffer framebuffer; + VkSemaphore draw_complete_semaphore; + VkSemaphore image_ownership_semaphore; } SwapchainImageResources; struct demo { @@ -436,6 +443,7 @@ struct wl_seat *seat; struct wl_pointer *pointer; struct wl_keyboard *keyboard; + int pending_width, pending_height; #endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) IDirectFB *dfb; @@ -455,10 +463,11 @@ #endif WSI_PLATFORM wsi_platform; VkSurfaceKHR surface; - bool prepared; + bool initialized; + bool swapchain_ready; + bool is_minimized; bool use_staging_buffer; bool separate_present_queue; - bool is_minimized; bool invalid_gpu_selection; int32_t gpu_number; @@ -481,12 +490,11 @@ VkQueue present_queue; uint32_t graphics_queue_family_index; uint32_t present_queue_family_index; - VkSemaphore image_acquired_semaphores[FRAME_LAG]; - VkSemaphore draw_complete_semaphores[FRAME_LAG]; - VkSemaphore image_ownership_semaphores[FRAME_LAG]; VkPhysicalDeviceProperties gpu_props; VkQueueFamilyProperties *queue_props; VkPhysicalDeviceMemoryProperties memory_properties; + SubmissionResources submission_resources[FRAME_LAG]; + uint32_t current_submission_index; uint32_t enabled_extension_count; uint32_t enabled_layer_count; @@ -499,10 +507,8 @@ uint32_t swapchainImageCount; VkSwapchainKHR swapchain; - SwapchainImageResources *swapchain_image_resources; + SwapchainImageResources swapchain_resources[MAX_SWAPCHAIN_IMAGE_COUNT]; VkPresentModeKHR presentMode; - VkFence fences[FRAME_LAG]; - int frame_index; bool first_swapchain_frame; VkCommandPool cmd_pool; @@ -550,7 +556,6 @@ VkDebugUtilsMessengerEXT dbg_messenger; - uint32_t current_buffer; uint32_t queue_family_count; }; @@ -706,6 +711,7 @@ // Forward declarations: static void demo_resize(struct demo *demo); + static void demo_create_surface(struct demo *demo); #if defined(__GNUC__) || defined(__clang__) @@ -879,7 +885,8 @@ vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, 0, 0, NULL, 0, NULL, 1, pmemory_barrier); } -static void demo_draw_build_cmd(struct demo *demo, VkCommandBuffer cmd_buf) { +static void demo_draw_build_cmd(struct demo *demo, SubmissionResources *submission_resource, + SwapchainImageResources *swapchain_resource) { const VkCommandBufferBeginInfo cmd_buf_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, .pNext = NULL, @@ -894,7 +901,7 @@ .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, .pNext = NULL, .renderPass = demo->render_pass, - .framebuffer = demo->swapchain_image_resources[demo->current_buffer].framebuffer, + .framebuffer = swapchain_resource->framebuffer, .renderArea.offset.x = 0, .renderArea.offset.y = 0, .renderArea.extent.width = demo->width, @@ -904,22 +911,23 @@ }; VkResult U_ASSERT_ONLY err; - err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info); + err = vkResetCommandBuffer(submission_resource->cmd, 0 /* VK_COMMAND_BUFFER_RESET_FLAGS */); + err = vkBeginCommandBuffer(submission_resource->cmd, &cmd_buf_info); - demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmd_buf, "CubeDrawCommandBuf"); + demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)submission_resource->cmd, "CubeDrawCommandBuf"); const float begin_color[4] = {0.4f, 0.3f, 0.2f, 0.1f}; - demo_push_cb_label(demo, cmd_buf, begin_color, "DrawBegin"); + demo_push_cb_label(demo, submission_resource->cmd, begin_color, "DrawBegin"); assert(!err); - vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_SUBPASS_CONTENTS_INLINE); + vkCmdBeginRenderPass(submission_resource->cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE); const float renderpass_color[4] = {8.4f, 7.3f, 6.2f, 7.1f}; - demo_push_cb_label(demo, cmd_buf, renderpass_color, "InsideRenderPass"); + demo_push_cb_label(demo, submission_resource->cmd, renderpass_color, "InsideRenderPass"); - vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline); - vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout, 0, 1, - &demo->swapchain_image_resources[demo->current_buffer].descriptor_set, 0, NULL); + vkCmdBindPipeline(submission_resource->cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline); + vkCmdBindDescriptorSets(submission_resource->cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout, 0, 1, + &submission_resource->descriptor_set, 0, NULL); VkViewport viewport; memset(&viewport, 0, sizeof(viewport)); float viewport_dimension; @@ -934,7 +942,7 @@ viewport.width = viewport_dimension; viewport.minDepth = (float)0.0f; viewport.maxDepth = (float)1.0f; - vkCmdSetViewport(cmd_buf, 0, 1, &viewport); + vkCmdSetViewport(submission_resource->cmd, 0, 1, &viewport); VkRect2D scissor; memset(&scissor, 0, sizeof(scissor)); @@ -942,17 +950,17 @@ scissor.extent.height = demo->height; scissor.offset.x = 0; scissor.offset.y = 0; - vkCmdSetScissor(cmd_buf, 0, 1, &scissor); + vkCmdSetScissor(submission_resource->cmd, 0, 1, &scissor); const float draw_color[4] = {-0.4f, -0.3f, -0.2f, -0.1f}; - demo_push_cb_label(demo, cmd_buf, draw_color, "ActualDraw"); - vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0); - demo_pop_cb_label(demo, cmd_buf); + demo_push_cb_label(demo, submission_resource->cmd, draw_color, "ActualDraw"); + vkCmdDraw(submission_resource->cmd, 12 * 3, 1, 0, 0); + demo_pop_cb_label(demo, submission_resource->cmd); // Note that ending the renderpass changes the image's layout from // COLOR_ATTACHMENT_OPTIMAL to PRESENT_SRC_KHR - vkCmdEndRenderPass(cmd_buf); - demo_pop_cb_label(demo, cmd_buf); + vkCmdEndRenderPass(submission_resource->cmd); + demo_pop_cb_label(demo, submission_resource->cmd); if (demo->separate_present_queue) { // We have to transfer ownership from the graphics queue family to the @@ -968,27 +976,31 @@ .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, .srcQueueFamilyIndex = demo->graphics_queue_family_index, .dstQueueFamilyIndex = demo->present_queue_family_index, - .image = demo->swapchain_image_resources[demo->current_buffer].image, + .image = swapchain_resource->image, .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}; - vkCmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, - NULL, 1, &image_ownership_barrier); + vkCmdPipelineBarrier(submission_resource->cmd, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + 0, 0, NULL, 0, NULL, 1, &image_ownership_barrier); } - demo_pop_cb_label(demo, cmd_buf); - err = vkEndCommandBuffer(cmd_buf); + demo_pop_cb_label(demo, submission_resource->cmd); + err = vkEndCommandBuffer(submission_resource->cmd); assert(!err); } -void demo_build_image_ownership_cmd(struct demo *demo, int i) { +void demo_build_image_ownership_cmd(struct demo *demo, SubmissionResources *submission_resource, + SwapchainImageResources *swapchain_resource) { VkResult U_ASSERT_ONLY err; + err = vkResetCommandBuffer(submission_resource->graphics_to_present_cmd, 0 /* VK_COMMAND_BUFFER_RESET_FLAGS */); + assert(!err); + const VkCommandBufferBeginInfo cmd_buf_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, .pNext = NULL, .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, .pInheritanceInfo = NULL, }; - err = vkBeginCommandBuffer(demo->swapchain_image_resources[i].graphics_to_present_cmd, &cmd_buf_info); + err = vkBeginCommandBuffer(submission_resource->graphics_to_present_cmd, &cmd_buf_info); assert(!err); VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, @@ -999,16 +1011,16 @@ .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, .srcQueueFamilyIndex = demo->graphics_queue_family_index, .dstQueueFamilyIndex = demo->present_queue_family_index, - .image = demo->swapchain_image_resources[i].image, + .image = swapchain_resource->image, .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}; - vkCmdPipelineBarrier(demo->swapchain_image_resources[i].graphics_to_present_cmd, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + vkCmdPipelineBarrier(submission_resource->graphics_to_present_cmd, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 1, &image_ownership_barrier); - err = vkEndCommandBuffer(demo->swapchain_image_resources[i].graphics_to_present_cmd); + err = vkEndCommandBuffer(submission_resource->graphics_to_present_cmd); assert(!err); } -void demo_update_data_buffer(struct demo *demo) { +void demo_update_data_buffer(struct demo *demo, void *uniform_memory_ptr) { mat4x4 MVP, Model, VP; int matrixSize = sizeof(MVP); @@ -1020,7 +1032,7 @@ mat4x4_orthonormalize(demo->model_matrix, demo->model_matrix); mat4x4_mul(MVP, VP, demo->model_matrix); - memcpy(demo->swapchain_image_resources[demo->current_buffer].uniform_memory_ptr, (const void *)&MVP[0][0], matrixSize); + memcpy(uniform_memory_ptr, (const void *)&MVP[0][0], matrixSize); } void DemoUpdateTargetIPD(struct demo *demo) { @@ -1132,7 +1144,7 @@ } if (calibrate_next) { - int64_t multiple = demo->next_present_id - past[count - 1].presentID; + int64_t multiple = demo->next_present_id - past[count - 1].presentID - 1; demo->prev_desired_present_time = (past[count - 1].actualPresentTime + (multiple * demo->target_IPD)); } free(past); @@ -1140,16 +1152,23 @@ } static void demo_draw(struct demo *demo) { + // Don't draw if initialization isn't complete, if the swapchain became outdated, or if the window is minimized + if (!demo->initialized || !demo->swapchain_ready || demo->is_minimized) { + return; + } + VkResult U_ASSERT_ONLY err; - // Ensure no more than FRAME_LAG renderings are outstanding - vkWaitForFences(demo->device, 1, &demo->fences[demo->frame_index], VK_TRUE, UINT64_MAX); - vkResetFences(demo->device, 1, &demo->fences[demo->frame_index]); + SubmissionResources current_submission = demo->submission_resources[demo->current_submission_index]; + // Ensure no more than FRAME_LAG renderings are outstanding + vkWaitForFences(demo->device, 1, ¤t_submission.fence, VK_TRUE, UINT64_MAX); + + uint32_t current_swapchain_image_index; do { // Get the index of the next available swapchain image: - err = vkAcquireNextImageKHR(demo->device, demo->swapchain, UINT64_MAX, demo->image_acquired_semaphores[demo->frame_index], - VK_NULL_HANDLE, &demo->current_buffer); + err = vkAcquireNextImageKHR(demo->device, demo->swapchain, UINT64_MAX, current_submission.image_acquired_semaphore, + VK_NULL_HANDLE, ¤t_swapchain_image_index); if (err == VK_ERROR_OUT_OF_DATE_KHR) { // demo->swapchain is out of date (e.g. the window was resized) and @@ -1166,9 +1185,16 @@ } else { assert(!err); } + + // Stop drawing if we resized but didn't successfully create a new swapchain. + if (!demo->swapchain_ready) { + return; + } } while (err != VK_SUCCESS); - demo_update_data_buffer(demo); + SwapchainImageResources current_swapchain_resource = demo->swapchain_resources[current_swapchain_image_index]; + + demo_update_data_buffer(demo, current_submission.uniform_memory_ptr); if (demo->VK_GOOGLE_display_timing_enabled) { // Look at what happened to previous presents, and make appropriate @@ -1182,6 +1208,15 @@ // simple that it doesn't do either of those. } + demo_draw_build_cmd(demo, ¤t_submission, ¤t_swapchain_resource); + + if (demo->separate_present_queue) { + demo_build_image_ownership_cmd(demo, ¤t_submission, ¤t_swapchain_resource); + } + + // Only reset right before submitting so we can't deadlock on an un-signalled fence that has nothing submitted to it + vkResetFences(demo->device, 1, ¤t_submission.fence); + // Wait for the image acquired semaphore to be signaled to ensure // that the image won't be rendered to until the presentation // engine has fully released ownership to the application, and it is @@ -1193,12 +1228,12 @@ pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; submit_info.pWaitDstStageMask = &pipe_stage_flags; submit_info.waitSemaphoreCount = 1; - submit_info.pWaitSemaphores = &demo->image_acquired_semaphores[demo->frame_index]; + submit_info.pWaitSemaphores = ¤t_submission.image_acquired_semaphore; submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &demo->swapchain_image_resources[demo->current_buffer].cmd; + submit_info.pCommandBuffers = ¤t_submission.cmd; submit_info.signalSemaphoreCount = 1; - submit_info.pSignalSemaphores = &demo->draw_complete_semaphores[demo->frame_index]; - err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, demo->fences[demo->frame_index]); + submit_info.pSignalSemaphores = ¤t_swapchain_resource.draw_complete_semaphore; + err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, current_submission.fence); assert(!err); if (demo->separate_present_queue) { @@ -1208,11 +1243,11 @@ VkFence nullFence = VK_NULL_HANDLE; pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; submit_info.waitSemaphoreCount = 1; - submit_info.pWaitSemaphores = &demo->draw_complete_semaphores[demo->frame_index]; + submit_info.pWaitSemaphores = ¤t_swapchain_resource.draw_complete_semaphore; submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &demo->swapchain_image_resources[demo->current_buffer].graphics_to_present_cmd; + submit_info.pCommandBuffers = ¤t_submission.graphics_to_present_cmd; submit_info.signalSemaphoreCount = 1; - submit_info.pSignalSemaphores = &demo->image_ownership_semaphores[demo->frame_index]; + submit_info.pSignalSemaphores = ¤t_swapchain_resource.image_ownership_semaphore; err = vkQueueSubmit(demo->present_queue, 1, &submit_info, nullFence); assert(!err); } @@ -1223,11 +1258,11 @@ .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, .pNext = NULL, .waitSemaphoreCount = 1, - .pWaitSemaphores = (demo->separate_present_queue) ? &demo->image_ownership_semaphores[demo->frame_index] - : &demo->draw_complete_semaphores[demo->frame_index], + .pWaitSemaphores = (demo->separate_present_queue) ? ¤t_swapchain_resource.image_ownership_semaphore + : ¤t_swapchain_resource.draw_complete_semaphore, .swapchainCount = 1, .pSwapchains = &demo->swapchain, - .pImageIndices = &demo->current_buffer, + .pImageIndices = ¤t_swapchain_image_index, }; VkRectLayerKHR rect; @@ -1266,8 +1301,9 @@ present.pNext = ®ions; } + VkPresentTimesInfoGOOGLE present_time; + VkPresentTimeGOOGLE ptime; if (demo->VK_GOOGLE_display_timing_enabled) { - VkPresentTimeGOOGLE ptime; if (demo->prev_desired_present_time == 0) { // This must be the first present for this swapchain. // @@ -1290,20 +1326,19 @@ ptime.presentID = demo->next_present_id++; demo->prev_desired_present_time = ptime.desiredPresentTime; - VkPresentTimesInfoGOOGLE present_time = { + present_time = (VkPresentTimesInfoGOOGLE){ .sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, .pNext = present.pNext, .swapchainCount = present.swapchainCount, .pTimes = &ptime, }; - if (demo->VK_GOOGLE_display_timing_enabled) { - present.pNext = &present_time; - } + + present.pNext = &present_time; } err = vkQueuePresentKHR(demo->present_queue, &present); - demo->frame_index += 1; - demo->frame_index %= FRAME_LAG; + demo->current_submission_index += 1; + demo->current_submission_index %= FRAME_LAG; demo->first_swapchain_frame = false; if (err == VK_ERROR_OUT_OF_DATE_KHR) { @@ -1328,10 +1363,22 @@ } } -static void demo_prepare_buffers(struct demo *demo) { +// Forward decls for that demo_prepare_swapchain needs +static void demo_prepare_depth(struct demo *demo); +static void demo_prepare_framebuffers(struct demo *demo); + +// Creates the swapchain, swapchain image views, depth buffer, framebuffers, and sempahores. +// This function returns early if it fails to create a swapchain, setting swapchain_ready to false. +static void demo_prepare_swapchain(struct demo *demo) { VkResult U_ASSERT_ONLY err; VkSwapchainKHR oldSwapchain = demo->swapchain; +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + if (demo->wsi_platform == WSI_PLATFORM_WAYLAND && !demo->xdg_surface_has_been_configured) { + return; + } +#endif + // Check the surface capabilities and formats VkSurfaceCapabilitiesKHR surfCapabilities; err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->gpu, demo->surface, &surfCapabilities); @@ -1501,10 +1548,6 @@ err = vkGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, swapchainImages); assert(!err); - demo->swapchain_image_resources = - (SwapchainImageResources *)malloc(sizeof(SwapchainImageResources) * demo->swapchainImageCount); - assert(demo->swapchain_image_resources); - for (i = 0; i < demo->swapchainImageCount; i++) { demo_name_object(demo, VK_OBJECT_TYPE_IMAGE, (uint64_t)swapchainImages[i], "SwapchainImage(%u)", i); } @@ -1526,14 +1569,35 @@ .flags = 0, }; - demo->swapchain_image_resources[i].image = swapchainImages[i]; + demo->swapchain_resources[i].image = swapchainImages[i]; - color_image_view.image = demo->swapchain_image_resources[i].image; + color_image_view.image = demo->swapchain_resources[i].image; - err = vkCreateImageView(demo->device, &color_image_view, NULL, &demo->swapchain_image_resources[i].view); + err = vkCreateImageView(demo->device, &color_image_view, NULL, &demo->swapchain_resources[i].view); assert(!err); - demo_name_object(demo, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)demo->swapchain_image_resources[i].view, "SwapchainView(%u)", - i); + demo_name_object(demo, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)demo->swapchain_resources[i].view, "SwapchainView(%u)", i); + } + + // Create semaphores to synchronize acquiring presentable buffers before + // rendering and waiting for drawing to be complete before presenting + VkSemaphoreCreateInfo semaphoreCreateInfo = { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + .pNext = NULL, + .flags = 0, + }; + for (i = 0; i < demo->swapchainImageCount; i++) { + err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->swapchain_resources[i].draw_complete_semaphore); + assert(!err); + demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->swapchain_resources[i].draw_complete_semaphore, + "DrawCompleteSem(%u)", i); + + if (demo->separate_present_queue) { + err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, + &demo->swapchain_resources[i].image_ownership_semaphore); + assert(!err); + demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->swapchain_resources[i].image_ownership_semaphore, + "ImageOwnerSem(%u)", i); + } } if (demo->VK_GOOGLE_display_timing_enabled) { @@ -1557,15 +1621,21 @@ if (NULL != presentModes) { free(presentModes); } + + demo_prepare_depth(demo); + demo_prepare_framebuffers(demo); + demo->swapchain_ready = true; + demo->first_swapchain_frame = true; } static void demo_prepare_depth(struct demo *demo) { - const VkFormat depth_format = VK_FORMAT_D16_UNORM; + demo->depth.format = VK_FORMAT_D16_UNORM; + const VkImageCreateInfo image = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = NULL, .imageType = VK_IMAGE_TYPE_2D, - .format = depth_format, + .format = demo->depth.format, .extent = {demo->width, demo->height, 1}, .mipLevels = 1, .arrayLayers = 1, @@ -1579,7 +1649,7 @@ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .pNext = NULL, .image = VK_NULL_HANDLE, - .format = depth_format, + .format = demo->depth.format, .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1}, .flags = 0, @@ -1595,8 +1665,6 @@ VkResult U_ASSERT_ONLY err; bool U_ASSERT_ONLY pass; - demo->depth.format = depth_format; - /* create image */ err = vkCreateImage(demo->device, &image, NULL, &demo->depth.image); assert(!err); @@ -1639,19 +1707,16 @@ if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "P6\n", 3)) { return false; } - while (strncmp(cPtr++, "\n", 1)) - ; + while (strncmp(cPtr++, "\n", 1)); sscanf(cPtr, "%u %u", width, height); if (rgba_data == NULL) { return true; } - while (strncmp(cPtr++, "\n", 1)) - ; + while (strncmp(cPtr++, "\n", 1)); if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "255\n", 4)) { return false; } - while (strncmp(cPtr++, "\n", 1)) - ; + while (strncmp(cPtr++, "\n", 1)); for (int y = 0; y < *height; y++) { uint8_t *rowPtr = rgba_data; for (int x = 0; x < *width; x++) { @@ -1728,7 +1793,7 @@ static void demo_prepare_texture_image(struct demo *demo, const char *filename, struct texture_object *tex_obj, VkImageTiling tiling, VkImageUsageFlags usage, VkFlags required_props) { - const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM; + const VkFormat tex_format = VK_FORMAT_R8G8B8A8_SRGB; int32_t tex_width; int32_t tex_height; VkResult U_ASSERT_ONLY err; @@ -1813,7 +1878,7 @@ } static void demo_prepare_textures(struct demo *demo) { - const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM; + const VkFormat tex_format = VK_FORMAT_R8G8B8A8_SRGB; VkFormatProperties props; uint32_t i; @@ -1870,8 +1935,8 @@ demo_pop_cb_label(demo, demo->cmd); // "StagingTexture" } else { - /* Can't support VK_FORMAT_R8G8B8A8_UNORM !? */ - assert(!"No support for R8G8B8A8_UNORM as texture image format"); + /* Can't support VK_FORMAT_R8G8B8A8_SRGB !? */ + assert(!"No support for R8G8B8A8_SRGB as texture image format"); } const VkSamplerCreateInfo sampler = { @@ -1953,13 +2018,12 @@ buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; buf_info.size = sizeof(data); - for (unsigned int i = 0; i < demo->swapchainImageCount; i++) { - err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->swapchain_image_resources[i].uniform_buffer); + for (unsigned int i = 0; i < FRAME_LAG; i++) { + err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->submission_resources[i].uniform_buffer); assert(!err); - demo_name_object(demo, VK_OBJECT_TYPE_BUFFER, (uint64_t)demo->swapchain_image_resources[i].uniform_buffer, - "SwapchainUniformBuf(%u)", i); + demo_name_object(demo, VK_OBJECT_TYPE_BUFFER, (uint64_t)demo->submission_resources[i].uniform_buffer, "UniformBuf(%u)", i); - vkGetBufferMemoryRequirements(demo->device, demo->swapchain_image_resources[i].uniform_buffer, &mem_reqs); + vkGetBufferMemoryRequirements(demo->device, demo->submission_resources[i].uniform_buffer, &mem_reqs); mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; mem_alloc.pNext = NULL; @@ -1971,19 +2035,19 @@ &mem_alloc.memoryTypeIndex); assert(pass); - err = vkAllocateMemory(demo->device, &mem_alloc, NULL, &demo->swapchain_image_resources[i].uniform_memory); + err = vkAllocateMemory(demo->device, &mem_alloc, NULL, &demo->submission_resources[i].uniform_memory); assert(!err); - demo_name_object(demo, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)demo->swapchain_image_resources[i].uniform_memory, - "SwapchainUniformMem(%u)", i); + demo_name_object(demo, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)demo->submission_resources[i].uniform_memory, + "UniformMem(%u)", i); - err = vkMapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, 0, VK_WHOLE_SIZE, 0, - &demo->swapchain_image_resources[i].uniform_memory_ptr); + err = vkMapMemory(demo->device, demo->submission_resources[i].uniform_memory, 0, VK_WHOLE_SIZE, 0, + &demo->submission_resources[i].uniform_memory_ptr); assert(!err); - memcpy(demo->swapchain_image_resources[i].uniform_memory_ptr, &data, sizeof data); + memcpy(demo->submission_resources[i].uniform_memory_ptr, &data, sizeof data); - err = vkBindBufferMemory(demo->device, demo->swapchain_image_resources[i].uniform_buffer, - demo->swapchain_image_resources[i].uniform_memory, 0); + err = vkBindBufferMemory(demo->device, demo->submission_resources[i].uniform_buffer, + demo->submission_resources[i].uniform_memory, 0); assert(!err); } } @@ -2281,18 +2345,18 @@ [0] = { .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - .descriptorCount = demo->swapchainImageCount, + .descriptorCount = FRAME_LAG, }, [1] = { .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .descriptorCount = demo->swapchainImageCount * DEMO_TEXTURE_COUNT, + .descriptorCount = FRAME_LAG * DEMO_TEXTURE_COUNT, }, }; const VkDescriptorPoolCreateInfo descriptor_pool = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, .pNext = NULL, - .maxSets = demo->swapchainImageCount, + .maxSets = FRAME_LAG, .poolSizeCount = 2, .pPoolSizes = type_counts, }; @@ -2337,12 +2401,12 @@ writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[1].pImageInfo = tex_descs; - for (unsigned int i = 0; i < demo->swapchainImageCount; i++) { - err = vkAllocateDescriptorSets(demo->device, &alloc_info, &demo->swapchain_image_resources[i].descriptor_set); + for (unsigned int i = 0; i < FRAME_LAG; i++) { + err = vkAllocateDescriptorSets(demo->device, &alloc_info, &demo->submission_resources[i].descriptor_set); assert(!err); - buffer_info.buffer = demo->swapchain_image_resources[i].uniform_buffer; - writes[0].dstSet = demo->swapchain_image_resources[i].descriptor_set; - writes[1].dstSet = demo->swapchain_image_resources[i].descriptor_set; + buffer_info.buffer = demo->submission_resources[i].uniform_buffer; + writes[0].dstSet = demo->submission_resources[i].descriptor_set; + writes[1].dstSet = demo->submission_resources[i].descriptor_set; vkUpdateDescriptorSets(demo->device, 2, writes, 0, NULL); } } @@ -2365,29 +2429,44 @@ uint32_t i; for (i = 0; i < demo->swapchainImageCount; i++) { - attachments[0] = demo->swapchain_image_resources[i].view; - err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->swapchain_image_resources[i].framebuffer); + attachments[0] = demo->swapchain_resources[i].view; + err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->swapchain_resources[i].framebuffer); assert(!err); - demo_name_object(demo, VK_OBJECT_TYPE_FRAMEBUFFER, (uint64_t)demo->swapchain_image_resources[i].framebuffer, - "Framebuffer(%u)", i); + demo_name_object(demo, VK_OBJECT_TYPE_FRAMEBUFFER, (uint64_t)demo->swapchain_resources[i].framebuffer, "Framebuffer(%u)", + i); + } +} + +static void demo_prepare_submission_sync_objects(struct demo *demo) { + VkSemaphoreCreateInfo semaphoreCreateInfo = { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + .pNext = NULL, + .flags = 0, + }; + // Create fences that we can use to throttle if we get too far + // ahead of the image presents + VkFenceCreateInfo fence_ci = { + .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = VK_FENCE_CREATE_SIGNALED_BIT}; + VkResult U_ASSERT_ONLY err; + for (uint32_t i = 0; i < FRAME_LAG; i++) { + err = vkCreateFence(demo->device, &fence_ci, NULL, &demo->submission_resources[i].fence); + assert(!err); + + err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->submission_resources[i].image_acquired_semaphore); + assert(!err); + demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->submission_resources[i].image_acquired_semaphore, + "AcquireSem(%u)", i); } } static void demo_prepare(struct demo *demo) { - demo_prepare_buffers(demo); - - if (demo->is_minimized) { - demo->prepared = false; - return; - } - VkResult U_ASSERT_ONLY err; if (demo->cmd_pool == VK_NULL_HANDLE) { const VkCommandPoolCreateInfo cmd_pool_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, .pNext = NULL, .queueFamilyIndex = demo->graphics_queue_family_index, - .flags = 0, + .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, }; err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool); assert(!err); @@ -2413,17 +2492,21 @@ demo_push_cb_label(demo, demo->cmd, NULL, "Prepare"); assert(!err); - demo_prepare_depth(demo); demo_prepare_textures(demo); demo_prepare_cube_data_buffers(demo); demo_prepare_descriptor_layout(demo); + + // Only need to know the format of the depth buffer before we create the renderpass + demo->depth.format = VK_FORMAT_D16_UNORM; demo_prepare_render_pass(demo); demo_prepare_pipeline(demo); - for (uint32_t i = 0; i < demo->swapchainImageCount; i++) { - err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->swapchain_image_resources[i].cmd); + for (uint32_t i = 0; i < FRAME_LAG; i++) { + err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->submission_resources[i].cmd); assert(!err); + demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)demo->submission_resources[i].cmd, "MainCommandBuffer(%u)", + i); } if (demo->separate_present_queue) { @@ -2442,25 +2525,18 @@ .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, .commandBufferCount = 1, }; - for (uint32_t i = 0; i < demo->swapchainImageCount; i++) { - err = vkAllocateCommandBuffers(demo->device, &present_cmd_info, - &demo->swapchain_image_resources[i].graphics_to_present_cmd); + for (uint32_t i = 0; i < FRAME_LAG; i++) { + err = vkAllocateCommandBuffers(demo->device, &present_cmd_info, &demo->submission_resources[i].graphics_to_present_cmd); assert(!err); - demo_build_image_ownership_cmd(demo, i); - demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, - (uint64_t)demo->swapchain_image_resources[i].graphics_to_present_cmd, "GfxToPresent(%u)", i); + demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)demo->submission_resources[i].graphics_to_present_cmd, + "GfxToPresent(%u)", i); } } demo_prepare_descriptor_pool(demo); demo_prepare_descriptor_set(demo); - demo_prepare_framebuffers(demo); - - for (uint32_t i = 0; i < demo->swapchainImageCount; i++) { - demo->current_buffer = i; - demo_draw_build_cmd(demo, demo->swapchain_image_resources[i].cmd); - } + demo_prepare_submission_sync_objects(demo); /* * Prepare functions above may generate pipeline commands @@ -2471,34 +2547,24 @@ if (demo->staging_texture.buffer) { demo_destroy_texture(demo, &demo->staging_texture); } - - demo->current_buffer = 0; - demo->prepared = true; - demo->first_swapchain_frame = true; + demo->current_submission_index = 0; + demo->initialized = true; + demo_prepare_swapchain(demo); } static void demo_cleanup(struct demo *demo) { uint32_t i; - demo->prepared = false; + demo->initialized = false; vkDeviceWaitIdle(demo->device); // Wait for fences from present operations for (i = 0; i < FRAME_LAG; i++) { - vkWaitForFences(demo->device, 1, &demo->fences[i], VK_TRUE, UINT64_MAX); - vkDestroyFence(demo->device, demo->fences[i], NULL); - vkDestroySemaphore(demo->device, demo->image_acquired_semaphores[i], NULL); - vkDestroySemaphore(demo->device, demo->draw_complete_semaphores[i], NULL); - if (demo->separate_present_queue) { - vkDestroySemaphore(demo->device, demo->image_ownership_semaphores[i], NULL); - } + vkWaitForFences(demo->device, 1, &demo->submission_resources[i].fence, VK_TRUE, UINT64_MAX); } // If the window is currently minimized, demo_resize has already done some cleanup for us. if (!demo->is_minimized) { - for (i = 0; i < demo->swapchainImageCount; i++) { - vkDestroyFramebuffer(demo->device, demo->swapchain_image_resources[i].framebuffer, NULL); - } vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL); vkDestroyPipeline(demo->device, demo->pipeline, NULL); @@ -2520,13 +2586,21 @@ vkFreeMemory(demo->device, demo->depth.mem, NULL); for (i = 0; i < demo->swapchainImageCount; i++) { - vkDestroyImageView(demo->device, demo->swapchain_image_resources[i].view, NULL); - vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->swapchain_image_resources[i].cmd); - vkDestroyBuffer(demo->device, demo->swapchain_image_resources[i].uniform_buffer, NULL); - vkUnmapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory); - vkFreeMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, NULL); + vkDestroyImageView(demo->device, demo->swapchain_resources[i].view, NULL); + vkDestroyFramebuffer(demo->device, demo->swapchain_resources[i].framebuffer, NULL); + vkDestroySemaphore(demo->device, demo->swapchain_resources[i].draw_complete_semaphore, NULL); + if (demo->separate_present_queue) { + vkDestroySemaphore(demo->device, demo->swapchain_resources[i].image_ownership_semaphore, NULL); + } } - free(demo->swapchain_image_resources); + + for (i = 0; i < FRAME_LAG; i++) { + vkDestroyFence(demo->device, demo->submission_resources[i].fence, NULL); + vkDestroySemaphore(demo->device, demo->submission_resources[i].image_acquired_semaphore, NULL); + vkDestroyBuffer(demo->device, demo->submission_resources[i].uniform_buffer, NULL); + vkUnmapMemory(demo->device, demo->submission_resources[i].uniform_memory); + vkFreeMemory(demo->device, demo->submission_resources[i].uniform_memory, NULL); + } free(demo->queue_props); vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL); @@ -2588,64 +2662,53 @@ #endif vkDestroyInstance(demo->inst, NULL); + unload_vulkan_library(); } static void demo_resize(struct demo *demo) { uint32_t i; // Don't react to resize until after first initialization. - if (!demo->prepared) { - if (demo->is_minimized) { - demo_prepare(demo); - } + if (!demo->initialized) { return; } - // In order to properly resize the window, we must re-create the swapchain - // AND redo the command buffers, etc. + + // Don't do anything if the surface has zero size, as vulkan disallows creating swapchains with zero area + // We use is_minimized to track this because zero size window usually occurs from minimizing + if (demo->width == 0 || demo->height == 0) { + demo->is_minimized = true; + return; + } else { + demo->is_minimized = false; + } + + // In order to properly resize the window, we must re-create the + // swapchain // - // First, perform part of the demo_cleanup() function: - demo->prepared = false; - vkDeviceWaitIdle(demo->device); + // First, destroy the old swapchain and its associated resources, setting swapchain_ready to false to prevent draw from running - for (i = 0; i < demo->swapchainImageCount; i++) { - vkDestroyFramebuffer(demo->device, demo->swapchain_image_resources[i].framebuffer, NULL); - } - vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL); + if (demo->swapchain_ready) { + demo->swapchain_ready = false; + vkDeviceWaitIdle(demo->device); - vkDestroyPipeline(demo->device, demo->pipeline, NULL); - vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL); - vkDestroyRenderPass(demo->device, demo->render_pass, NULL); - vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL); - vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL); + vkDestroyImageView(demo->device, demo->depth.view, NULL); + vkDestroyImage(demo->device, demo->depth.image, NULL); + vkFreeMemory(demo->device, demo->depth.mem, NULL); + memset(&(demo->depth), 0, sizeof(demo->depth)); - for (i = 0; i < DEMO_TEXTURE_COUNT; i++) { - vkDestroyImageView(demo->device, demo->textures[i].view, NULL); - vkDestroyImage(demo->device, demo->textures[i].image, NULL); - vkFreeMemory(demo->device, demo->textures[i].mem, NULL); - vkDestroySampler(demo->device, demo->textures[i].sampler, NULL); + for (i = 0; i < demo->swapchainImageCount; i++) { + vkDestroyImageView(demo->device, demo->swapchain_resources[i].view, NULL); + vkDestroyFramebuffer(demo->device, demo->swapchain_resources[i].framebuffer, NULL); + vkDestroySemaphore(demo->device, demo->swapchain_resources[i].draw_complete_semaphore, NULL); + if (demo->separate_present_queue) { + vkDestroySemaphore(demo->device, demo->swapchain_resources[i].image_ownership_semaphore, NULL); + } + } + memset(&(demo->swapchain_resources), 0, sizeof(SwapchainImageResources) * MAX_SWAPCHAIN_IMAGE_COUNT); } - vkDestroyImageView(demo->device, demo->depth.view, NULL); - vkDestroyImage(demo->device, demo->depth.image, NULL); - vkFreeMemory(demo->device, demo->depth.mem, NULL); - - for (i = 0; i < demo->swapchainImageCount; i++) { - vkDestroyImageView(demo->device, demo->swapchain_image_resources[i].view, NULL); - vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->swapchain_image_resources[i].cmd); - vkDestroyBuffer(demo->device, demo->swapchain_image_resources[i].uniform_buffer, NULL); - vkUnmapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory); - vkFreeMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, NULL); - } - vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL); - demo->cmd_pool = VK_NULL_HANDLE; - if (demo->separate_present_queue) { - vkDestroyCommandPool(demo->device, demo->present_cmd_pool, NULL); - } - free(demo->swapchain_image_resources); - - // Second, re-perform the demo_prepare() function, which will re-create the - // swapchain: - demo_prepare(demo); + // Second, recreate the swapchain, depth buffer, and framebuffers. + demo_prepare_swapchain(demo); } // On MS-Windows, make this a global, so it's available to WndProc() @@ -2653,10 +2716,12 @@ #if defined(VK_USE_PLATFORM_WIN32_KHR) static void demo_run(struct demo *demo) { - if (!demo->prepared) return; + if (!demo->initialized || !demo->swapchain_ready) return; demo_draw(demo); - demo->curFrame++; + if (!demo->is_minimized) { + demo->curFrame++; + } if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) { PostQuitMessage(validation_error); } @@ -2796,6 +2861,7 @@ XMapWindow(demo->xlib_display, demo->xlib_window); XFlush(demo->xlib_display); demo->xlib_wm_delete_window = XInternAtom(demo->xlib_display, "WM_DELETE_WINDOW", False); + XSetWMProtocols(demo->xlib_display, demo->xlib_window, &demo->xlib_wm_delete_window, 1); } static void demo_handle_xlib_event(struct demo *demo, const XEvent *event) { switch (event->type) { @@ -2842,10 +2908,13 @@ XNextEvent(demo->xlib_display, &event); demo_handle_xlib_event(demo, &event); } - - demo_draw(demo); - demo->curFrame++; - if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + if (demo->initialized && demo->swapchain_ready) { + demo_draw(demo); + if (!demo->is_minimized) { + demo->curFrame++; + } + if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + } } } #endif @@ -2908,10 +2977,13 @@ free(event); event = xcb_poll_for_event(demo->connection); } - - demo_draw(demo); - demo->curFrame++; - if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + if (demo->initialized && demo->swapchain_ready) { + demo_draw(demo); + if (!demo->is_minimized) { + demo->curFrame++; + } + if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + } } } @@ -2927,6 +2999,15 @@ xcb_create_window(demo->connection, XCB_COPY_FROM_PARENT, demo->xcb_window, demo->screen->root, 0, 0, demo->width, demo->height, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, demo->screen->root_visual, value_mask, value_list); + char *name = "Vkcube X11"; + xcb_intern_atom_cookie_t net_wm_name_cookie = xcb_intern_atom(demo->connection, 0, strlen("_NET_WM_NAME"), "_NET_WM_NAME"); + xcb_intern_atom_cookie_t utf8_string_cookie = xcb_intern_atom(demo->connection, 0, strlen("UTF8_STRING"), "UTF8_STRING"); + xcb_intern_atom_reply_t *net_wm_name_reply = xcb_intern_atom_reply(demo->connection, net_wm_name_cookie, NULL); + xcb_intern_atom_reply_t *utf8_string_reply = xcb_intern_atom_reply(demo->connection, utf8_string_cookie, NULL); + xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE, + demo->xcb_window, net_wm_name_reply->atom, + utf8_string_reply->atom, 8, strlen(name), name); + /* Magic code that will send notification when window is destroyed */ xcb_intern_atom_cookie_t cookie = xcb_intern_atom(demo->connection, 1, 12, "WM_PROTOCOLS"); xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(demo->connection, cookie, 0); @@ -2967,10 +3048,13 @@ // Pump events wl_display_dispatch_pending(demo->wayland_display); - - demo_draw(demo); - demo->curFrame++; - if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + if (demo->initialized && demo->swapchain_ready) { + demo_draw(demo); + if (!demo->is_minimized) { + demo->curFrame++; + } + if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + } } } } @@ -2978,10 +3062,14 @@ static void handle_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial) { struct demo *demo = (struct demo *)data; xdg_surface_ack_configure(xdg_surface, serial); - if (demo->xdg_surface_has_been_configured) { - demo_resize(demo); - } demo->xdg_surface_has_been_configured = 1; + if (demo->pending_width > 0) { + demo->width = demo->pending_width; + } + if (demo->pending_height > 0) { + demo->height = demo->pending_height; + } + demo_resize(demo); } static const struct xdg_surface_listener xdg_surface_listener = {handle_surface_configure}; @@ -2992,10 +3080,10 @@ /* zero values imply the program may choose its own size, so in that case * stay with the existing value (which on startup is the default) */ if (width > 0) { - demo->width = width; + demo->pending_width = width; } if (height > 0) { - demo->height = height; + demo->pending_height = height; } /* This should be followed by a surface configure */ } @@ -3113,26 +3201,35 @@ if (!demo->event_buffer->GetEvent(demo->event_buffer, DFB_EVENT(&event))) demo_handle_directfb_event(demo, &event); } else { if (!demo->event_buffer->GetEvent(demo->event_buffer, DFB_EVENT(&event))) demo_handle_directfb_event(demo, &event); - - demo_draw(demo); - demo->curFrame++; - if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + if (demo->initialized && demo->swapchain_ready) { + demo_draw(demo); + if (!demo->is_minimized) { + demo->curFrame++; + } + if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true; + } } } } #endif #if defined(VK_USE_PLATFORM_ANDROID_KHR) static void demo_run(struct demo *demo) { - if (!demo->prepared) return; + if (!demo->initialized || !demo->swapchain_ready) return; demo_draw(demo); - demo->curFrame++; + if (!demo->is_minimized) { + demo->curFrame++; + } } #endif #if defined(VK_USE_PLATFORM_METAL_EXT) static void demo_run(struct demo *demo) { + if (!demo->initialized || !demo->swapchain_ready) return; + demo_draw(demo); - demo->curFrame++; + if (!demo->is_minimized) { + demo->curFrame++; + } if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) { demo->quit = TRUE; } @@ -3374,10 +3471,12 @@ } } - if (demo->pause) { + if (demo->pause || !demo->initialized || !demo->swapchain_ready) { } else { demo_draw(demo); - demo->curFrame++; + if (!demo->is_minimized) { + demo->curFrame++; + } if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) { demo->quit = true; } @@ -3665,6 +3764,30 @@ // If the wsi_platform is AUTO, this function also sets wsi_platform to the first available WSI platform // Otherwise, it errors out if the specified wsi_platform isn't available static void demo_check_and_set_wsi_platform(struct demo *demo) { +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + if (demo->wsi_platform == WSI_PLATFORM_WAYLAND || demo->wsi_platform == WSI_PLATFORM_AUTO) { + bool wayland_extension_available = false; + for (uint32_t i = 0; i < demo->enabled_extension_count; i++) { + if (strcmp(demo->extension_names[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) { + wayland_extension_available = true; + break; + } + } + if (wayland_extension_available) { + const char *error_msg = demo_init_wayland_connection(demo); + if (error_msg != NULL) { + if (demo->wsi_platform == WSI_PLATFORM_WAYLAND) { + fprintf(stderr, "%s\nExiting ...\n", error_msg); + fflush(stdout); + exit(1); + } + } else { + demo->wsi_platform = WSI_PLATFORM_WAYLAND; + return; + } + } + } +#endif #if defined(VK_USE_PLATFORM_XCB_KHR) if (demo->wsi_platform == WSI_PLATFORM_XCB || demo->wsi_platform == WSI_PLATFORM_AUTO) { bool xcb_extension_available = false; @@ -3713,30 +3836,6 @@ } } #endif -#if defined(VK_USE_PLATFORM_WAYLAND_KHR) - if (demo->wsi_platform == WSI_PLATFORM_WAYLAND || demo->wsi_platform == WSI_PLATFORM_AUTO) { - bool wayland_extension_available = false; - for (uint32_t i = 0; i < demo->enabled_extension_count; i++) { - if (strcmp(demo->extension_names[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) { - wayland_extension_available = true; - break; - } - } - if (wayland_extension_available) { - const char *error_msg = demo_init_wayland_connection(demo); - if (error_msg != NULL) { - if (demo->wsi_platform == WSI_PLATFORM_WAYLAND) { - fprintf(stderr, "%s\nExiting ...\n", error_msg); - fflush(stdout); - exit(1); - } - } else { - demo->wsi_platform = WSI_PLATFORM_WAYLAND; - return; - } - } - } -#endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) if (demo->wsi_platform == WSI_PLATFORM_DIRECTFB || demo->wsi_platform == WSI_PLATFORM_AUTO) { bool direftfb_extension_available = false; @@ -3808,7 +3907,7 @@ } } if (qnx_extension_available) { - demo->wsi_platform = WSI_PLATFORM_ANDROID; + demo->wsi_platform = WSI_PLATFORM_QNX; return; } } @@ -3841,7 +3940,7 @@ demo->is_minimized = false; demo->cmd_pool = VK_NULL_HANDLE; - err = volkInitialize(); + err = load_vulkan_library(); if (err != VK_SUCCESS) { ERR_EXIT( "Unable to find the Vulkan runtime on the system.\n\n" @@ -3979,98 +4078,95 @@ if (!surfaceExtFound) { ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", + " instance extension.\n\n" + "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not " + "configured to present to the screen. \n", "vkCreateInstance Failure"); } if (!platformSurfaceExtFound) { + switch (demo->wsi_platform) { #if defined(VK_USE_PLATFORM_WIN32_KHR) - if (demo->wsi_platform == WSI_PLATFORM_WIN32) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_WIN32): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform win32 is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_METAL_EXT) - if (demo->wsi_platform == WSI_PLATFORM_METAL) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_METAL_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_METAL): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_METAL_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform metal is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_XCB_KHR) - if (demo->wsi_platform == WSI_PLATFORM_XCB) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_XCB): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform xcb is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_WAYLAND_KHR) - if (demo->wsi_platform == WSI_PLATFORM_WAYLAND) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_WAYLAND): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform wayland is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_DISPLAY_KHR) - if (demo->wsi_platform == WSI_PLATFORM_DISPLAY) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_DISPLAY): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform display is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_ANDROID_KHR) - if (demo->wsi_platform == WSI_PLATFORM_ANDROID) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_ANDROID_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_ANDROID): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_ANDROID_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform android is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_XLIB_KHR) - if (demo->wsi_platform == WSI_PLATFORM_XLIB) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_XLIB): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform xlib is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) - if (demo->wsi_platform == WSI_PLATFORM_DIRECTFB) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_DIRECTFB): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform directfb is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_SCREEN_QNX) - if (demo->wsi_platform == WSI_PLATFORM_WIN32) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_QNX_SCREEN_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WSI_PLATFORM_QNX): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_QNX_SCREEN_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform qnx is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif - ERR_EXIT( - "vkEnumerateInstanceExtensionProperties failed to find any supported WSI surface extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); + default: + case (WSI_PLATFORM_AUTO): + // Getting here indicates we are using the WSI extension that is default on this platform + ERR_EXIT( + "vkEnumerateInstanceExtensionProperties failed to find any supported WSI surface instance extensions.\n\n" + "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not " + "configured to present to the screen. \n", + "vkCreateInstance Failure"); + break; + } } bool auto_wsi_platform = demo->wsi_platform == WSI_PLATFORM_AUTO; @@ -4142,7 +4238,7 @@ "vkCreateInstance Failure"); } - volkLoadInstance(demo->inst); + load_vulkan_instance_functions(demo->inst); } static void demo_select_physical_device(struct demo *demo) { @@ -4389,7 +4485,7 @@ err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device); assert(!err); - volkLoadDevice(demo->device); + load_vulkan_device_functions(demo->device); } static void demo_create_surface(struct demo *demo) { @@ -4591,37 +4687,6 @@ demo->quit = false; demo->curFrame = 0; - // Create semaphores to synchronize acquiring presentable buffers before - // rendering and waiting for drawing to be complete before presenting - VkSemaphoreCreateInfo semaphoreCreateInfo = { - .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, - .pNext = NULL, - .flags = 0, - }; - - // Create fences that we can use to throttle if we get too far - // ahead of the image presents - VkFenceCreateInfo fence_ci = { - .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = VK_FENCE_CREATE_SIGNALED_BIT}; - for (uint32_t i = 0; i < FRAME_LAG; i++) { - err = vkCreateFence(demo->device, &fence_ci, NULL, &demo->fences[i]); - assert(!err); - - err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_acquired_semaphores[i]); - assert(!err); - demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->image_acquired_semaphores[i], "AcquireSem(%u)", i); - - err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->draw_complete_semaphores[i]); - assert(!err); - demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->draw_complete_semaphores[i], "DrawCompleteSem(%u)", i); - - if (demo->separate_present_queue) { - err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_ownership_semaphores[i]); - assert(!err); - demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->image_ownership_semaphores[i], "ImageOwnerSem(%u)", i); - } - } - demo->frame_index = 0; demo->first_swapchain_frame = true; // Get Memory information and properties @@ -4824,6 +4889,8 @@ #endif } + demo->initialized = false; + demo_init_vk(demo); demo->spin_angle = 4.0f; @@ -4949,7 +5016,6 @@ #include <android_native_app_glue.h> #include "android_util.h" -static bool initialized = false; static bool active = false; struct demo demo; @@ -4969,7 +5035,7 @@ // is tied to the swapchain, it's easiest to simply cleanup and // start over (i.e. use a brute-force approach of re-starting // the app) - if (demo.prepared) { + if (demo.initialized) { demo_cleanup(&demo); } @@ -4994,7 +5060,6 @@ demo_select_physical_device(&demo); demo_init_vk_swapchain(&demo); demo_prepare(&demo); - initialized = true; } break; } @@ -5010,7 +5075,7 @@ } void android_main(struct android_app *app) { - demo.prepared = false; + demo.initialized = false; app->onAppCmd = processCommand; app->onInputEvent = processInput; @@ -5028,7 +5093,7 @@ return; } } - if (initialized && active) { + if (demo.initialized && demo.swapchain_ready && active) { demo_run(&demo); } } @@ -5073,12 +5138,15 @@ #endif #if defined(VK_USE_PLATFORM_DISPLAY_KHR) case (WSI_PLATFORM_DISPLAY): - // nothing to do here + // select physical device because display surface creation needs a gpu to be selected. + demo_select_physical_device(&demo); break; #endif } demo_create_surface(&demo); - demo_select_physical_device(&demo); + if (demo.wsi_platform != WSI_PLATFORM_DISPLAY) { + demo_select_physical_device(&demo); + } demo_init_vk_swapchain(&demo);
diff --git a/cube/cube.cpp b/cube/cube.cpp index 1bd24bb..b3934de 100644 --- a/cube/cube.cpp +++ b/cube/cube.cpp
@@ -2,7 +2,7 @@ * Copyright (c) 2015-2019 The Khronos Group Inc. * Copyright (c) 2015-2019 Valve Corporation * Copyright (c) 2015-2019 LunarG, Inc. - * Copyright (c) 2020 The Fuchsia Authors. + * Copyright (c) 2025 The Fuchsia Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,6 +20,7 @@ * Author: Charles Giessen <charles@lunarg.com> */ +#include <algorithm> #include <cassert> #include <cinttypes> #include <cstdio> @@ -56,13 +57,8 @@ #define VULKAN_HPP_NO_EXCEPTIONS #define VULKAN_HPP_TYPESAFE_CONVERSION 1 -// Volk requires VK_NO_PROTOTYPES before including vulkan.hpp -#define VK_NO_PROTOTYPES #include <vulkan/vulkan.hpp> -#define VOLK_IMPLEMENTATION -#include "volk.h" - VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE #include "linmath.h" @@ -261,13 +257,17 @@ if (str == "fuchsia_scenic") return WsiPlatform::fuchsia_scenic; #endif return WsiPlatform::invalid; -} +}; const char *wsi_to_string(WsiPlatform wsi_platform) { switch (wsi_platform) { case (WsiPlatform::auto_): return "auto"; #if defined(VK_USE_PLATFORM_WIN32_KHR) + case (WsiPlatform::win32): + return "win32"; +#endif +#if defined(VK_USE_PLATFORM_METAL_EXT) case (WsiPlatform::metal): return "metal"; #endif @@ -308,29 +308,36 @@ default: return "unknown"; } -} +}; -struct SwapchainImageResources { - vk::Image image; +struct SubmissionResources { + vk::Fence fence; + vk::Semaphore image_acquired_semaphore; vk::CommandBuffer cmd; vk::CommandBuffer graphics_to_present_cmd; - vk::ImageView view; vk::Buffer uniform_buffer; vk::DeviceMemory uniform_memory; void *uniform_memory_ptr = nullptr; - vk::Framebuffer framebuffer; vk::DescriptorSet descriptor_set; }; +struct SwapchainImageResources { + vk::Image image; + vk::ImageView view; + vk::Framebuffer framebuffer; + vk::Semaphore draw_complete_semaphore; + vk::Semaphore image_ownership_semaphore; +}; + struct Demo { - void build_image_ownership_cmd(const SwapchainImageResources &swapchain_image_resource); + void build_image_ownership_cmd(const SubmissionResources &submission_resource, + const SwapchainImageResources &swapchain_image_resource); vk::Bool32 check_layers(const std::vector<const char *> &check_names, const std::vector<vk::LayerProperties> &layers); void cleanup(); - void destroy_swapchain_related_resources(); void create_device(); void destroy_texture(texture_object &tex_objs); void draw(); - void draw_build_cmd(const SwapchainImageResources &swapchain_image_resource); + void draw_build_cmd(const SubmissionResources &submission_resource, const SwapchainImageResources &swapchain_image_resource); void prepare_init_cmd(); void flush_init_cmd(); void init(int argc, char **argv); @@ -338,14 +345,13 @@ void init_vk(); void select_physical_device(); void init_vk_swapchain(); + void prepare(); - void prepare_buffers(); void prepare_cube_data_buffers(); - void prepare_depth(); void prepare_descriptor_layout(); void prepare_descriptor_pool(); void prepare_descriptor_set(); - void prepare_framebuffers(); + void prepare_submission_sync_objects(); vk::ShaderModule prepare_shader_module(const uint32_t *code, size_t size); vk::ShaderModule prepare_vs(); vk::ShaderModule prepare_fs(); @@ -358,9 +364,13 @@ void resize(); void create_surface(); + void prepare_swapchain(); + void prepare_framebuffers(); + void prepare_depth(); + void set_image_layout(vk::Image image, vk::ImageAspectFlags aspectMask, vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::AccessFlags srcAccessMask, vk::PipelineStageFlags src_stages, vk::PipelineStageFlags dest_stages); - void update_data_buffer(); + void update_data_buffer(void *uniform_memory_ptr); bool loadTexture(const char *filename, uint8_t *rgba_data, vk::SubresourceLayout &layout, uint32_t &width, uint32_t &height); bool memory_type_from_properties(uint32_t typeBits, vk::MemoryPropertyFlags requirements_mask, uint32_t &typeIndex); vk::SurfaceFormatKHR pick_surface_format(const std::vector<vk::SurfaceFormatKHR> &surface_formats); @@ -370,47 +380,32 @@ const vk::DebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData); -#if defined(VK_USE_PLATFORM_WIN32_KHR) - void run(); - void create_window(); -#endif + template <WsiPlatform WSI_PLATFORM> + void create_window() = delete; + template <WsiPlatform WSI_PLATFORM> + void run() = delete; + template <WsiPlatform WSI_PLATFORM> + void execute(); #if defined(VK_USE_PLATFORM_XLIB_KHR) const char *init_xlib_connection(); - void create_xlib_window(); void handle_xlib_event(const XEvent *event); - void run_xlib(); #endif #if defined(VK_USE_PLATFORM_XCB_KHR) const char *init_xcb_connection(); void handle_xcb_event(const xcb_generic_event_t *event); - void run_xcb(); - void create_xcb_window(); #endif #if defined(VK_USE_PLATFORM_WAYLAND_KHR) const char *init_wayland_connection(); - void run_wayland(); - void create_wayland_window(); #endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) void handle_directfb_event(const DFBInputEvent *event); - void run_directfb(); - void create_directfb_window(); -#endif -#if defined(VK_USE_PLATFORM_METAL_EXT) - void run(); #endif #if defined(VK_USE_PLATFORM_DISPLAY_KHR) vk::Result create_display_surface(); - void run_display(); -#endif -#if defined(VK_USE_PLATFORM_SCREEN_QNX) - void run(); - void create_window(); #endif #if defined(VK_USE_PLATFORM_FUCHSIA) + // Returns a layer name of static storage duration. const char *get_fuchsia_image_pipe_layer() const; - void create_flatland_view(); - void run(); #endif std::string name = "vkcubepp"; // Name to put on the window/icon @@ -447,6 +442,7 @@ wl_seat *seat = nullptr; wl_pointer *pointer = nullptr; wl_keyboard *keyboard = nullptr; + int pending_width = 0, pending_height = 0; #endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) IDirectFB *dfb = nullptr; @@ -471,14 +467,16 @@ #endif WsiPlatform wsi_platform = WsiPlatform::auto_; vk::SurfaceKHR surface; - bool prepared = false; + bool initialized; + bool swapchain_ready; + bool is_minimized; bool use_staging_buffer = false; bool separate_present_queue = false; bool invalid_gpu_selection = false; int32_t gpu_number = 0; - // If true, the Demo renders on the protected memory. Currently, this - // feature is only supported on Fuchsia with specific hardware. + // If true, the Demo renders on the protected memory. This requires the + // physical device to support protected memory. bool protected_output = false; // If true, the Demo skips presenting the swapchain image to the display @@ -494,12 +492,11 @@ vk::Queue present_queue; uint32_t graphics_queue_family_index = 0; uint32_t present_queue_family_index = 0; - std::array<vk::Semaphore, FRAME_LAG> image_acquired_semaphores; - std::array<vk::Semaphore, FRAME_LAG> draw_complete_semaphores; - std::array<vk::Semaphore, FRAME_LAG> image_ownership_semaphores; vk::PhysicalDeviceProperties gpu_props; std::vector<vk::QueueFamilyProperties> queue_props; vk::PhysicalDeviceMemoryProperties memory_properties; + std::array<SubmissionResources, FRAME_LAG> submission_resources; + uint32_t current_submission_index = 0; std::vector<const char *> enabled_instance_extensions; std::vector<const char *> enabled_layers; @@ -511,10 +508,9 @@ vk::ColorSpaceKHR color_space; vk::SwapchainKHR swapchain; - std::vector<SwapchainImageResources> swapchain_image_resources; + std::vector<SwapchainImageResources> swapchain_resources; vk::PresentModeKHR presentMode = vk::PresentModeKHR::eFifo; - std::array<vk::Fence, FRAME_LAG> fences; - uint32_t frame_index = 0; + bool first_swapchain_frame; vk::CommandPool cmd_pool; vk::CommandPool present_cmd_pool; @@ -570,9 +566,6 @@ bool use_break = false; bool suppress_popups = false; bool force_errors = false; - bool is_minimized = false; - - uint32_t current_buffer = 0; }; #ifdef _WIN32 @@ -686,8 +679,12 @@ static const wl_registry_listener registry_listener = {registry_handle_global, registry_handle_global_remove}; #endif -void Demo::build_image_ownership_cmd(const SwapchainImageResources &swapchain_image_resource) { - auto result = swapchain_image_resource.graphics_to_present_cmd.begin( +void Demo::build_image_ownership_cmd(const SubmissionResources &submission_resource, + const SwapchainImageResources &swapchain_image_resource) { + auto result = submission_resource.graphics_to_present_cmd.reset(); + VERIFY(result == vk::Result::eSuccess); + + result = submission_resource.graphics_to_present_cmd.begin( vk::CommandBufferBeginInfo().setFlags(vk::CommandBufferUsageFlagBits::eSimultaneousUse)); VERIFY(result == vk::Result::eSuccess); @@ -702,11 +699,11 @@ .setImage(swapchain_image_resource.image) .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1)); - swapchain_image_resource.graphics_to_present_cmd.pipelineBarrier(vk::PipelineStageFlagBits::eBottomOfPipe, - vk::PipelineStageFlagBits::eBottomOfPipe, - vk::DependencyFlagBits(), {}, {}, image_ownership_barrier); + submission_resource.graphics_to_present_cmd.pipelineBarrier(vk::PipelineStageFlagBits::eBottomOfPipe, + vk::PipelineStageFlagBits::eBottomOfPipe, vk::DependencyFlagBits(), + {}, {}, image_ownership_barrier); - result = swapchain_image_resource.graphics_to_present_cmd.end(); + result = submission_resource.graphics_to_present_cmd.end(); VERIFY(result == vk::Result::eSuccess); } @@ -728,24 +725,53 @@ } void Demo::cleanup() { - prepared = false; + initialized = false; auto result = device.waitIdle(); VERIFY(result == vk::Result::eSuccess); - if (!is_minimized) { - destroy_swapchain_related_resources(); + + device.destroyCommandPool(cmd_pool); + if (separate_present_queue) { + device.destroyCommandPool(present_cmd_pool); } - // Wait for fences from present operations - for (uint32_t i = 0; i < FRAME_LAG; i++) { - device.destroyFence(fences[i]); - device.destroySemaphore(image_acquired_semaphores[i]); - device.destroySemaphore(draw_complete_semaphores[i]); + + device.destroyDescriptorPool(desc_pool); + + device.destroyPipeline(pipeline); + device.destroyPipelineCache(pipelineCache); + device.destroyRenderPass(render_pass); + device.destroyPipelineLayout(pipeline_layout); + device.destroyDescriptorSetLayout(desc_layout); + + for (const auto &tex : textures) { + device.destroyImageView(tex.view); + device.destroyImage(tex.image); + device.freeMemory(tex.mem); + device.destroySampler(tex.sampler); + } + + device.destroyImageView(depth.view); + device.destroyImage(depth.image); + device.freeMemory(depth.mem); + + for (auto &swapchain_resource : swapchain_resources) { + device.destroyFramebuffer(swapchain_resource.framebuffer); + device.destroyImageView(swapchain_resource.view); + device.destroySemaphore(swapchain_resource.draw_complete_semaphore); if (separate_present_queue) { - device.destroySemaphore(image_ownership_semaphores[i]); + device.destroySemaphore(swapchain_resource.image_ownership_semaphore); } } device.destroySwapchainKHR(swapchain); + for (const auto &submission_resource : submission_resources) { + device.destroyFence(submission_resource.fence); + device.destroySemaphore(submission_resource.image_acquired_semaphore); + device.destroyBuffer(submission_resource.uniform_buffer); + device.unmapMemory(submission_resource.uniform_memory); + device.freeMemory(submission_resource.uniform_memory); + } + device.destroy(); inst.destroySurfaceKHR(surface); @@ -802,20 +828,21 @@ float priorities = 0.0; std::vector<vk::DeviceQueueCreateInfo> queues; + const vk::DeviceQueueCreateFlags queue_create_flags = + protected_output ? vk::DeviceQueueCreateFlagBits::eProtected : vk::DeviceQueueCreateFlags{}; queues.push_back(vk::DeviceQueueCreateInfo() .setQueueFamilyIndex(graphics_queue_family_index) .setQueuePriorities(priorities) - .setFlags(protected_output ? vk::DeviceQueueCreateFlagBits::eProtected : vk::DeviceQueueCreateFlags{})); + .setFlags(queue_create_flags)); if (separate_present_queue) { queues.push_back( vk::DeviceQueueCreateInfo().setQueueFamilyIndex(present_queue_family_index).setQueuePriorities(priorities)); } - auto const protected_memory = vk::PhysicalDeviceProtectedMemoryFeatures().setProtectedMemory(protected_output); - + auto const protected_memory_features = vk::PhysicalDeviceProtectedMemoryFeatures().setProtectedMemory(protected_output); auto deviceInfo = vk::DeviceCreateInfo() - .setPNext(&protected_memory) + .setPNext(protected_output ? &protected_memory_features : nullptr) .setQueueCreateInfos(queues) .setPEnabledExtensionNames(enabled_device_extensions); auto device_return = gpu.createDevice(deviceInfo); @@ -832,15 +859,22 @@ } void Demo::draw() { + // Don't draw if initialization isn't complete, if the swapchain became outdated, or if the window is minimized + if (!initialized || !swapchain_ready || is_minimized) { + return; + } + + auto ¤t_submission = submission_resources[current_submission_index]; + // Ensure no more than FRAME_LAG renderings are outstanding - const vk::Result wait_result = device.waitForFences(fences[frame_index], VK_TRUE, UINT64_MAX); + const vk::Result wait_result = device.waitForFences(current_submission.fence, VK_TRUE, UINT64_MAX); VERIFY(wait_result == vk::Result::eSuccess || wait_result == vk::Result::eTimeout); - device.resetFences({fences[frame_index]}); vk::Result acquire_result; + uint32_t current_swapchain_image_index = 0; do { - acquire_result = - device.acquireNextImageKHR(swapchain, UINT64_MAX, image_acquired_semaphores[frame_index], vk::Fence(), ¤t_buffer); + acquire_result = device.acquireNextImageKHR(swapchain, UINT64_MAX, current_submission.image_acquired_semaphore, vk::Fence(), + ¤t_swapchain_image_index); if (acquire_result == vk::Result::eErrorOutOfDateKHR) { // demo.swapchain is out of date (e.g. the window was resized) and // must be recreated: @@ -856,9 +890,25 @@ } else { VERIFY(acquire_result == vk::Result::eSuccess); } + // If we minimized then stop trying to draw + if (!swapchain_ready) { + return; + } } while (acquire_result != vk::Result::eSuccess); - update_data_buffer(); + auto ¤t_swapchain_resource = swapchain_resources[current_swapchain_image_index]; + + update_data_buffer(submission_resources[current_submission_index].uniform_memory_ptr); + + draw_build_cmd(current_submission, current_swapchain_resource); + + if (separate_present_queue) { + build_image_ownership_cmd(current_submission, current_swapchain_resource); + } + + // Only reset right before submitting so we can't deadlock on an un-signalled fence that has nothing submitted to it + auto reset_result = device.resetFences({current_submission.fence}); + VERIFY(reset_result == vk::Result::eSuccess); // Wait for the image acquired semaphore to be signaled to ensure // that the image won't be rendered to until the presentation @@ -868,12 +918,12 @@ auto protected_submit_info = vk::ProtectedSubmitInfo().setProtectedSubmit(protected_output); auto submit_result = graphics_queue.submit(vk::SubmitInfo() - .setPNext(&protected_submit_info) + .setPNext(protected_output ? &protected_submit_info : nullptr) .setWaitDstStageMask(pipe_stage_flags) - .setWaitSemaphores(image_acquired_semaphores[frame_index]) - .setCommandBuffers(swapchain_image_resources[current_buffer].cmd) - .setSignalSemaphores(draw_complete_semaphores[frame_index]), - fences[frame_index]); + .setWaitSemaphores(current_submission.image_acquired_semaphore) + .setCommandBuffers(current_submission.cmd) + .setSignalSemaphores(current_swapchain_resource.draw_complete_semaphore), + current_submission.fence); VERIFY(submit_result == vk::Result::eSuccess); if (separate_present_queue) { @@ -884,23 +934,24 @@ auto change_owner_result = present_queue.submit(vk::SubmitInfo() .setWaitDstStageMask(pipe_stage_flags) - .setWaitSemaphores(draw_complete_semaphores[frame_index]) - .setCommandBuffers(swapchain_image_resources[current_buffer].graphics_to_present_cmd) - .setSignalSemaphores(image_ownership_semaphores[frame_index])); + .setWaitSemaphores(current_swapchain_resource.draw_complete_semaphore) + .setCommandBuffers(current_submission.graphics_to_present_cmd) + .setSignalSemaphores(current_swapchain_resource.image_ownership_semaphore)); VERIFY(change_owner_result == vk::Result::eSuccess); } const auto presentInfo = vk::PresentInfoKHR() - .setWaitSemaphores(separate_present_queue ? image_ownership_semaphores[frame_index] - : draw_complete_semaphores[frame_index]) + .setWaitSemaphores(separate_present_queue ? current_swapchain_resource.image_ownership_semaphore + : current_swapchain_resource.draw_complete_semaphore) .setSwapchains(swapchain) - .setImageIndices(current_buffer); + .setImageIndices(current_swapchain_image_index); // If we are using separate queues we have to wait for image ownership, // otherwise wait for draw complete auto present_result = present_queue.presentKHR(&presentInfo); - frame_index += 1; - frame_index %= FRAME_LAG; + current_submission_index += 1; + current_submission_index %= FRAME_LAG; + first_swapchain_frame = false; if (present_result == vk::Result::eErrorOutOfDateKHR) { // swapchain is out of date (e.g. the window was resized) and // must be recreated: @@ -922,12 +973,14 @@ } } -void Demo::draw_build_cmd(const SwapchainImageResources &swapchain_image_resource) { - const auto commandBuffer = swapchain_image_resource.cmd; +void Demo::draw_build_cmd(const SubmissionResources &submission_resource, const SwapchainImageResources &swapchain_image_resource) { + const auto commandBuffer = submission_resource.cmd; vk::ClearValue const clearValues[2] = {vk::ClearColorValue(std::array<float, 4>({{0.2f, 0.2f, 0.2f, 0.2f}})), vk::ClearDepthStencilValue(1.0f, 0u)}; + auto result = commandBuffer.reset(); + VERIFY(result == vk::Result::eSuccess); - auto result = commandBuffer.begin(vk::CommandBufferBeginInfo().setFlags(vk::CommandBufferUsageFlagBits::eSimultaneousUse)); + result = commandBuffer.begin(vk::CommandBufferBeginInfo().setFlags(vk::CommandBufferUsageFlagBits::eSimultaneousUse)); VERIFY(result == vk::Result::eSuccess); commandBuffer.beginRenderPass(vk::RenderPassBeginInfo() @@ -939,8 +992,7 @@ vk::SubpassContents::eInline); commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline); - commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0, swapchain_image_resource.descriptor_set, - {}); + commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0, submission_resource.descriptor_set, {}); float viewport_dimension; float viewport_x = 0.0f; float viewport_y = 0.0f; @@ -994,11 +1046,11 @@ } void Demo::prepare_init_cmd() { - auto cmd_pool_info = vk::CommandPoolCreateInfo().setQueueFamilyIndex(graphics_queue_family_index); - if (protected_output) { - cmd_pool_info.setFlags(vk::CommandPoolCreateFlagBits::eProtected); - } - auto cmd_pool_return = device.createCommandPool(cmd_pool_info); + vk::CommandPoolCreateFlags cmd_pool_create_flags = + protected_output ? vk::CommandPoolCreateFlagBits::eProtected : vk::CommandPoolCreateFlags{}; + cmd_pool_create_flags |= vk::CommandPoolCreateFlagBits::eResetCommandBuffer; + auto cmd_pool_return = device.createCommandPool( + vk::CommandPoolCreateInfo().setQueueFamilyIndex(graphics_queue_family_index).setFlags(cmd_pool_create_flags)); VERIFY(cmd_pool_return.result == vk::Result::eSuccess); cmd_pool = cmd_pool_return.value; @@ -1027,7 +1079,8 @@ auto fence = fence_return.value; auto const protected_submit_info = vk::ProtectedSubmitInfo().setProtectedSubmit(protected_output); - result = graphics_queue.submit(vk::SubmitInfo().setPNext(&protected_submit_info).setCommandBuffers(cmd), fence); + result = graphics_queue.submit( + vk::SubmitInfo().setPNext(protected_output ? &protected_submit_info : nullptr).setCommandBuffers(cmd), fence); VERIFY(result == vk::Result::eSuccess); result = device.waitForFences(fence, VK_TRUE, UINT64_MAX); @@ -1124,7 +1177,6 @@ skip_present = true; continue; } - if ((strcmp(argv[i], "--wsi") == 0) && (i < argc - 1)) { std::string selection_input = argv[i + 1]; for (char &c : selection_input) { @@ -1191,9 +1243,9 @@ << "\t[--break] [--c <framecount>] [--suppress_popups]\n" << "\t[--gpu_number <index of physical device>]\n" << "\t[--present_mode <present mode enum>]\n" - << "\t[--protected_output]\n" << "\t[--width <width>] [--height <height>]\n" << "\t[--force_errors]\n" + << "\t[--protected_output]\n" << "\t[--wsi <" << wsi_platforms << ">]\n" << "\t<present_mode_enum>\n" << "\t\tVK_PRESENT_MODE_IMMEDIATE_KHR = " << VK_PRESENT_MODE_IMMEDIATE_KHR << "\n" @@ -1210,6 +1262,8 @@ exit(1); } + initialized = false; + init_vk(); spin_angle = 4.0f; @@ -1280,6 +1334,25 @@ #endif void Demo::check_and_set_wsi_platform() { +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + if (wsi_platform == WsiPlatform::wayland || wsi_platform == WsiPlatform::auto_) { + auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(), + [](const char *str) { return 0 == strcmp(str, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); }); + if (found != enabled_instance_extensions.end()) { + const char *error_msg = init_wayland_connection(); + if (error_msg != NULL) { + if (wsi_platform == WsiPlatform::wayland) { + fprintf(stderr, "%s\nExiting ...\n", error_msg); + fflush(stdout); + exit(1); + } + } else { + wsi_platform = WsiPlatform::wayland; + return; + } + } + } +#endif #if defined(VK_USE_PLATFORM_XCB_KHR) if (wsi_platform == WsiPlatform::xcb || wsi_platform == WsiPlatform::auto_) { auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(), @@ -1318,25 +1391,6 @@ } } #endif -#if defined(VK_USE_PLATFORM_WAYLAND_KHR) - if (wsi_platform == WsiPlatform::wayland || wsi_platform == WsiPlatform::auto_) { - auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(), - [](const char *str) { return 0 == strcmp(str, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); }); - if (found != enabled_instance_extensions.end()) { - const char *error_msg = init_wayland_connection(); - if (error_msg != NULL) { - if (wsi_platform == WsiPlatform::wayland) { - fprintf(stderr, "%s\nExiting ...\n", error_msg); - fflush(stdout); - exit(1); - } - } else { - wsi_platform = WsiPlatform::wayland; - return; - } - } - } -#endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) if (wsi_platform == WsiPlatform::directfb || wsi_platform == WsiPlatform::auto_) { auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(), @@ -1400,7 +1454,7 @@ #endif #if defined(VK_USE_PLATFORM_FUCHSIA) if (wsi_platform == WsiPlatform::auto_) { - ERR_EXIT("auto WSI platform is not supported", "check_and_set_wsi_platform error"); + ERR_EXIT("auto WSI platform is not supported on Fuchsia", "check_and_set_wsi_platform error"); } #endif } @@ -1516,27 +1570,21 @@ } void Demo::init_vk() { - // See https://github.com/KhronosGroup/Vulkan-Hpp/pull/1755 - // Currently Vulkan-Hpp doesn't check for libvulkan.1.dylib - // Which affects vkcube installation on Apple platforms. - VkResult err = volkInitialize(); - if (err != VK_SUCCESS) { - ERR_EXIT( - "Unable to find the Vulkan runtime on the system.\n\n" - "This likely indicates that no Vulkan capable drivers are installed.", - "Installation Failure"); - } - - VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr); - - std::vector<char const *> instance_validation_layers = {"VK_LAYER_KHRONOS_validation"}; + VULKAN_HPP_DEFAULT_DISPATCHER.init(); uint32_t apiVersion = 0; - vk::enumerateInstanceVersion(&apiVersion); - if (protected_output && apiVersion < VK_MAKE_VERSION(1, 1, 0)) { - ERR_EXIT("Need vulkan 1.1 for protected output.", "vkCreateInstance Failure"); + vk::Result enumerate_instance_version_result = vk::enumerateInstanceVersion(&apiVersion); + if (protected_output) { + if (enumerate_instance_version_result != vk::Result::eSuccess) { + ERR_EXIT("Failed to query instance version.", "vkCreateInstance Failure"); + } + if (apiVersion < VK_MAKE_VERSION(1, 1, 0)) { + ERR_EXIT("Need Vulkan 1.1 instance for protected output.", "vkCreateInstance Failure"); + } } + std::vector<char const *> instance_validation_layers = {"VK_LAYER_KHRONOS_validation"}; + // Look for validation layers vk::Bool32 validation_found = VK_FALSE; if (validate) { @@ -1561,15 +1609,19 @@ vk::Bool32 platformSurfaceExtFound = VK_FALSE; bool portabilityEnumerationActive = false; + // Some platforms (for example, Fuchsia) may have their WSI instance + // extension in layers and require the client to manually specify the + // instance extension layer. + vk::Optional<const std::string> instance_extension_layer = nullptr; #if VK_USE_PLATFORM_FUCHSIA - std::string kLayerName = get_fuchsia_image_pipe_layer(); - vk::Optional<const std::string> kLayer(kLayerName); + const char *image_pipe_layer_name = get_fuchsia_image_pipe_layer(); + enabled_layers.push_back(image_pipe_layer_name); - enabled_layers.push_back(kLayerName.c_str()); -#else - vk::Optional<const std::string> kLayer{nullptr}; -#endif - auto instance_extensions_return = vk::enumerateInstanceExtensionProperties(kLayer); + const std::string image_pipe_layer_name_str = image_pipe_layer_name; + instance_extension_layer = image_pipe_layer_name_str; +#endif // VK_USE_PLATFORM_FUCHSIA + + auto instance_extensions_return = vk::enumerateInstanceExtensionProperties(instance_extension_layer); VERIFY(instance_extensions_return.result == vk::Result::eSuccess); for (const auto &extension : instance_extensions_return.value) { @@ -1653,102 +1705,96 @@ if (!surfaceExtFound) { ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", + " instance extension.\n\n" + "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not " + "configured to present to the screen. \n", "vkCreateInstance Failure"); } if (!platformSurfaceExtFound) { + switch (wsi_platform) { #if defined(VK_USE_PLATFORM_WIN32_KHR) - if (wsi_platform == WsiPlatform::win32) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::win32): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform win32 is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_XCB_KHR) - if (wsi_platform == WsiPlatform::xcb) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::xcb): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform xcb is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_WAYLAND_KHR) - if (wsi_platform == WsiPlatform::wayland) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::wayland): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform wayland is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_XLIB_KHR) - if (wsi_platform == WsiPlatform::xlib) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::xlib): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform xlib is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) - if (wsi_platform == WsiPlatform::directfb) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::directfb): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform directfb is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_DISPLAY_KHR) - if (wsi_platform == WsiPlatform::display) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME - " extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::display): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform display is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_METAL_EXT) - if (wsi_platform == WsiPlatform::metal) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_METAL_SURFACE_EXTENSION_NAME - " extension.\n\nDo you have a compatible " - "Vulkan installable client driver (ICD) installed?\nPlease " - "look at the Getting Started guide for additional " - "information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::metal): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_METAL_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform metal is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_SCREEN_QNX) - if (wsi_platform == WsiPlatform::qnx) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_QNX_SCREEN_SURFACE_EXTENSION_NAME - " extension.\n\nDo you have a compatible " - "Vulkan installable client driver (ICD) installed?\nPlease " - "look at the Getting Started guide for additional " - "information.\n", - "vkCreateInstance Failure"); - } + case (WsiPlatform::qnx): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_QNX_SCREEN_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform qnx is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; #endif #if defined(VK_USE_PLATFORM_FUCHSIA) - if (wsi_platform == WsiPlatform::fuchsia_display || wsi_platform == WsiPlatform::fuchsia_scenic) { - ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME - " extension.\n\nDo you have a compatible " - "Vulkan installable client driver (ICD) installed?\nPlease " - "look at the Getting Started guide for additional " - "information.\n", + case (WsiPlatform::fuchsia_display): + case (WsiPlatform::fuchsia_scenic): + ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME + " instance extension.\n\n" + "The selected WSI platform fuschia is not available, please choose a different WSI platform\n", + "vkCreateInstance Failure"); + break; +#endif + default: + case (WsiPlatform::auto_): + // Getting here indicates we are using the WSI extension that is default on this platform + ERR_EXIT( + "vkEnumerateInstanceExtensionProperties failed to find any supported WSI surface instance extensions.\n\n" + "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not " + "configured to present to the screen. \n", "vkCreateInstance Failure"); } -#endif - ERR_EXIT( - "vkEnumerateInstanceExtensionProperties failed to find any supported WSI surface extension.\n\n" - "Do you have a compatible Vulkan installable client driver (ICD) installed?\n" - "Please look at the Getting Started guide for additional information.\n", - "vkCreateInstance Failure"); } bool auto_wsi_platform = wsi_platform == WsiPlatform::auto_; @@ -1837,7 +1883,9 @@ exit(1); } #else - printf("WSI selection was set to DISPLAY but vkcubepp was not compiled with support for the DISPLAY platform, exiting \n"); + printf( + "WSI selection was set to DISPLAY but vkcubepp was not compiled with support for the DISPLAY platform, exiting " + "\n"); fflush(stdout); exit(1); #endif @@ -1850,21 +1898,17 @@ assert(physicalDeviceProperties.deviceType <= vk::PhysicalDeviceType::eCpu); auto support_result = physical_devices[i].getSurfaceSupportKHR(0, surface); - if (support_result.result != vk::Result::eSuccess || - support_result.value != vk::True) { + if (support_result.result != vk::Result::eSuccess || support_result.value != vk::True) { continue; } std::map<vk::PhysicalDeviceType, int> device_type_priorities = { - {vk::PhysicalDeviceType::eDiscreteGpu, 5}, - {vk::PhysicalDeviceType::eIntegratedGpu, 4}, - {vk::PhysicalDeviceType::eVirtualGpu, 3}, - {vk::PhysicalDeviceType::eCpu, 2}, + {vk::PhysicalDeviceType::eDiscreteGpu, 5}, {vk::PhysicalDeviceType::eIntegratedGpu, 4}, + {vk::PhysicalDeviceType::eVirtualGpu, 3}, {vk::PhysicalDeviceType::eCpu, 2}, {vk::PhysicalDeviceType::eOther, 1}, }; int priority = -1; - if (device_type_priorities.find(physicalDeviceProperties.deviceType) != - device_type_priorities.end()) { + if (device_type_priorities.find(physicalDeviceProperties.deviceType) != device_type_priorities.end()) { priority = device_type_priorities[physicalDeviceProperties.deviceType]; } @@ -1886,15 +1930,22 @@ /* Look for device extensions */ vk::Bool32 swapchainExtFound = VK_FALSE; - // TODO(https://fxbug.dev/378964821): Remove the redundancy here. + // Some platforms (for example, Fuchsia) may have their device swapchain + // extension in layers and require the client to manually specify the + // device swapchain extension layer. + vk::Optional<const std::string> device_extension_layer = nullptr; #if VK_USE_PLATFORM_FUCHSIA - std::string kLayerName = get_fuchsia_image_pipe_layer(); - vk::Optional<const std::string> kLayer(kLayerName); -#else - vk::Optional<const std::string> kLayer{nullptr}; -#endif + const std::string image_pipe_layer_name = get_fuchsia_image_pipe_layer(); + device_extension_layer = image_pipe_layer_name; +#endif // VK_USE_PLATFORM_FUCHSIA - auto device_extension_return = gpu.enumerateDeviceExtensionProperties(kLayer); + // Currently we assume that the device swapchain extension layer is always + // enabled when the instance is initialized. + assert((!device_extension_layer) || (std::any_of(enabled_layers.begin(), enabled_layers.end(), [&](const char *layer_name) { + return *device_extension_layer == layer_name; + }))); + + auto device_extension_return = gpu.enumerateDeviceExtensionProperties(device_extension_layer); VERIFY(device_extension_return.result == vk::Result::eSuccess); for (const auto &extension : device_extension_return.value) { @@ -1917,7 +1968,7 @@ gpu.getProperties(&gpu_props); if (protected_output && gpu_props.apiVersion < VK_MAKE_VERSION(1, 1, 0)) { - ERR_EXIT("Need vulkan physical device 1.1 for protected output.", "vkcube"); + ERR_EXIT("Need Vulkan 1.1 physical device for protected output.", "VkPhysicalDevice failure"); } /* Call with nullptr data to get count */ @@ -2087,58 +2138,31 @@ color_space = surfaceFormat.colorSpace; quit = false; + first_swapchain_frame = true; curFrame = 0; - // Create semaphores to synchronize acquiring presentable buffers before - // rendering and waiting for drawing to be complete before presenting - auto const semaphoreCreateInfo = vk::SemaphoreCreateInfo(); - - // Create fences that we can use to throttle if we get too far - // ahead of the image presents - auto const fence_ci = vk::FenceCreateInfo().setFlags(vk::FenceCreateFlagBits::eSignaled); - for (uint32_t i = 0; i < FRAME_LAG; i++) { - vk::Result result = device.createFence(&fence_ci, nullptr, &fences[i]); - VERIFY(result == vk::Result::eSuccess); - - result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &image_acquired_semaphores[i]); - VERIFY(result == vk::Result::eSuccess); - - result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &draw_complete_semaphores[i]); - VERIFY(result == vk::Result::eSuccess); - - if (separate_present_queue) { - result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &image_ownership_semaphores[i]); - VERIFY(result == vk::Result::eSuccess); - } - } - frame_index = 0; - // Get Memory information and properties memory_properties = gpu.getMemoryProperties(); } void Demo::prepare() { - prepare_buffers(); - if (is_minimized) { - prepared = false; - return; - } prepare_init_cmd(); - prepare_depth(); prepare_textures(); prepare_cube_data_buffers(); prepare_descriptor_layout(); + // Only need to know the format of the depth buffer before we create the renderpass + depth.format = vk::Format::eD16Unorm; prepare_render_pass(); prepare_pipeline(); - for (auto &swapchain_image_resource : swapchain_image_resources) { + for (auto &submission_resource : submission_resources) { auto alloc_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo() .setCommandPool(cmd_pool) .setLevel(vk::CommandBufferLevel::ePrimary) .setCommandBufferCount(1)); VERIFY(alloc_return.result == vk::Result::eSuccess); - swapchain_image_resource.cmd = alloc_return.value[0]; + submission_resource.cmd = alloc_return.value[0]; } if (separate_present_queue) { @@ -2147,14 +2171,13 @@ VERIFY(present_cmd_pool_return.result == vk::Result::eSuccess); present_cmd_pool = present_cmd_pool_return.value; - for (auto &swapchain_image_resource : swapchain_image_resources) { + for (auto &submission_resource : submission_resources) { auto alloc_cmd_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo() .setCommandPool(present_cmd_pool) .setLevel(vk::CommandBufferLevel::ePrimary) .setCommandBufferCount(1)); VERIFY(alloc_cmd_return.result == vk::Result::eSuccess); - swapchain_image_resource.graphics_to_present_cmd = alloc_cmd_return.value[0]; - build_image_ownership_cmd(swapchain_image_resource); + submission_resource.graphics_to_present_cmd = alloc_cmd_return.value[0]; } } @@ -2163,9 +2186,7 @@ prepare_framebuffers(); - for (const auto &swapchain_image_resource : swapchain_image_resources) { - draw_build_cmd(swapchain_image_resource); - } + prepare_submission_sync_objects(); /* * Prepare functions above may generate pipeline commands @@ -2176,13 +2197,22 @@ destroy_texture(staging_texture); } - current_buffer = 0; - prepared = true; + initialized = true; + + prepare_swapchain(); } -void Demo::prepare_buffers() { +// Creates the swapchain, swapchain image views, depth buffer, framebuffers, and sempahores. +// This function returns early if it fails to create a swapchain, setting swapchain_ready to false. +void Demo::prepare_swapchain() { vk::SwapchainKHR oldSwapchain = swapchain; +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + if (wsi_platform == WsiPlatform::wayland && !xdg_surface_has_been_configured) { + return; + } +#endif + // Check the surface capabilities and formats auto surface_capabilities_return = gpu.getSurfaceCapabilitiesKHR(surface); VERIFY(surface_capabilities_return.result == vk::Result::eSuccess); @@ -2299,26 +2329,28 @@ } } - auto swapchain_return = device.createSwapchainKHR( - vk::SwapchainCreateInfoKHR() - .setSurface(surface) - .setMinImageCount(desiredNumOfSwapchainImages) - .setImageFormat(format) - .setImageColorSpace(color_space) - .setImageExtent({swapchainExtent.width, swapchainExtent.height}) - .setImageArrayLayers(1) - .setImageUsage(vk::ImageUsageFlagBits::eColorAttachment) - .setImageSharingMode(vk::SharingMode::eExclusive) - .setPreTransform(preTransform) - .setCompositeAlpha(compositeAlpha) - .setPresentMode(swapchainPresentMode) - .setClipped(true) - .setOldSwapchain(oldSwapchain) - .setFlags(protected_output ? vk::SwapchainCreateFlagBitsKHR::eProtected : vk::SwapchainCreateFlagsKHR{})); + const vk::SwapchainCreateFlagsKHR swapchain_create_flags = + protected_output ? vk::SwapchainCreateFlagBitsKHR::eProtected : vk::SwapchainCreateFlagsKHR{}; + auto swapchain_return = device.createSwapchainKHR(vk::SwapchainCreateInfoKHR() + .setSurface(surface) + .setMinImageCount(desiredNumOfSwapchainImages) + .setImageFormat(format) + .setImageColorSpace(color_space) + .setImageExtent({swapchainExtent.width, swapchainExtent.height}) + .setImageArrayLayers(1) + .setImageUsage(vk::ImageUsageFlagBits::eColorAttachment) + .setImageSharingMode(vk::SharingMode::eExclusive) + .setPreTransform(preTransform) + .setCompositeAlpha(compositeAlpha) + .setPresentMode(swapchainPresentMode) + .setClipped(true) + .setOldSwapchain(oldSwapchain) + .setFlags(swapchain_create_flags)); VERIFY(swapchain_return.result == vk::Result::eSuccess); swapchain = swapchain_return.value; // If we just re-created an existing swapchain, we should destroy the + // old // swapchain at this point. // Note: destroying the swapchain also cleans up all its associated // presentable images once the platform is done with them. @@ -2328,22 +2360,41 @@ auto swapchain_images_return = device.getSwapchainImagesKHR(swapchain); VERIFY(swapchain_images_return.result == vk::Result::eSuccess); - swapchain_image_resources.resize(swapchain_images_return.value.size()); + swapchain_resources.resize(swapchain_images_return.value.size()); - for (uint32_t i = 0; i < swapchain_image_resources.size(); ++i) { + for (uint32_t i = 0; i < swapchain_resources.size(); ++i) { auto color_image_view = vk::ImageViewCreateInfo() .setViewType(vk::ImageViewType::e2D) .setFormat(format) .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1)); - swapchain_image_resources[i].image = swapchain_images_return.value[i]; + swapchain_resources[i].image = swapchain_images_return.value[i]; - color_image_view.image = swapchain_image_resources[i].image; + color_image_view.image = swapchain_resources[i].image; auto image_view_return = device.createImageView(color_image_view); VERIFY(image_view_return.result == vk::Result::eSuccess); - swapchain_image_resources[i].view = image_view_return.value; + swapchain_resources[i].view = image_view_return.value; } + + // Create semaphores to synchronize acquiring presentable buffers before + // rendering and waiting for drawing to be complete before presenting + auto const semaphoreCreateInfo = vk::SemaphoreCreateInfo(); + + for (auto &swapchain_resource : swapchain_resources) { + auto result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &swapchain_resource.draw_complete_semaphore); + VERIFY(result == vk::Result::eSuccess); + + if (separate_present_queue) { + result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &swapchain_resource.image_ownership_semaphore); + VERIFY(result == vk::Result::eSuccess); + } + } + + prepare_depth(); + prepare_framebuffers(); + swapchain_ready = true; + first_swapchain_frame = true; } void Demo::prepare_cube_data_buffers() { @@ -2370,12 +2421,12 @@ auto const buf_info = vk::BufferCreateInfo().setSize(sizeof(data)).setUsage(vk::BufferUsageFlagBits::eUniformBuffer); - for (auto &swapchain_image_resource : swapchain_image_resources) { - auto result = device.createBuffer(&buf_info, nullptr, &swapchain_image_resource.uniform_buffer); + for (auto &submission_resource : submission_resources) { + auto result = device.createBuffer(&buf_info, nullptr, &submission_resource.uniform_buffer); VERIFY(result == vk::Result::eSuccess); vk::MemoryRequirements mem_reqs; - device.getBufferMemoryRequirements(swapchain_image_resource.uniform_buffer, &mem_reqs); + device.getBufferMemoryRequirements(submission_resource.uniform_buffer, &mem_reqs); auto mem_alloc = vk::MemoryAllocateInfo().setAllocationSize(mem_reqs.size).setMemoryTypeIndex(0); @@ -2384,16 +2435,16 @@ mem_alloc.memoryTypeIndex); VERIFY(pass); - result = device.allocateMemory(&mem_alloc, nullptr, &swapchain_image_resource.uniform_memory); + result = device.allocateMemory(&mem_alloc, nullptr, &submission_resource.uniform_memory); VERIFY(result == vk::Result::eSuccess); - result = device.mapMemory(swapchain_image_resource.uniform_memory, 0, VK_WHOLE_SIZE, vk::MemoryMapFlags(), - &swapchain_image_resource.uniform_memory_ptr); + result = device.mapMemory(submission_resource.uniform_memory, 0, VK_WHOLE_SIZE, vk::MemoryMapFlags(), + &submission_resource.uniform_memory_ptr); VERIFY(result == vk::Result::eSuccess); - memcpy(swapchain_image_resource.uniform_memory_ptr, &data, sizeof data); + memcpy(submission_resource.uniform_memory_ptr, &data, sizeof data); - result = device.bindBufferMemory(swapchain_image_resource.uniform_buffer, swapchain_image_resource.uniform_memory, 0); + result = device.bindBufferMemory(submission_resource.uniform_buffer, submission_resource.uniform_memory, 0); VERIFY(result == vk::Result::eSuccess); } } @@ -2475,13 +2526,13 @@ std::array<vk::DescriptorPoolSize, 2> const poolSizes = { vk::DescriptorPoolSize() .setType(vk::DescriptorType::eUniformBuffer) - .setDescriptorCount(static_cast<uint32_t>(swapchain_image_resources.size())), + .setDescriptorCount(static_cast<uint32_t>(submission_resources.size())), vk::DescriptorPoolSize() .setType(vk::DescriptorType::eCombinedImageSampler) - .setDescriptorCount(static_cast<uint32_t>(swapchain_image_resources.size()) * texture_count)}; + .setDescriptorCount(static_cast<uint32_t>(submission_resources.size()) * texture_count)}; auto const descriptor_pool = - vk::DescriptorPoolCreateInfo().setMaxSets(static_cast<uint32_t>(swapchain_image_resources.size())).setPoolSizes(poolSizes); + vk::DescriptorPoolCreateInfo().setMaxSets(static_cast<uint32_t>(submission_resources.size())).setPoolSizes(poolSizes); auto result = device.createDescriptorPool(&descriptor_pool, nullptr, &desc_pool); VERIFY(result == vk::Result::eSuccess); @@ -2507,13 +2558,13 @@ .setDescriptorType(vk::DescriptorType::eCombinedImageSampler) .setImageInfo(tex_descs); - for (auto &swapchain_image_resource : swapchain_image_resources) { - auto result = device.allocateDescriptorSets(&alloc_info, &swapchain_image_resource.descriptor_set); + for (auto &submission_resource : submission_resources) { + auto result = device.allocateDescriptorSets(&alloc_info, &submission_resource.descriptor_set); VERIFY(result == vk::Result::eSuccess); - buffer_info.setBuffer(swapchain_image_resource.uniform_buffer); - writes[0].setDstSet(swapchain_image_resource.descriptor_set); - writes[1].setDstSet(swapchain_image_resource.descriptor_set); + buffer_info.setBuffer(submission_resource.uniform_buffer); + writes[0].setDstSet(submission_resource.descriptor_set); + writes[1].setDstSet(submission_resource.descriptor_set); device.updateDescriptorSets(writes, {}); } } @@ -2522,7 +2573,7 @@ std::array<vk::ImageView, 2> attachments; attachments[1] = depth.view; - for (auto &swapchain_image_resource : swapchain_image_resources) { + for (auto &swapchain_image_resource : swapchain_resources) { attachments[0] = swapchain_image_resource.view; auto const framebuffer_return = device.createFramebuffer(vk::FramebufferCreateInfo() .setRenderPass(render_pass) @@ -2535,6 +2586,23 @@ } } +void Demo::prepare_submission_sync_objects() { + // Create semaphores to synchronize acquiring presentable buffers before + // rendering and waiting for drawing to be complete before presenting + auto const semaphoreCreateInfo = vk::SemaphoreCreateInfo(); + + // Create fences that we can use to throttle if we get too far + // ahead of the image presents + auto const fence_ci = vk::FenceCreateInfo().setFlags(vk::FenceCreateFlagBits::eSignaled); + for (auto &submission_resource : submission_resources) { + vk::Result result = device.createFence(&fence_ci, nullptr, &submission_resource.fence); + VERIFY(result == vk::Result::eSuccess); + + result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &submission_resource.image_acquired_semaphore); + VERIFY(result == vk::Result::eSuccess); + } +} + vk::ShaderModule Demo::prepare_fs() { const uint32_t fragShaderCode[] = { #ifdef CUBE_FRAG_INC @@ -2741,7 +2809,7 @@ auto const image_create_info = vk::ImageCreateInfo() .setImageType(vk::ImageType::e2D) - .setFormat(vk::Format::eR8G8B8A8Unorm) + .setFormat(vk::Format::eR8G8B8A8Srgb) .setExtent({tex_obj.tex_width, tex_obj.tex_height, 1}) .setMipLevels(1) .setArrayLayers(1) @@ -2788,7 +2856,7 @@ } void Demo::prepare_textures() { - vk::Format const tex_format = vk::Format::eR8G8B8A8Unorm; + vk::Format const tex_format = vk::Format::eR8G8B8A8Srgb; vk::FormatProperties props; gpu.getFormatProperties(tex_format, &props); @@ -2836,7 +2904,7 @@ textures[i].imageLayout, vk::AccessFlagBits::eTransferWrite, vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eFragmentShader); } else { - assert(false && "No support for R8G8B8A8_UNORM as texture image format"); + assert(false && "No support for R8G8B8A8_SRGB as texture image format"); } auto const samplerInfo = vk::SamplerCreateInfo() @@ -2884,63 +2952,48 @@ return vert_shader_module; } -void Demo::destroy_swapchain_related_resources() { - device.destroyDescriptorPool(desc_pool); - - device.destroyPipeline(pipeline); - device.destroyPipelineCache(pipelineCache); - device.destroyRenderPass(render_pass); - device.destroyPipelineLayout(pipeline_layout); - device.destroyDescriptorSetLayout(desc_layout); - - for (const auto &tex : textures) { - device.destroyImageView(tex.view); - device.destroyImage(tex.image); - device.freeMemory(tex.mem); - device.destroySampler(tex.sampler); - } - - device.destroyImageView(depth.view); - device.destroyImage(depth.image); - device.freeMemory(depth.mem); - - for (const auto &resource : swapchain_image_resources) { - device.destroyFramebuffer(resource.framebuffer); - device.destroyImageView(resource.view); - device.freeCommandBuffers(cmd_pool, {resource.cmd}); - device.destroyBuffer(resource.uniform_buffer); - device.unmapMemory(resource.uniform_memory); - device.freeMemory(resource.uniform_memory); - } - - device.destroyCommandPool(cmd_pool); - if (separate_present_queue) { - device.destroyCommandPool(present_cmd_pool); - } -} - void Demo::resize() { // Don't react to resize until after first initialization. - if (!prepared) { - if (is_minimized) { - prepare(); - } + if (!initialized) { return; } + // Don't do anything if the surface has zero size, as vulkan disallows creating swapchains with zero area + // We use is_minimized to track this because zero size window usually occurs from minimizing + if (width == 0 || height == 0) { + is_minimized = true; + return; + } else { + is_minimized = false; + } + // In order to properly resize the window, we must re-create the // swapchain - // AND redo the command buffers, etc. // - // First, perform part of the cleanup() function: - prepared = false; - auto result = device.waitIdle(); - VERIFY(result == vk::Result::eSuccess); - destroy_swapchain_related_resources(); + // First, destroy the old swapchain and its associated resources, setting swapchain_ready to false to prevent draw from + // running + if (swapchain_ready) { + swapchain_ready = false; + auto result = device.waitIdle(); + VERIFY(result == vk::Result::eSuccess); - // Second, re-perform the prepare() function, which will re-create the - // swapchain. - prepare(); + device.destroyImageView(depth.view); + device.destroyImage(depth.image); + device.freeMemory(depth.mem); + depth = {}; + + for (auto &swapchain_resource : swapchain_resources) { + device.destroyFramebuffer(swapchain_resource.framebuffer); + device.destroyImageView(swapchain_resource.view); + device.destroySemaphore(swapchain_resource.draw_complete_semaphore); + if (separate_present_queue) { + device.destroySemaphore(swapchain_resource.image_ownership_semaphore); + } + } + swapchain_resources.clear(); + } + // Second, recreate the swapchain, depth buffer, and framebuffers. + prepare_swapchain(); } void Demo::set_image_layout(vk::Image image, vk::ImageAspectFlags aspectMask, vk::ImageLayout oldLayout, vk::ImageLayout newLayout, @@ -2991,7 +3044,7 @@ .setSubresourceRange(vk::ImageSubresourceRange(aspectMask, 0, 1, 0, 1))); } -void Demo::update_data_buffer() { +void Demo::update_data_buffer(void *uniform_memory_ptr) { mat4x4 VP; mat4x4_mul(VP, projection_matrix, view_matrix); @@ -3004,7 +3057,7 @@ mat4x4 MVP; mat4x4_mul(MVP, VP, model_matrix); - memcpy(swapchain_image_resources[current_buffer].uniform_memory_ptr, (const void *)&MVP[0][0], sizeof(MVP)); + memcpy(uniform_memory_ptr, (const void *)&MVP[0][0], sizeof(MVP)); } /* Convert ppm image data from header file into RGBA texture image */ @@ -3020,19 +3073,16 @@ if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "P6\n", 3)) { return false; } - while (strncmp(cPtr++, "\n", 1)) - ; + while (strncmp(cPtr++, "\n", 1)); sscanf(cPtr, "%u %u", &width, &height); if (rgba_data == nullptr) { return true; } - while (strncmp(cPtr++, "\n", 1)) - ; + while (strncmp(cPtr++, "\n", 1)); if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "255\n", 4)) { return false; } - while (strncmp(cPtr++, "\n", 1)) - ; + while (strncmp(cPtr++, "\n", 1)); for (uint32_t y = 0; y < height; y++) { uint8_t *rowPtr = rgba_data; for (uint32_t x = 0; x < width; x++) { @@ -3083,20 +3133,24 @@ } #if defined(VK_USE_PLATFORM_WIN32_KHR) -void Demo::run() { - if (!prepared) { +template <> +void Demo::run<WsiPlatform::win32>() { + if (!initialized || !swapchain_ready) { return; } draw(); - curFrame++; + if (!is_minimized) { + curFrame++; + } if (frameCount != UINT32_MAX && curFrame == frameCount) { PostQuitMessage(validation_error); } } -void Demo::create_window() { +template <> +void Demo::create_window<WsiPlatform::win32>() { WNDCLASSEX win_class; // Initialize the window class structure: @@ -3152,7 +3206,8 @@ #endif #if defined(VK_USE_PLATFORM_XLIB_KHR) -void Demo::create_xlib_window() { +template <> +void Demo::create_window<WsiPlatform::xlib>() { const char *display_envar = getenv("DISPLAY"); if (display_envar == nullptr || display_envar[0] == '\0') { printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n"); @@ -3185,6 +3240,7 @@ XMapWindow(xlib_display, xlib_window); XFlush(xlib_display); xlib_wm_delete_window = XInternAtom(xlib_display, "WM_DELETE_WINDOW", False); + XSetWMProtocols(xlib_display, xlib_window, &xlib_wm_delete_window, 1); } void Demo::handle_xlib_event(const XEvent *event) { @@ -3222,7 +3278,8 @@ } } -void Demo::run_xlib() { +template <> +void Demo::run<WsiPlatform::xlib>() { while (!quit) { XEvent event; @@ -3234,12 +3291,15 @@ XNextEvent(xlib_display, &event); handle_xlib_event(&event); } + if (initialized && swapchain_ready) { + draw(); + if (!is_minimized) { + curFrame++; + } - draw(); - curFrame++; - - if (frameCount != UINT32_MAX && curFrame == frameCount) { - quit = true; + if (frameCount != UINT32_MAX && curFrame == frameCount) { + quit = true; + } } } } @@ -3288,7 +3348,8 @@ } } -void Demo::run_xcb() { +template <> +void Demo::run<WsiPlatform::xcb>() { xcb_flush(connection); while (!quit) { @@ -3304,16 +3365,20 @@ free(event); event = xcb_poll_for_event(connection); } - - draw(); - curFrame++; - if (frameCount != UINT32_MAX && curFrame == frameCount) { - quit = true; + if (initialized && swapchain_ready) { + draw(); + if (!is_minimized) { + curFrame++; + } + if (frameCount != UINT32_MAX && curFrame == frameCount) { + quit = true; + } } } } -void Demo::create_xcb_window() { +template <> +void Demo::create_window<WsiPlatform::xcb>() { uint32_t value_mask, value_list[32]; xcb_window = xcb_generate_id(connection); @@ -3347,16 +3412,21 @@ #endif #if defined(VK_USE_PLATFORM_WAYLAND_KHR) -void Demo::run_wayland() { +template <> +void Demo::run<WsiPlatform::wayland>() { while (!quit) { if (pause) { wl_display_dispatch(wayland_display); } else { wl_display_dispatch_pending(wayland_display); - draw(); - curFrame++; - if (frameCount != UINT32_MAX && curFrame == frameCount) { - quit = true; + if (initialized && swapchain_ready) { + draw(); + if (!is_minimized) { + curFrame++; + } + if (frameCount != UINT32_MAX && curFrame == frameCount) { + quit = true; + } } } } @@ -3365,10 +3435,14 @@ static void handle_surface_configure(void *data, xdg_surface *xdg_surface, uint32_t serial) { Demo &demo = *static_cast<Demo *>(data); xdg_surface_ack_configure(xdg_surface, serial); - if (demo.xdg_surface_has_been_configured) { - demo.resize(); - } demo.xdg_surface_has_been_configured = true; + if (demo.pending_width > 0) { + demo.width = demo.pending_width; + } + if (demo.pending_height > 0) { + demo.height = demo.pending_height; + } + demo.resize(); } static const xdg_surface_listener surface_listener = {handle_surface_configure}; @@ -3379,10 +3453,10 @@ /* zero values imply the program may choose its own size, so in that case * stay with the existing value (which on startup is the default) */ if (width > 0) { - demo.width = static_cast<uint32_t>(width); + demo.pending_width = static_cast<uint32_t>(width); } if (height > 0) { - demo.height = static_cast<uint32_t>(height); + demo.pending_height = static_cast<uint32_t>(height); } // This will be followed by a surface configure } @@ -3394,7 +3468,8 @@ static const xdg_toplevel_listener toplevel_listener = {handle_toplevel_configure, handle_toplevel_close}; -void Demo::create_wayland_window() { +template <> +void Demo::create_window<WsiPlatform::wayland>() { if (!wm_base) { printf("Compositor did not provide the standard protocol xdg-wm-base\n"); fflush(stdout); @@ -3454,7 +3529,8 @@ } } -void Demo::run_directfb() { +template <> +void Demo::run<WsiPlatform::directfb>() { while (!quit) { DFBInputEvent event; @@ -3463,17 +3539,21 @@ if (!event_buffer->GetEvent(event_buffer, DFB_EVENT(&event))) handle_directfb_event(&event); } else { if (!event_buffer->GetEvent(event_buffer, DFB_EVENT(&event))) handle_directfb_event(&event); - - draw(); - curFrame++; - if (frameCount != UINT32_MAX && curFrame == frameCount) { - quit = true; + if (initialized && swapchain_ready) { + draw(); + if (!is_minimized) { + curFrame++; + } + if (frameCount != UINT32_MAX && curFrame == frameCount) { + quit = true; + } } } } } -void Demo::create_directfb_window() { +template <> +void Demo::create_window<WsiPlatform::directfb>() { DFBResult ret; ret = DirectFBInit(nullptr, nullptr); @@ -3511,9 +3591,15 @@ } #endif #if defined(VK_USE_PLATFORM_METAL_EXT) -void Demo::run() { +template <> +void Demo::run<WsiPlatform::metal>() { + if (!initialized || !swapchain_ready) { + return; + } draw(); - curFrame++; + if (!is_minimized) { + curFrame++; + } if (frameCount != UINT32_MAX && curFrame == frameCount) { quit = true; } @@ -3616,7 +3702,8 @@ return inst.createDisplayPlaneSurfaceKHR(&createInfo, nullptr, &surface); } -void Demo::run_display() { +template <> +void Demo::run<WsiPlatform::display>() { while (!quit) { draw(); curFrame++; @@ -3631,7 +3718,8 @@ #if defined(VK_USE_PLATFORM_SCREEN_QNX) #include <sys/keycodes.h> -void Demo::run() { +template <> +void Demo::run<WsiPlatform::qnx>() { int size[2] = {0, 0}; screen_window_t win; int val; @@ -3722,11 +3810,13 @@ } } - if (pause) { + if (pause || !initialized || !swapchain_ready) { } else { - update_data_buffer(); + update_data_buffer(submission_resources[current_submission_index].uniform_memory_ptr); draw(); - curFrame++; + if (!is_minimized) { + curFrame++; + } if (frameCount != UINT32_MAX && curFrame == frameCount) { quit = true; } @@ -3734,7 +3824,8 @@ } } -void Demo::create_window() { +template <> +void Demo::create_window<WsiPlatform::qnx>() { const char *idstr = APP_SHORT_NAME; int size[2]; int usage = SCREEN_USAGE_VULKAN; @@ -3811,13 +3902,19 @@ } } -void Demo::create_flatland_view() { +template <> +void Demo::create_window<WsiPlatform::fuchsia_display>() { + // Nothing to do +} + +template <> +void Demo::create_window<WsiPlatform::fuchsia_scenic>() { if (flatland_view) return; zx::result<fidl::ClientEnd<fuchsia_io::Directory> > incoming_result = component::OpenServiceRoot(); if (incoming_result.is_error()) { printf("Failed to open incoming directory: %s\n", incoming_result.status_string()); - ERR_EXIT("Failed to open incoming directory", "create_flatland_view failure"); + ERR_EXIT("Failed to open incoming directory", "create_window<WsiPlatform::fuchsia_scenic> failure"); } incoming = std::move(incoming_result).value(); @@ -3827,14 +3924,14 @@ auto resize_callback = [this](uint32_t width, uint32_t height) { this->width = width; this->height = height; - if (prepared) { + if (initialized) { resize(); } }; flatland_view = FlatlandView::Create(incoming.borrow(), std::move(*args.view_creation_token()), resize_callback, loop.dispatcher()); - if (!flatland_view) ERR_EXIT("Failed to created FlatlandView", "create_flatland_view failure"); + if (!flatland_view) ERR_EXIT("Failed to created FlatlandView", "create_window<WsiPlatform::fuchsia_scenic> failure"); view_creation_token = flatland_view->TakeChildViewCreationToken(); }; @@ -3847,13 +3944,13 @@ }); if (add_protocol_result.is_error()) { printf("Failed to add protocol to outgoing directory: %s\n", add_protocol_result.status_string()); - ERR_EXIT("Failed to add protocol to outgoing directory", "create_flatland_view failure"); + ERR_EXIT("Failed to add protocol to outgoing directory", "create_window<WsiPlatform::fuchsia_scenic> failure"); } zx::result<> serve_result = outgoing->ServeFromStartupInfo(); if (serve_result.is_error()) { printf("Failed to serve outgoing directory: %s\n", serve_result.status_string()); - ERR_EXIT("Failed to serve outgoing directory", "create_flatland_view failure"); + ERR_EXIT("Failed to serve outgoing directory", "create_window<WsiPlatform::fuchsia_scenic> failure"); } zx_status_t loop_status = ZX_OK; @@ -3863,8 +3960,8 @@ loop_status = loop.RunUntilIdle(); } } - -void Demo::run() { +template <> +void Demo::run<WsiPlatform::fuchsia_display>() { uint32_t num_frames = 60; uint32_t elapsed_frames = 0; static const float kMsPerSec = 1000; @@ -3892,16 +3989,27 @@ num_frames = static_cast<uint32_t>(fps); elapsed_frames = 0; } + if (initialized && swapchain_ready) { + draw(); - draw(); + if (!is_minimized) { + curFrame++; + } + elapsed_frames++; - curFrame++; - elapsed_frames++; - - if (frameCount != UINT32_MAX && curFrame == frameCount) quit = true; + if (frameCount != UINT32_MAX && curFrame == frameCount) { + quit = true; + } + } } } +template <> +void Demo::run<WsiPlatform::fuchsia_scenic>() { + // Uses the same run function,as fuchsia_display + run<WsiPlatform::fuchsia_display>(); +} + #endif #if _WIN32 @@ -3918,7 +4026,7 @@ break; case WM_PAINT: if (!demo.in_callback) { - demo.run(); + demo.run<WsiPlatform::win32>(); } break; case WM_GETMINMAXINFO: // set window's minimum size @@ -4013,7 +4121,7 @@ demo.connection = hInstance; demo.name = "Vulkan Cube"; - demo.create_window(); + demo.create_window<WsiPlatform::win32>(); demo.create_surface(); demo.select_physical_device(); demo.init_vk_swapchain(); @@ -4050,7 +4158,38 @@ return static_cast<int>(msg.wParam); } -#elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__QNX__) || defined(__Fuchsia__) || defined(__GNU__) +#elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__QNX__) || defined(__GNU__) || \ + defined(__Fuchsia__) + +template <WsiPlatform WSI_PLATFORM> +void Demo::execute() { + create_window<WSI_PLATFORM>(); + + create_surface(); + + select_physical_device(); + + init_vk_swapchain(); + + prepare(); + + run<WSI_PLATFORM>(); +} + +#if defined(VK_USE_PLATFORM_DISPLAY_KHR) +template <> +void Demo::execute<WsiPlatform::display>() { + select_physical_device(); + + create_surface(); + + init_vk_swapchain(); + + prepare(); + + run<WsiPlatform::display>(); +} +#endif int main(int argc, char **argv) { Demo demo; @@ -4067,94 +4206,40 @@ break; #if defined(VK_USE_PLATFORM_XCB_KHR) case (WsiPlatform::xcb): - demo.create_xcb_window(); + demo.execute<WsiPlatform::xcb>(); break; #endif #if defined(VK_USE_PLATFORM_XLIB_KHR) case (WsiPlatform::xlib): - demo.create_xlib_window(); + demo.execute<WsiPlatform::xlib>(); break; #endif #if defined(VK_USE_PLATFORM_WAYLAND_KHR) case (WsiPlatform::wayland): - demo.create_wayland_window(); + demo.execute<WsiPlatform::wayland>(); break; #endif #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) case (WsiPlatform::directfb): - demo.create_directfb_window(); - break; -#endif -#if defined(VK_USE_PLATFORM_SCREEN_QNX) - case (WsiPlatform::qnx): - demo.create_window(); + demo.execute<WsiPlatform::directfb>(); break; #endif #if defined(VK_USE_PLATFORM_DISPLAY_KHR) case (WsiPlatform::display): - // nothing to do here - break; -#endif -#if defined(VK_USE_PLATFORM_FUCHSIA) - case (WsiPlatform::fuchsia_display): - // nothing to do here - break; - case (WsiPlatform::fuchsia_scenic): - demo.create_flatland_view(); - break; -#endif - } - - demo.create_surface(); - - demo.select_physical_device(); - - demo.init_vk_swapchain(); - - demo.prepare(); - - switch (demo.wsi_platform) { - default: - case (WsiPlatform::auto_): - fprintf(stderr, - "WSI platform should have already been set, indicating a bug. Please set a WSI platform manually with " - "--wsi\n"); - exit(1); - break; -#if defined(VK_USE_PLATFORM_XCB_KHR) - case (WsiPlatform::xcb): - demo.run_xcb(); - break; -#endif -#if defined(VK_USE_PLATFORM_XLIB_KHR) - case (WsiPlatform::xlib): - demo.run_xlib(); - break; -#endif -#if defined(VK_USE_PLATFORM_WAYLAND_KHR) - case (WsiPlatform::wayland): - demo.run_wayland(); - break; -#endif -#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) - case (WsiPlatform::directfb): - demo.run_directfb(); - break; -#endif -#if defined(VK_USE_PLATFORM_DISPLAY_KHR) - case (WsiPlatform::display): - demo.run_display(); + demo.execute<WsiPlatform::display>(); break; #endif #if defined(VK_USE_PLATFORM_SCREEN_QNX) case (WsiPlatform::qnx): - demo.run(); + demo.execute<WsiPlatform::qnx>(); break; #endif #if defined(VK_USE_PLATFORM_FUCHSIA) case (WsiPlatform::fuchsia_display): + demo.execute<WsiPlatform::fuchsia_display>(); + break; case (WsiPlatform::fuchsia_scenic): - demo.run(); + demo.execute<WsiPlatform::fuchsia_scenic>(); break; #endif }
diff --git a/cube/cube.frag b/cube/cube.frag index 5bf6507..c68b985 100644 --- a/cube/cube.frag +++ b/cube/cube.frag
@@ -29,10 +29,26 @@ const vec3 lightDir= vec3(0.424, 0.566, 0.707); +float linearToSrgb(float linear) { + if (linear <= 0.0031308) { + return linear * 12.92; + } else { + return (1.055 * pow(linear, 1.0/2.4)) - 0.055; + } +} + +vec3 linearToSrgb(vec3 linear) { + return vec3(linearToSrgb(linear.r), linearToSrgb(linear.g), linearToSrgb(linear.b)); +} + +vec4 linearToSrgb(vec4 linear) { + return vec4(linearToSrgb(linear.rgb), linear.a); +} + void main() { vec3 dX = dFdx(frag_pos); vec3 dY = dFdy(frag_pos); vec3 normal = normalize(cross(dX,dY)); float light = max(0.0, dot(lightDir, normal)); - uFragColor = light * texture(tex, texcoord.xy); + uFragColor = linearToSrgb(light * texture(tex, texcoord.xy)); }
diff --git a/cube/cube.frag.inc b/cube/cube.frag.inc index 98ff521..539636e 100644 --- a/cube/cube.frag.inc +++ b/cube/cube.frag.inc
@@ -1,41 +1,84 @@ - // 7.9.2888 - 0x07230203,0x00010000,0x00080007,0x00000030,0x00000000,0x00020011,0x00000001,0x0006000b, + // 1115.1.0 + 0x07230203,0x00010000,0x0008000b,0x00000073,0x00000000,0x00020011,0x00000001,0x0006000b, 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, - 0x0008000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000000b,0x00000022,0x0000002a, + 0x0008000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000004e,0x00000063,0x0000006b, 0x00030010,0x00000004,0x00000007,0x00030003,0x00000002,0x00000190,0x00090004,0x415f4c47, 0x735f4252,0x72617065,0x5f657461,0x64616873,0x6f5f7265,0x63656a62,0x00007374,0x00090004, 0x415f4c47,0x735f4252,0x69646168,0x6c5f676e,0x75676e61,0x5f656761,0x70303234,0x006b6361, - 0x00040005,0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000009,0x00005864,0x00050005, - 0x0000000b,0x67617266,0x736f705f,0x00000000,0x00030005,0x0000000e,0x00005964,0x00040005, - 0x00000011,0x6d726f6e,0x00006c61,0x00040005,0x00000017,0x6867696c,0x00000074,0x00050005, - 0x00000022,0x61724675,0x6c6f4367,0x0000726f,0x00030005,0x00000027,0x00786574,0x00050005, - 0x0000002a,0x63786574,0x64726f6f,0x00000000,0x00040047,0x0000000b,0x0000001e,0x00000001, - 0x00040047,0x00000022,0x0000001e,0x00000000,0x00040047,0x00000027,0x00000022,0x00000000, - 0x00040047,0x00000027,0x00000021,0x00000001,0x00040047,0x0000002a,0x0000001e,0x00000000, - 0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020, - 0x00040017,0x00000007,0x00000006,0x00000003,0x00040020,0x00000008,0x00000007,0x00000007, - 0x00040020,0x0000000a,0x00000001,0x00000007,0x0004003b,0x0000000a,0x0000000b,0x00000001, - 0x00040020,0x00000016,0x00000007,0x00000006,0x0004002b,0x00000006,0x00000018,0x00000000, - 0x0004002b,0x00000006,0x00000019,0x3ed91687,0x0004002b,0x00000006,0x0000001a,0x3f10e560, - 0x0004002b,0x00000006,0x0000001b,0x3f34fdf4,0x0006002c,0x00000007,0x0000001c,0x00000019, - 0x0000001a,0x0000001b,0x00040017,0x00000020,0x00000006,0x00000004,0x00040020,0x00000021, - 0x00000003,0x00000020,0x0004003b,0x00000021,0x00000022,0x00000003,0x00090019,0x00000024, - 0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x0003001b, - 0x00000025,0x00000024,0x00040020,0x00000026,0x00000000,0x00000025,0x0004003b,0x00000026, - 0x00000027,0x00000000,0x00040020,0x00000029,0x00000001,0x00000020,0x0004003b,0x00000029, - 0x0000002a,0x00000001,0x00040017,0x0000002b,0x00000006,0x00000002,0x00050036,0x00000002, - 0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000008,0x00000009, - 0x00000007,0x0004003b,0x00000008,0x0000000e,0x00000007,0x0004003b,0x00000008,0x00000011, - 0x00000007,0x0004003b,0x00000016,0x00000017,0x00000007,0x0004003d,0x00000007,0x0000000c, - 0x0000000b,0x000400cf,0x00000007,0x0000000d,0x0000000c,0x0003003e,0x00000009,0x0000000d, - 0x0004003d,0x00000007,0x0000000f,0x0000000b,0x000400d0,0x00000007,0x00000010,0x0000000f, - 0x0003003e,0x0000000e,0x00000010,0x0004003d,0x00000007,0x00000012,0x00000009,0x0004003d, - 0x00000007,0x00000013,0x0000000e,0x0007000c,0x00000007,0x00000014,0x00000001,0x00000044, - 0x00000012,0x00000013,0x0006000c,0x00000007,0x00000015,0x00000001,0x00000045,0x00000014, - 0x0003003e,0x00000011,0x00000015,0x0004003d,0x00000007,0x0000001d,0x00000011,0x00050094, - 0x00000006,0x0000001e,0x0000001c,0x0000001d,0x0007000c,0x00000006,0x0000001f,0x00000001, - 0x00000028,0x00000018,0x0000001e,0x0003003e,0x00000017,0x0000001f,0x0004003d,0x00000006, - 0x00000023,0x00000017,0x0004003d,0x00000025,0x00000028,0x00000027,0x0004003d,0x00000020, - 0x0000002c,0x0000002a,0x0007004f,0x0000002b,0x0000002d,0x0000002c,0x0000002c,0x00000000, - 0x00000001,0x00050057,0x00000020,0x0000002e,0x00000028,0x0000002d,0x0005008e,0x00000020, - 0x0000002f,0x0000002e,0x00000023,0x0003003e,0x00000022,0x0000002f,0x000100fd,0x00010038 + 0x00040005,0x00000004,0x6e69616d,0x00000000,0x00070005,0x0000000a,0x656e696c,0x6f547261, + 0x62677253,0x3b316628,0x00000000,0x00040005,0x00000009,0x656e696c,0x00007261,0x00070005, + 0x00000010,0x656e696c,0x6f547261,0x62677253,0x33667628,0x0000003b,0x00040005,0x0000000f, + 0x656e696c,0x00007261,0x00070005,0x00000016,0x656e696c,0x6f547261,0x62677253,0x34667628, + 0x0000003b,0x00040005,0x00000015,0x656e696c,0x00007261,0x00040005,0x0000002c,0x61726170, + 0x0000006d,0x00040005,0x00000032,0x61726170,0x0000006d,0x00040005,0x00000037,0x61726170, + 0x0000006d,0x00040005,0x0000003f,0x61726170,0x0000006d,0x00030005,0x0000004c,0x00005864, + 0x00050005,0x0000004e,0x67617266,0x736f705f,0x00000000,0x00030005,0x00000051,0x00005964, + 0x00040005,0x00000054,0x6d726f6e,0x00006c61,0x00040005,0x00000059,0x6867696c,0x00000074, + 0x00050005,0x00000063,0x61724675,0x6c6f4367,0x0000726f,0x00030005,0x00000068,0x00786574, + 0x00050005,0x0000006b,0x63786574,0x64726f6f,0x00000000,0x00040005,0x00000071,0x61726170, + 0x0000006d,0x00040047,0x0000004e,0x0000001e,0x00000001,0x00040047,0x00000063,0x0000001e, + 0x00000000,0x00040047,0x00000068,0x00000021,0x00000001,0x00040047,0x00000068,0x00000022, + 0x00000000,0x00040047,0x0000006b,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021, + 0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040020,0x00000007,0x00000007, + 0x00000006,0x00040021,0x00000008,0x00000006,0x00000007,0x00040017,0x0000000c,0x00000006, + 0x00000003,0x00040020,0x0000000d,0x00000007,0x0000000c,0x00040021,0x0000000e,0x0000000c, + 0x0000000d,0x00040017,0x00000012,0x00000006,0x00000004,0x00040020,0x00000013,0x00000007, + 0x00000012,0x00040021,0x00000014,0x00000012,0x00000013,0x0004002b,0x00000006,0x00000019, + 0x3b4d2e1c,0x00020014,0x0000001a,0x0004002b,0x00000006,0x0000001f,0x414eb852,0x0004002b, + 0x00000006,0x00000023,0x3f870a3d,0x0004002b,0x00000006,0x00000025,0x3ed55555,0x0004002b, + 0x00000006,0x00000028,0x3d6147ae,0x00040015,0x0000002d,0x00000020,0x00000000,0x0004002b, + 0x0000002d,0x0000002e,0x00000000,0x0004002b,0x0000002d,0x00000033,0x00000001,0x0004002b, + 0x0000002d,0x00000038,0x00000002,0x0004002b,0x0000002d,0x00000043,0x00000003,0x00040020, + 0x0000004d,0x00000001,0x0000000c,0x0004003b,0x0000004d,0x0000004e,0x00000001,0x0004002b, + 0x00000006,0x0000005a,0x00000000,0x0004002b,0x00000006,0x0000005b,0x3ed91687,0x0004002b, + 0x00000006,0x0000005c,0x3f10e560,0x0004002b,0x00000006,0x0000005d,0x3f34fdf4,0x0006002c, + 0x0000000c,0x0000005e,0x0000005b,0x0000005c,0x0000005d,0x00040020,0x00000062,0x00000003, + 0x00000012,0x0004003b,0x00000062,0x00000063,0x00000003,0x00090019,0x00000065,0x00000006, + 0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x0003001b,0x00000066, + 0x00000065,0x00040020,0x00000067,0x00000000,0x00000066,0x0004003b,0x00000067,0x00000068, + 0x00000000,0x00040020,0x0000006a,0x00000001,0x00000012,0x0004003b,0x0000006a,0x0000006b, + 0x00000001,0x00040017,0x0000006c,0x00000006,0x00000002,0x00050036,0x00000002,0x00000004, + 0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x0000000d,0x0000004c,0x00000007, + 0x0004003b,0x0000000d,0x00000051,0x00000007,0x0004003b,0x0000000d,0x00000054,0x00000007, + 0x0004003b,0x00000007,0x00000059,0x00000007,0x0004003b,0x00000013,0x00000071,0x00000007, + 0x0004003d,0x0000000c,0x0000004f,0x0000004e,0x000400cf,0x0000000c,0x00000050,0x0000004f, + 0x0003003e,0x0000004c,0x00000050,0x0004003d,0x0000000c,0x00000052,0x0000004e,0x000400d0, + 0x0000000c,0x00000053,0x00000052,0x0003003e,0x00000051,0x00000053,0x0004003d,0x0000000c, + 0x00000055,0x0000004c,0x0004003d,0x0000000c,0x00000056,0x00000051,0x0007000c,0x0000000c, + 0x00000057,0x00000001,0x00000044,0x00000055,0x00000056,0x0006000c,0x0000000c,0x00000058, + 0x00000001,0x00000045,0x00000057,0x0003003e,0x00000054,0x00000058,0x0004003d,0x0000000c, + 0x0000005f,0x00000054,0x00050094,0x00000006,0x00000060,0x0000005e,0x0000005f,0x0007000c, + 0x00000006,0x00000061,0x00000001,0x00000028,0x0000005a,0x00000060,0x0003003e,0x00000059, + 0x00000061,0x0004003d,0x00000006,0x00000064,0x00000059,0x0004003d,0x00000066,0x00000069, + 0x00000068,0x0004003d,0x00000012,0x0000006d,0x0000006b,0x0007004f,0x0000006c,0x0000006e, + 0x0000006d,0x0000006d,0x00000000,0x00000001,0x00050057,0x00000012,0x0000006f,0x00000069, + 0x0000006e,0x0005008e,0x00000012,0x00000070,0x0000006f,0x00000064,0x0003003e,0x00000071, + 0x00000070,0x00050039,0x00000012,0x00000072,0x00000016,0x00000071,0x0003003e,0x00000063, + 0x00000072,0x000100fd,0x00010038,0x00050036,0x00000006,0x0000000a,0x00000000,0x00000008, + 0x00030037,0x00000007,0x00000009,0x000200f8,0x0000000b,0x0004003d,0x00000006,0x00000018, + 0x00000009,0x000500bc,0x0000001a,0x0000001b,0x00000018,0x00000019,0x000300f7,0x0000001d, + 0x00000000,0x000400fa,0x0000001b,0x0000001c,0x00000022,0x000200f8,0x0000001c,0x0004003d, + 0x00000006,0x0000001e,0x00000009,0x00050085,0x00000006,0x00000020,0x0000001e,0x0000001f, + 0x000200fe,0x00000020,0x000200f8,0x00000022,0x0004003d,0x00000006,0x00000024,0x00000009, + 0x0007000c,0x00000006,0x00000026,0x00000001,0x0000001a,0x00000024,0x00000025,0x00050085, + 0x00000006,0x00000027,0x00000023,0x00000026,0x00050083,0x00000006,0x00000029,0x00000027, + 0x00000028,0x000200fe,0x00000029,0x000200f8,0x0000001d,0x000100ff,0x00010038,0x00050036, + 0x0000000c,0x00000010,0x00000000,0x0000000e,0x00030037,0x0000000d,0x0000000f,0x000200f8, + 0x00000011,0x0004003b,0x00000007,0x0000002c,0x00000007,0x0004003b,0x00000007,0x00000032, + 0x00000007,0x0004003b,0x00000007,0x00000037,0x00000007,0x00050041,0x00000007,0x0000002f, + 0x0000000f,0x0000002e,0x0004003d,0x00000006,0x00000030,0x0000002f,0x0003003e,0x0000002c, + 0x00000030,0x00050039,0x00000006,0x00000031,0x0000000a,0x0000002c,0x00050041,0x00000007, + 0x00000034,0x0000000f,0x00000033,0x0004003d,0x00000006,0x00000035,0x00000034,0x0003003e, + 0x00000032,0x00000035,0x00050039,0x00000006,0x00000036,0x0000000a,0x00000032,0x00050041, + 0x00000007,0x00000039,0x0000000f,0x00000038,0x0004003d,0x00000006,0x0000003a,0x00000039, + 0x0003003e,0x00000037,0x0000003a,0x00050039,0x00000006,0x0000003b,0x0000000a,0x00000037, + 0x00060050,0x0000000c,0x0000003c,0x00000031,0x00000036,0x0000003b,0x000200fe,0x0000003c, + 0x00010038,0x00050036,0x00000012,0x00000016,0x00000000,0x00000014,0x00030037,0x00000013, + 0x00000015,0x000200f8,0x00000017,0x0004003b,0x0000000d,0x0000003f,0x00000007,0x0004003d, + 0x00000012,0x00000040,0x00000015,0x0008004f,0x0000000c,0x00000041,0x00000040,0x00000040, + 0x00000000,0x00000001,0x00000002,0x0003003e,0x0000003f,0x00000041,0x00050039,0x0000000c, + 0x00000042,0x00000010,0x0000003f,0x00050041,0x00000007,0x00000044,0x00000015,0x00000043, + 0x0004003d,0x00000006,0x00000045,0x00000044,0x00050051,0x00000006,0x00000046,0x00000042, + 0x00000000,0x00050051,0x00000006,0x00000047,0x00000042,0x00000001,0x00050051,0x00000006, + 0x00000048,0x00000042,0x00000002,0x00070050,0x00000012,0x00000049,0x00000046,0x00000047, + 0x00000048,0x00000045,0x000200fe,0x00000049,0x00010038
diff --git a/cube/cube.vert.inc b/cube/cube.vert.inc index 5d029c6..f5c3fef 100644 --- a/cube/cube.vert.inc +++ b/cube/cube.vert.inc
@@ -1,5 +1,5 @@ - // 7.9.2888 - 0x07230203,0x00010000,0x00080007,0x0000002f,0x00000000,0x00020011,0x00000001,0x0006000b, + // 1115.1.0 + 0x07230203,0x00010000,0x0008000b,0x0000002f,0x00000000,0x00020011,0x00000001,0x0006000b, 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, 0x0009000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x00000009,0x00000015,0x0000001e, 0x0000002b,0x00030003,0x00000002,0x00000190,0x00090004,0x415f4c47,0x735f4252,0x72617065, @@ -15,14 +15,14 @@ 0x00000002,0x435f6c67,0x4470696c,0x61747369,0x0065636e,0x00030005,0x0000001e,0x00000000, 0x00050005,0x0000002b,0x67617266,0x736f705f,0x00000000,0x00040047,0x00000009,0x0000001e, 0x00000000,0x00040047,0x0000000d,0x00000006,0x00000010,0x00040047,0x0000000e,0x00000006, - 0x00000010,0x00040048,0x0000000f,0x00000000,0x00000005,0x00050048,0x0000000f,0x00000000, - 0x00000023,0x00000000,0x00050048,0x0000000f,0x00000000,0x00000007,0x00000010,0x00050048, - 0x0000000f,0x00000001,0x00000023,0x00000040,0x00050048,0x0000000f,0x00000002,0x00000023, - 0x00000280,0x00030047,0x0000000f,0x00000002,0x00040047,0x00000011,0x00000022,0x00000000, - 0x00040047,0x00000011,0x00000021,0x00000000,0x00040047,0x00000015,0x0000000b,0x0000002a, - 0x00050048,0x0000001c,0x00000000,0x0000000b,0x00000000,0x00050048,0x0000001c,0x00000001, - 0x0000000b,0x00000001,0x00050048,0x0000001c,0x00000002,0x0000000b,0x00000003,0x00030047, - 0x0000001c,0x00000002,0x00040047,0x0000002b,0x0000001e,0x00000001,0x00020013,0x00000002, + 0x00000010,0x00030047,0x0000000f,0x00000002,0x00040048,0x0000000f,0x00000000,0x00000005, + 0x00050048,0x0000000f,0x00000000,0x00000007,0x00000010,0x00050048,0x0000000f,0x00000000, + 0x00000023,0x00000000,0x00050048,0x0000000f,0x00000001,0x00000023,0x00000040,0x00050048, + 0x0000000f,0x00000002,0x00000023,0x00000280,0x00040047,0x00000011,0x00000021,0x00000000, + 0x00040047,0x00000011,0x00000022,0x00000000,0x00040047,0x00000015,0x0000000b,0x0000002a, + 0x00030047,0x0000001c,0x00000002,0x00050048,0x0000001c,0x00000000,0x0000000b,0x00000000, + 0x00050048,0x0000001c,0x00000001,0x0000000b,0x00000001,0x00050048,0x0000001c,0x00000002, + 0x0000000b,0x00000003,0x00040047,0x0000002b,0x0000001e,0x00000001,0x00020013,0x00000002, 0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007, 0x00000006,0x00000004,0x00040020,0x00000008,0x00000003,0x00000007,0x0004003b,0x00000008, 0x00000009,0x00000003,0x00040018,0x0000000a,0x00000007,0x00000004,0x00040015,0x0000000b,
diff --git a/cube/cube_functions.h b/cube/cube_functions.h new file mode 100644 index 0000000..975f65f --- /dev/null +++ b/cube/cube_functions.h
@@ -0,0 +1,355 @@ +/* + * Copyright (c) 2025 The Khronos Group Inc. + * Copyright (c) 2025 Valve Corporation + * Copyright (c) 2025 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: Charles Giessen <charles@lunarg.com> + * + */ +#pragma once + +// Need to include relevant system headers to open the dynamic library +#if defined(_WIN32) +#include <windows.h> +#elif defined(__APPLE__) +#include <stdlib.h> +#include <dlfcn.h> +#else +#include <dlfcn.h> +#endif + +// We are providing storage for all functions, make sure the vulkan headers doesn't conflate with ours. +#if !defined(VK_NO_PROTOTYPES) +#define VK_NO_PROTOTYPES +#endif + +#include <vulkan/vulkan.h> + +void* vulkan_library; + +// Global Functions +PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; +PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; +PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; +PFN_vkCreateInstance vkCreateInstance; + +// Per-platform Instance functions +#if defined(VK_USE_PLATFORM_WIN32_KHR) +PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) +PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_XLIB_KHR) +PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_XCB_KHR) +PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_METAL_EXT) +PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; +#endif +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) +PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; +#endif +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX; +#endif + +// Instance functions +PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT; +PFN_vkCreateDevice vkCreateDevice; +PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT; +PFN_vkDestroyInstance vkDestroyInstance; +PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR; +PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; +PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; +PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR; +PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR; +PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR; +PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR; +PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR; +PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; +PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; +PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; +PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; +PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; +PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR; +PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR; +PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR; +PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR; +PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR; + +// While technically a device function, it needs to be loaded with get instance proc addr +PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr; + +// Device functions +PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR; +PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; +PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; +PFN_vkAllocateMemory vkAllocateMemory; +PFN_vkBeginCommandBuffer vkBeginCommandBuffer; +PFN_vkBindBufferMemory vkBindBufferMemory; +PFN_vkBindImageMemory vkBindImageMemory; +PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT; +PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; +PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; +PFN_vkCmdBindPipeline vkCmdBindPipeline; +PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; +PFN_vkCmdDraw vkCmdDraw; +PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT; +PFN_vkCmdEndRenderPass vkCmdEndRenderPass; +PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; +PFN_vkCmdSetScissor vkCmdSetScissor; +PFN_vkCmdSetViewport vkCmdSetViewport; +PFN_vkCreateBuffer vkCreateBuffer; +PFN_vkCreateCommandPool vkCreateCommandPool; +PFN_vkCreateDescriptorPool vkCreateDescriptorPool; +PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; +PFN_vkCreateFence vkCreateFence; +PFN_vkCreateFramebuffer vkCreateFramebuffer; +PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; +PFN_vkCreateImage vkCreateImage; +PFN_vkCreateImageView vkCreateImageView; +PFN_vkCreatePipelineCache vkCreatePipelineCache; +PFN_vkCreatePipelineLayout vkCreatePipelineLayout; +PFN_vkCreateRenderPass vkCreateRenderPass; +PFN_vkCreateSampler vkCreateSampler; +PFN_vkCreateSemaphore vkCreateSemaphore; +PFN_vkCreateShaderModule vkCreateShaderModule; +PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR; +PFN_vkDestroyBuffer vkDestroyBuffer; +PFN_vkDestroyCommandPool vkDestroyCommandPool; +PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; +PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; +PFN_vkDestroyDevice vkDestroyDevice; +PFN_vkDestroyFence vkDestroyFence; +PFN_vkDestroyFramebuffer vkDestroyFramebuffer; +PFN_vkDestroyImage vkDestroyImage; +PFN_vkDestroyImageView vkDestroyImageView; +PFN_vkDestroyPipeline vkDestroyPipeline; +PFN_vkDestroyPipelineCache vkDestroyPipelineCache; +PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; +PFN_vkDestroyRenderPass vkDestroyRenderPass; +PFN_vkDestroySampler vkDestroySampler; +PFN_vkDestroySemaphore vkDestroySemaphore; +PFN_vkDestroyShaderModule vkDestroyShaderModule; +PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; +PFN_vkDeviceWaitIdle vkDeviceWaitIdle; +PFN_vkEndCommandBuffer vkEndCommandBuffer; +PFN_vkFreeCommandBuffers vkFreeCommandBuffers; +PFN_vkFreeMemory vkFreeMemory; +PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; +PFN_vkGetDeviceQueue vkGetDeviceQueue; +PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; +PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; +PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE; +PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE; +PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; +PFN_vkMapMemory vkMapMemory; +PFN_vkQueuePresentKHR vkQueuePresentKHR; +PFN_vkQueueSubmit vkQueueSubmit; +PFN_vkResetCommandBuffer vkResetCommandBuffer; +PFN_vkResetFences vkResetFences; +PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT; +PFN_vkUnmapMemory vkUnmapMemory; +PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; +PFN_vkWaitForFences vkWaitForFences; + +#define LOAD_INSTANCE_FUNCTION(instance, function) function = (PFN_##function)vkGetInstanceProcAddr(instance, #function) +#define LOAD_DEVICE_FUNCTION(device, function) function = (PFN_##function)vkGetDeviceProcAddr(device, #function) + +static VkResult load_vulkan_library() { + vulkan_library = NULL; +#if defined(WIN32) + HMODULE library = LoadLibraryA("vulkan-1.dll"); + if (library == NULL) return VK_ERROR_INITIALIZATION_FAILED; + + vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)(void (*)(void))GetProcAddress(library, "vkGetInstanceProcAddr"); +#elif defined(__APPLE__) + void* library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) { + library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); + } + if (library == NULL && getenv("DYLD_FALLBACK_LIBRARY_PATH") == NULL) { + library = dlopen("/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) { + library = dlopen("/usr/local/lib/libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); + } + } + if (library == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr"); +#else // Assume everything else supports dlopen + void* library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr"); +#endif + if (vkGetInstanceProcAddr == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + vulkan_library = library; + LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceExtensionProperties); + LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceLayerProperties); + LOAD_INSTANCE_FUNCTION(NULL, vkCreateInstance); + + return VK_SUCCESS; +} + +static void unload_vulkan_library() { + if (vulkan_library != NULL) { +#if defined(WIN32) + FreeLibrary((HMODULE)vulkan_library); +#else + dlclose(vulkan_library); +#endif + vulkan_library = NULL; + } +} + +static void load_vulkan_instance_functions(VkInstance instance) { +#if defined(VK_USE_PLATFORM_WIN32_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateWin32SurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateWaylandSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateAndroidSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_XLIB_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateXlibSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_XCB_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateXcbSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_METAL_EXT) + LOAD_INSTANCE_FUNCTION(instance, vkCreateMetalSurfaceEXT); +#endif +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + LOAD_INSTANCE_FUNCTION(instance, vkCreateDirectFBSurfaceEXT); +#endif +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + LOAD_INSTANCE_FUNCTION(instance, vkCreateScreenSurfaceQNX); +#endif + LOAD_INSTANCE_FUNCTION(instance, vkCreateDebugUtilsMessengerEXT); + LOAD_INSTANCE_FUNCTION(instance, vkCreateDevice); + LOAD_INSTANCE_FUNCTION(instance, vkDestroyDebugUtilsMessengerEXT); + LOAD_INSTANCE_FUNCTION(instance, vkDestroyInstance); + LOAD_INSTANCE_FUNCTION(instance, vkDestroySurfaceKHR); + LOAD_INSTANCE_FUNCTION(instance, vkEnumerateDeviceExtensionProperties); + LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDevices); + LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayModePropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneCapabilitiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneSupportedDisplaysKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormatsKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfacePresentModesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceSupportKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetDeviceProcAddr); + LOAD_INSTANCE_FUNCTION(instance, vkCreateDisplayPlaneSurfaceKHR); +} +static void load_vulkan_device_functions(VkDevice device) { + LOAD_DEVICE_FUNCTION(device, vkAcquireNextImageKHR); + LOAD_DEVICE_FUNCTION(device, vkAllocateCommandBuffers); + LOAD_DEVICE_FUNCTION(device, vkAllocateDescriptorSets); + LOAD_DEVICE_FUNCTION(device, vkAllocateMemory); + LOAD_DEVICE_FUNCTION(device, vkBeginCommandBuffer); + LOAD_DEVICE_FUNCTION(device, vkBindBufferMemory); + LOAD_DEVICE_FUNCTION(device, vkBindImageMemory); + LOAD_DEVICE_FUNCTION(device, vkCmdBeginDebugUtilsLabelEXT); + LOAD_DEVICE_FUNCTION(device, vkCmdBeginRenderPass); + LOAD_DEVICE_FUNCTION(device, vkCmdBindDescriptorSets); + LOAD_DEVICE_FUNCTION(device, vkCmdBindPipeline); + LOAD_DEVICE_FUNCTION(device, vkCmdCopyBufferToImage); + LOAD_DEVICE_FUNCTION(device, vkCmdDraw); + LOAD_DEVICE_FUNCTION(device, vkCmdEndDebugUtilsLabelEXT); + LOAD_DEVICE_FUNCTION(device, vkCmdEndRenderPass); + LOAD_DEVICE_FUNCTION(device, vkCmdPipelineBarrier); + LOAD_DEVICE_FUNCTION(device, vkCmdSetScissor); + LOAD_DEVICE_FUNCTION(device, vkCmdSetViewport); + LOAD_DEVICE_FUNCTION(device, vkCreateBuffer); + LOAD_DEVICE_FUNCTION(device, vkCreateCommandPool); + LOAD_DEVICE_FUNCTION(device, vkCreateDescriptorPool); + LOAD_DEVICE_FUNCTION(device, vkCreateDescriptorSetLayout); + LOAD_DEVICE_FUNCTION(device, vkCreateFence); + LOAD_DEVICE_FUNCTION(device, vkCreateFramebuffer); + LOAD_DEVICE_FUNCTION(device, vkCreateGraphicsPipelines); + LOAD_DEVICE_FUNCTION(device, vkCreateImage); + LOAD_DEVICE_FUNCTION(device, vkCreateImageView); + LOAD_DEVICE_FUNCTION(device, vkCreatePipelineCache); + LOAD_DEVICE_FUNCTION(device, vkCreatePipelineLayout); + LOAD_DEVICE_FUNCTION(device, vkCreateRenderPass); + LOAD_DEVICE_FUNCTION(device, vkCreateSampler); + LOAD_DEVICE_FUNCTION(device, vkCreateSemaphore); + LOAD_DEVICE_FUNCTION(device, vkCreateShaderModule); + LOAD_DEVICE_FUNCTION(device, vkCreateSwapchainKHR); + LOAD_DEVICE_FUNCTION(device, vkDestroyBuffer); + LOAD_DEVICE_FUNCTION(device, vkDestroyCommandPool); + LOAD_DEVICE_FUNCTION(device, vkDestroyDescriptorPool); + LOAD_DEVICE_FUNCTION(device, vkDestroyDescriptorSetLayout); + LOAD_DEVICE_FUNCTION(device, vkDestroyDevice); + LOAD_DEVICE_FUNCTION(device, vkDestroyFence); + LOAD_DEVICE_FUNCTION(device, vkDestroyFramebuffer); + LOAD_DEVICE_FUNCTION(device, vkDestroyImage); + LOAD_DEVICE_FUNCTION(device, vkDestroyImageView); + LOAD_DEVICE_FUNCTION(device, vkDestroyPipeline); + LOAD_DEVICE_FUNCTION(device, vkDestroyPipelineCache); + LOAD_DEVICE_FUNCTION(device, vkDestroyPipelineLayout); + LOAD_DEVICE_FUNCTION(device, vkDestroyRenderPass); + LOAD_DEVICE_FUNCTION(device, vkDestroySampler); + LOAD_DEVICE_FUNCTION(device, vkDestroySemaphore); + LOAD_DEVICE_FUNCTION(device, vkDestroyShaderModule); + LOAD_DEVICE_FUNCTION(device, vkDestroySwapchainKHR); + LOAD_DEVICE_FUNCTION(device, vkDeviceWaitIdle); + LOAD_DEVICE_FUNCTION(device, vkEndCommandBuffer); + LOAD_DEVICE_FUNCTION(device, vkFreeCommandBuffers); + LOAD_DEVICE_FUNCTION(device, vkFreeMemory); + LOAD_DEVICE_FUNCTION(device, vkGetBufferMemoryRequirements); + LOAD_DEVICE_FUNCTION(device, vkGetDeviceProcAddr); + LOAD_DEVICE_FUNCTION(device, vkGetDeviceQueue); + LOAD_DEVICE_FUNCTION(device, vkGetImageMemoryRequirements); + LOAD_DEVICE_FUNCTION(device, vkGetImageSubresourceLayout); + LOAD_DEVICE_FUNCTION(device, vkGetPastPresentationTimingGOOGLE); + LOAD_DEVICE_FUNCTION(device, vkGetRefreshCycleDurationGOOGLE); + LOAD_DEVICE_FUNCTION(device, vkGetSwapchainImagesKHR); + LOAD_DEVICE_FUNCTION(device, vkMapMemory); + LOAD_DEVICE_FUNCTION(device, vkQueuePresentKHR); + LOAD_DEVICE_FUNCTION(device, vkQueueSubmit); + LOAD_DEVICE_FUNCTION(device, vkResetCommandBuffer); + LOAD_DEVICE_FUNCTION(device, vkResetFences); + LOAD_DEVICE_FUNCTION(device, vkSetDebugUtilsObjectNameEXT); + LOAD_DEVICE_FUNCTION(device, vkUnmapMemory); + LOAD_DEVICE_FUNCTION(device, vkUpdateDescriptorSets); + LOAD_DEVICE_FUNCTION(device, vkWaitForFences); +} + +#undef LOAD_INSTANCE_FUNCTION +#undef LOAD_DEVICE_FUNCTION
diff --git a/cube/fuchsia/flatland_view.cpp b/cube/fuchsia/flatland_view.cpp index f7bfdf9..cb25d41 100644 --- a/cube/fuchsia/flatland_view.cpp +++ b/cube/fuchsia/flatland_view.cpp
@@ -1,5 +1,16 @@ -// Copyright 2022 The Fuchsia Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. +// Copyright (c) 2025 The Fuchsia Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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 "flatland_view.h" @@ -14,11 +25,15 @@ #include <cinttypes> +namespace { + const char* const kTag = "FlatlandView"; const fuchsia_ui_composition::TransformId kRootTransform = {1}; const fuchsia_ui_composition::ContentId kViewport = {1}; +} // namespace + // static std::unique_ptr<FlatlandView> FlatlandView::Create(fidl::UnownedClientEnd<fuchsia_io::Directory> service_directory, fuchsia_ui_views::ViewCreationToken view_creation_token,
diff --git a/cube/fuchsia/flatland_view.h b/cube/fuchsia/flatland_view.h index 2869858..01a8c6f 100644 --- a/cube/fuchsia/flatland_view.h +++ b/cube/fuchsia/flatland_view.h
@@ -1,16 +1,31 @@ -// Copyright 2022 The Fuchsia Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. +// Copyright (c) 2025 The Fuchsia Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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 THIRD_PARTY_VULKAN_TOOLS_SRC_CUBE_FUCHSIA_FLATLAND_VIEW_H_ -#define THIRD_PARTY_VULKAN_TOOLS_SRC_CUBE_FUCHSIA_FLATLAND_VIEW_H_ +#ifndef FUCHSIA_FLATLAND_VIEW_H_ +#define FUCHSIA_FLATLAND_VIEW_H_ #include <fidl/fuchsia.io/cpp/fidl.h> #include <fidl/fuchsia.ui.app/cpp/fidl.h> #include <fidl/fuchsia.ui.composition/cpp/fidl.h> #include <fidl/fuchsia.ui.views/cpp/fidl.h> #include <lib/fit/function.h> +#include <lib/async/dispatcher.h> #include <lib/syslog/cpp/macros.h> +#include <cstdint> +#include <utility> + #include <memory> // This class provides a convenient wrapper around the scenic fidl apis needed to get a Flatland @@ -84,4 +99,4 @@ async_dispatcher_t* const dispatcher_; }; -#endif // THIRD_PARTY_VULKAN_TOOLS_SRC_CUBE_FUCHSIA_FLATLAND_VIEW_H_ +#endif // FUCHSIA_FLATLAND_VIEW_H_
diff --git a/cube/fuchsia/meta/vkcube-on-fb-protected.cml b/cube/fuchsia/meta/vkcube-on-fb-protected.cml index 1b52343..43d51a6 100644 --- a/cube/fuchsia/meta/vkcube-on-fb-protected.cml +++ b/cube/fuchsia/meta/vkcube-on-fb-protected.cml
@@ -1,6 +1,16 @@ -// Copyright 2022 The Fuchsia Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. +// Copyright (c) 2025 The Fuchsia Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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: [ "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain_fb.shard.cml",
diff --git a/cube/fuchsia/meta/vkcube-on-fb.cml b/cube/fuchsia/meta/vkcube-on-fb.cml index fba65e3..eaa78aa 100644 --- a/cube/fuchsia/meta/vkcube-on-fb.cml +++ b/cube/fuchsia/meta/vkcube-on-fb.cml
@@ -1,6 +1,16 @@ -// Copyright 2022 The Fuchsia Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. +// Copyright (c) 2025 The Fuchsia Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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: [ "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain_fb.shard.cml",
diff --git a/cube/fuchsia/meta/vkcube-on-scenic-protected.cml b/cube/fuchsia/meta/vkcube-on-scenic-protected.cml index d739b90..3138b60 100644 --- a/cube/fuchsia/meta/vkcube-on-scenic-protected.cml +++ b/cube/fuchsia/meta/vkcube-on-scenic-protected.cml
@@ -1,6 +1,16 @@ -// Copyright 2022 The Fuchsia Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. +// Copyright (c) 2025 The Fuchsia Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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: [ "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain.shard.cml" ], program: {
diff --git a/cube/fuchsia/meta/vkcube-on-scenic.cml b/cube/fuchsia/meta/vkcube-on-scenic.cml index 2b6ed0b..cf940b5 100644 --- a/cube/fuchsia/meta/vkcube-on-scenic.cml +++ b/cube/fuchsia/meta/vkcube-on-scenic.cml
@@ -1,6 +1,16 @@ -// Copyright 2022 The Fuchsia Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. +// Copyright (c) 2025 The Fuchsia Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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: [ "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain.shard.cml" ], program: {
diff --git a/cube/gettime.h b/cube/gettime.h index 5eae98f..0a697b4 100644 --- a/cube/gettime.h +++ b/cube/gettime.h
@@ -26,14 +26,10 @@ #include <windows.h> -#elif defined(__unix__) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__ANDROID__) || defined(__EPOC32__) || defined(__QNX__) +#elif defined(__unix__) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__ANDROID__) || defined(__EPOC32__) || defined(__QNX__) || defined(__APPLE__) #include <time.h> -#elif defined(__APPLE__) - -#include <sys/time.h> - #endif uint64_t getTimeInNanoseconds(void) { @@ -55,7 +51,7 @@ return count.QuadPart / (freq.QuadPart / ns_in_s); } -#elif defined(__unix__) || defined(__linux) || defined(__linux__) || defined(__ANDROID__) || defined(__QNX__) +#elif defined(__unix__) || defined(__linux) || defined(__linux__) || defined(__ANDROID__) || defined(__QNX__) || defined(__APPLE__) struct timespec currTime; clock_gettime(CLOCK_MONOTONIC, &currTime); return (uint64_t)currTime.tv_sec * ns_in_s + (uint64_t)currTime.tv_nsec; @@ -66,11 +62,6 @@ clock_gettime(CLOCK_REALTIME, &currTime); return (uint64_t)currTime.tv_sec * ns_in_s + (uint64_t)currTime.tv_nsec; -#elif defined(__APPLE__) - struct timeval currTime; - gettimeofday(&currTime, NULL); - return (uint64_t)currTime.tv_sec * ns_in_s + (uint64_t)currTime.tv_usec * ns_in_us; - #else #error getTimeInNanoseconds Not implemented for target OS #endif
diff --git a/cube/macOS/cube/CMakeLists.txt b/cube/macOS/cube/CMakeLists.txt index 3300d6b..d0721a8 100644 --- a/cube/macOS/cube/CMakeLists.txt +++ b/cube/macOS/cube/CMakeLists.txt
@@ -17,8 +17,10 @@ # VkCube Application Bundle -set(cube_RESOURCES ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json - ${CMAKE_CURRENT_LIST_DIR}/Resources/VulkanIcon.icns) +set(cube_RESOURCES ${CMAKE_CURRENT_LIST_DIR}/Resources/VulkanIcon.icns) +if(NOT APPLE_USE_SYSTEM_ICD) + list(APPEND cube_RESOURCES ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json) +endif() # Have Xcode handle the Storyboard if(XCODE) @@ -52,7 +54,9 @@ COMMENT "Compiling storyboard") endif() -add_dependencies(vkcube MoltenVK_icd-staging-json) +if(NOT APPLE_USE_SYSTEM_ICD) + add_dependencies(vkcube MoltenVK_icd-staging-json) +endif() # Include demo source code dir because the MacOS cube's Objective-C source includes the "original" cube application C source code. target_include_directories(vkcube PRIVATE ${CMAKE_CURRENT_LIST_DIR}) @@ -70,18 +74,20 @@ # directory basis. If all the files went into the top-level Resource directory, then we could simply set the RESOURCE property to a # list of all the resource files. set_source_files_properties(${cube_RESOURCES} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources") -set_source_files_properties("${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json" - PROPERTIES - MACOSX_PACKAGE_LOCATION - "Resources/vulkan/icd.d") +if(NOT APPLE_USE_SYSTEM_ICD) + set_source_files_properties("${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json" + PROPERTIES + MACOSX_PACKAGE_LOCATION + "Resources/vulkan/icd.d") -# Copy the MoltenVK lib into the bundle. -if(XCODE) - add_custom_command(TARGET vkcube POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" - ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/vkcube.app/Contents/Frameworks/libMoltenVK.dylib) -else() - add_custom_command(TARGET vkcube POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" - ${CMAKE_CURRENT_BINARY_DIR}/vkcube.app/Contents/Frameworks/libMoltenVK.dylib) + # Copy the MoltenVK lib into the bundle. + if(XCODE) + add_custom_command(TARGET vkcube POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" + ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/vkcube.app/Contents/Frameworks/libMoltenVK.dylib) + else() + add_custom_command(TARGET vkcube POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" + ${CMAKE_CURRENT_BINARY_DIR}/vkcube.app/Contents/Frameworks/libMoltenVK.dylib) + endif() endif()
diff --git a/cube/macOS/cube/Resources/Main.storyboard b/cube/macOS/cube/Resources/Main.storyboard index d21c149..edc6314 100644 --- a/cube/macOS/cube/Resources/Main.storyboard +++ b/cube/macOS/cube/Resources/Main.storyboard
@@ -11,9 +11,9 @@ <application id="hnw-xV-0zn" sceneMemberID="viewController"> <menu key="mainMenu" title="Main Menu" systemMenu="main" id="AYu-sK-qS6"> <items> - <menuItem title="MoltenVK Demo" id="1Xt-HY-uBw"> + <menuItem title="VkCube" id="1Xt-HY-uBw"> <modifierMask key="keyEquivalentModifierMask"/> - <menu key="submenu" title="MoltenVK Demo" systemMenu="apple" id="uQy-DD-JDr"> + <menu key="submenu" title="VkCube" systemMenu="apple" id="uQy-DD-JDr"> <items> <menuItem title="About Demo" id="5kV-Vb-QxS"> <modifierMask key="keyEquivalentModifierMask"/> @@ -77,7 +77,7 @@ <modifierMask key="keyEquivalentModifierMask"/> <menu key="submenu" title="Help" systemMenu="help" id="F2S-fz-NVQ"> <items> - <menuItem title="MoltenVK Demo Help" keyEquivalent="?" id="FKE-Sm-Kum"> + <menuItem title="VkCube Help" keyEquivalent="?" id="FKE-Sm-Kum"> <connections> <action selector="showHelp:" target="Ady-hI-5gd" id="y7X-2Q-9no"/> </connections> @@ -100,7 +100,7 @@ <scene sceneID="R2V-B0-nI4"> <objects> <windowController id="B8D-0N-5wS" sceneMemberID="viewController"> - <window key="window" title="MoltenVK Demo" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" showsToolbarButton="NO" visibleAtLaunch="NO" animationBehavior="default" id="IQv-IB-iLA"> + <window key="window" title="VkCube" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" showsToolbarButton="NO" visibleAtLaunch="NO" animationBehavior="default" id="IQv-IB-iLA"> <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES"/> <rect key="contentRect" x="1051" y="656" width="300" height="200"/> <rect key="screenRect" x="0.0" y="0.0" width="2560" height="1417"/>
diff --git a/cube/macOS/cubepp/CMakeLists.txt b/cube/macOS/cubepp/CMakeLists.txt index cf05165..6390db0 100644 --- a/cube/macOS/cubepp/CMakeLists.txt +++ b/cube/macOS/cubepp/CMakeLists.txt
@@ -17,8 +17,10 @@ # VkCube Application Bundle -set(cubepp_RESOURCES ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json - ${CMAKE_CURRENT_LIST_DIR}/Resources/VulkanIcon.icns) +set(cubepp_RESOURCES ${CMAKE_CURRENT_LIST_DIR}/Resources/VulkanIcon.icns) +if(NOT APPLE_USE_SYSTEM_ICD) + list(APPEND cubepp_RESOURCES ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json) +endif() # Have Xcode handle the Storyboard if(XCODE) @@ -52,7 +54,9 @@ COMMENT "Compiling storyboard") endif() -add_dependencies(vkcubepp MoltenVK_icd-staging-json) +if(NOT APPLE_USE_SYSTEM_ICD) + add_dependencies(vkcubepp MoltenVK_icd-staging-json) +endif() # Include demo source code dir because the MacOS vkcubepp's Objective-C source includes the "original" vkcubepp application C++ source # code. @@ -68,18 +72,20 @@ # directory basis. If all the files went into the top-level Resource directory, then we could simply set the RESOURCE property to a # list of all the resource files. set_source_files_properties(${cubepp_RESOURCES} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources") -set_source_files_properties("${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json" - PROPERTIES - MACOSX_PACKAGE_LOCATION - "Resources/vulkan/icd.d") +if(NOT APPLE_USE_SYSTEM_ICD) + set_source_files_properties("${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json" + PROPERTIES + MACOSX_PACKAGE_LOCATION + "Resources/vulkan/icd.d") -# Copy the MoltenVK lib into the bundle. -if(XCODE) - add_custom_command(TARGET vkcubepp POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" - ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/vkcubepp.app/Contents/Frameworks/libMoltenVK.dylib) -else() - add_custom_command(TARGET vkcubepp POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" - ${CMAKE_CURRENT_BINARY_DIR}/vkcubepp.app/Contents/Frameworks/libMoltenVK.dylib) + # Copy the MoltenVK lib into the bundle. + if(XCODE) + add_custom_command(TARGET vkcubepp POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" + ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/vkcubepp.app/Contents/Frameworks/libMoltenVK.dylib) + else() + add_custom_command(TARGET vkcubepp POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" + ${CMAKE_CURRENT_BINARY_DIR}/vkcubepp.app/Contents/Frameworks/libMoltenVK.dylib) + endif() endif()
diff --git a/cube/macOS/cubepp/DemoViewController.mm b/cube/macOS/cubepp/DemoViewController.mm index 2635b58..fbb1779 100644 --- a/cube/macOS/cubepp/DemoViewController.mm +++ b/cube/macOS/cubepp/DemoViewController.mm
@@ -83,7 +83,7 @@ const CVTimeStamp* outputTime, CVOptionFlags flagsIn, CVOptionFlags* flagsOut, void* target) { struct Demo* demo = (struct Demo*)target; - demo->run(); + demo->run<WsiPlatform::metal>(); if (demo->quit) { CVDisplayLinkStop(displayLink); }
diff --git a/cube/macOS/cubepp/Resources/Main.storyboard b/cube/macOS/cubepp/Resources/Main.storyboard index d21c149..abae39b 100644 --- a/cube/macOS/cubepp/Resources/Main.storyboard +++ b/cube/macOS/cubepp/Resources/Main.storyboard
@@ -11,9 +11,9 @@ <application id="hnw-xV-0zn" sceneMemberID="viewController"> <menu key="mainMenu" title="Main Menu" systemMenu="main" id="AYu-sK-qS6"> <items> - <menuItem title="MoltenVK Demo" id="1Xt-HY-uBw"> + <menuItem title="VkCubepp" id="1Xt-HY-uBw"> <modifierMask key="keyEquivalentModifierMask"/> - <menu key="submenu" title="MoltenVK Demo" systemMenu="apple" id="uQy-DD-JDr"> + <menu key="submenu" title="VkCubepp" systemMenu="apple" id="uQy-DD-JDr"> <items> <menuItem title="About Demo" id="5kV-Vb-QxS"> <modifierMask key="keyEquivalentModifierMask"/> @@ -77,7 +77,7 @@ <modifierMask key="keyEquivalentModifierMask"/> <menu key="submenu" title="Help" systemMenu="help" id="F2S-fz-NVQ"> <items> - <menuItem title="MoltenVK Demo Help" keyEquivalent="?" id="FKE-Sm-Kum"> + <menuItem title="VkCubepp Help" keyEquivalent="?" id="FKE-Sm-Kum"> <connections> <action selector="showHelp:" target="Ady-hI-5gd" id="y7X-2Q-9no"/> </connections> @@ -100,7 +100,7 @@ <scene sceneID="R2V-B0-nI4"> <objects> <windowController id="B8D-0N-5wS" sceneMemberID="viewController"> - <window key="window" title="MoltenVK Demo" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" showsToolbarButton="NO" visibleAtLaunch="NO" animationBehavior="default" id="IQv-IB-iLA"> + <window key="window" title="VkCubepp" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" showsToolbarButton="NO" visibleAtLaunch="NO" animationBehavior="default" id="IQv-IB-iLA"> <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES"/> <rect key="contentRect" x="1051" y="656" width="300" height="200"/> <rect key="screenRect" x="0.0" y="0.0" width="2560" height="1417"/>
diff --git a/cube/wayland_loader.h b/cube/wayland_loader.h index 2afab6e..7d7d914 100644 --- a/cube/wayland_loader.h +++ b/cube/wayland_loader.h
@@ -80,9 +80,6 @@ static inline void *initialize_wayland() { void *wayland_library = NULL; -#if defined(WAYLAND_LIBRARY) - wayland_library = dlopen(WAYLAND_LIBRARY, RTLD_NOW | RTLD_LOCAL); -#endif if (NULL == wayland_library) { wayland_library = dlopen("libwayland-client.so.0", RTLD_NOW | RTLD_LOCAL); }
diff --git a/cube/xcb_loader.h b/cube/xcb_loader.h index a94d5ab..cecd254 100644 --- a/cube/xcb_loader.h +++ b/cube/xcb_loader.h
@@ -88,9 +88,6 @@ void *initialize_xcb() { void *xcb_library = NULL; -#if defined(XCB_LIBRARY) - xcb_library = dlopen(XCB_LIBRARY, RTLD_NOW | RTLD_LOCAL); -#endif if (NULL == xcb_library) { xcb_library = dlopen("libxcb.so.1", RTLD_NOW | RTLD_LOCAL); }
diff --git a/cube/xlib_loader.h b/cube/xlib_loader.h index c7874d0..5553558 100644 --- a/cube/xlib_loader.h +++ b/cube/xlib_loader.h
@@ -41,6 +41,7 @@ typedef Status (*PFN_XInitThreads)(void); typedef int (*PFN_XFlush)(Display* /* display */ ); +typedef Status (*PFN_XSetWMProtocols)(Display*, Window, Atom*, int); static PFN_XDestroyWindow cube_XDestroyWindow = NULL; static PFN_XOpenDisplay cube_XOpenDisplay = NULL; @@ -55,6 +56,7 @@ static PFN_XCloseDisplay cube_XCloseDisplay = NULL; static PFN_XInitThreads cube_XInitThreads = NULL; static PFN_XFlush cube_XFlush = NULL; +static PFN_XSetWMProtocols cube_XSetWMProtocols = NULL; #define XDestroyWindow cube_XDestroyWindow #define XOpenDisplay cube_XOpenDisplay @@ -69,12 +71,10 @@ #define XCloseDisplay cube_XCloseDisplay #define XInitThreads cube_XInitThreads #define XFlush cube_XFlush +#define XSetWMProtocols cube_XSetWMProtocols void* initialize_xlib() { void* xlib_library = NULL; -#if defined(XLIB_LIBRARY) - xlib_library = dlopen(XLIB_LIBRARY, RTLD_NOW | RTLD_LOCAL); -#endif if (NULL == xlib_library) { xlib_library = dlopen("libX11.so.6", RTLD_NOW | RTLD_LOCAL); } @@ -104,6 +104,7 @@ cube_XCloseDisplay = TYPE_CONVERSION(PFN_XCloseDisplay)(dlsym(xlib_library, "XCloseDisplay")); cube_XInitThreads = TYPE_CONVERSION(PFN_XInitThreads)(dlsym(xlib_library, "XInitThreads")); cube_XFlush = TYPE_CONVERSION(PFN_XFlush)(dlsym(xlib_library, "XFlush")); + cube_XSetWMProtocols = TYPE_CONVERSION(PFN_XSetWMProtocols)(dlsym(xlib_library, "XSetWMProtocols")); return xlib_library; }
diff --git a/icd/CMakeLists.txt b/icd/CMakeLists.txt index 4ca660b..a66d9c9 100644 --- a/icd/CMakeLists.txt +++ b/icd/CMakeLists.txt
@@ -30,7 +30,12 @@ if(WIN32) add_definitions(-DVK_USE_PLATFORM_WIN32_KHR -DVK_USE_PLATFORM_WIN32_KHX -DWIN32_LEAN_AND_MEAN) elseif(APPLE) - add_definitions(-DVK_USE_PLATFORM_MACOS_MVK) + add_definitions(-DVK_USE_PLATFORM_METAL_EXT) + if (IOS) + add_definitions(-DVK_USE_PLATFORM_IOS_MVK) + else() + add_definitions(-DVK_USE_PLATFORM_MACOS_MVK) + endif() elseif(BUILD_MOCK_ANDROID_SUPPORT) add_definitions(-DVK_USE_PLATFORM_ANDROID_KHR) elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
diff --git a/icd/VkICD_mock_icd.json.in b/icd/VkICD_mock_icd.json.in index 2346bf9..8616631 100644 --- a/icd/VkICD_mock_icd.json.in +++ b/icd/VkICD_mock_icd.json.in
@@ -2,6 +2,6 @@ "file_format_version": "1.0.1", "ICD": { "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.4.304" + "api_version": "1.4.350" } } \ No newline at end of file
diff --git a/icd/generated/function_declarations.h b/icd/generated/function_declarations.h index 5210af7..76f5631 100644 --- a/icd/generated/function_declarations.h +++ b/icd/generated/function_declarations.h
@@ -1,5 +1,5 @@ /* -** Copyright (c) 2015-2024 The Khronos Group Inc. +** Copyright (c) 2015-2025 The Khronos Group Inc. ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. @@ -19,9 +19,7 @@ ** */ - #pragma once - #include <stdint.h> #include <cstring> #include <string> @@ -29,4723 +27,3172 @@ #include <vulkan/vulkan.h> namespace vkmock { - // Map of instance extension name to version static const std::unordered_map<std::string, uint32_t> instance_extension_map = { - {"VK_KHR_surface", 25}, - {"VK_KHR_display", 23}, - {"VK_KHR_xlib_surface", 6}, - {"VK_KHR_xcb_surface", 6}, - {"VK_KHR_wayland_surface", 6}, - {"VK_KHR_android_surface", 6}, - {"VK_KHR_win32_surface", 6}, - {"VK_EXT_debug_report", 10}, - {"VK_GGP_stream_descriptor_surface", 1}, - {"VK_NV_external_memory_capabilities", 1}, - {"VK_KHR_get_physical_device_properties2", 2}, - {"VK_EXT_validation_flags", 3}, - {"VK_NN_vi_surface", 1}, - {"VK_KHR_device_group_creation", 1}, - {"VK_KHR_external_memory_capabilities", 1}, - {"VK_KHR_external_semaphore_capabilities", 1}, - {"VK_EXT_direct_mode_display", 1}, - {"VK_EXT_acquire_xlib_display", 1}, - {"VK_EXT_display_surface_counter", 1}, - {"VK_EXT_swapchain_colorspace", 5}, - {"VK_KHR_external_fence_capabilities", 1}, - {"VK_KHR_get_surface_capabilities2", 1}, - {"VK_KHR_get_display_properties2", 1}, - {"VK_MVK_ios_surface", 3}, - {"VK_MVK_macos_surface", 3}, - {"VK_EXT_debug_utils", 2}, - {"VK_FUCHSIA_imagepipe_surface", 1}, - {"VK_EXT_metal_surface", 1}, - {"VK_KHR_surface_protected_capabilities", 1}, - {"VK_EXT_validation_features", 6}, - {"VK_EXT_headless_surface", 1}, - {"VK_EXT_surface_maintenance1", 1}, - {"VK_EXT_acquire_drm_display", 1}, - {"VK_EXT_directfb_surface", 1}, - {"VK_QNX_screen_surface", 1}, - {"VK_KHR_portability_enumeration", 1}, - {"VK_GOOGLE_surfaceless_query", 2}, - {"VK_LUNARG_direct_driver_loading", 1}, - {"VK_EXT_layer_settings", 2}, - {"VK_NV_display_stereo", 1}, + {"VK_KHR_surface", VK_KHR_SURFACE_SPEC_VERSION}, + {"VK_KHR_display", VK_KHR_DISPLAY_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_XLIB_KHR + {"VK_KHR_xlib_surface", VK_KHR_XLIB_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_XCB_KHR + {"VK_KHR_xcb_surface", VK_KHR_XCB_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + {"VK_KHR_wayland_surface", VK_KHR_WAYLAND_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"VK_KHR_android_surface", VK_KHR_ANDROID_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_KHR_win32_surface", VK_KHR_WIN32_SURFACE_SPEC_VERSION}, +#endif + {"VK_KHR_get_physical_device_properties2", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION}, + {"VK_KHR_device_group_creation", VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION}, + {"VK_KHR_external_memory_capabilities", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION}, + {"VK_KHR_external_semaphore_capabilities", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION}, + {"VK_KHR_external_fence_capabilities", VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION}, + {"VK_KHR_get_surface_capabilities2", VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}, + {"VK_KHR_get_display_properties2", VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION}, + {"VK_KHR_surface_protected_capabilities", VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION}, + {"VK_KHR_portability_enumeration", VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION}, + {"VK_KHR_surface_maintenance1", VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION}, + {"VK_EXT_debug_report", VK_EXT_DEBUG_REPORT_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_GGP + {"VK_GGP_stream_descriptor_surface", VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION}, +#endif + {"VK_NV_external_memory_capabilities", VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION}, + {"VK_EXT_validation_flags", VK_EXT_VALIDATION_FLAGS_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_VI_NN + {"VK_NN_vi_surface", VK_NN_VI_SURFACE_SPEC_VERSION}, +#endif + {"VK_EXT_direct_mode_display", VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + {"VK_EXT_acquire_xlib_display", VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION}, +#endif + {"VK_EXT_display_surface_counter", VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION}, + {"VK_EXT_swapchain_colorspace", VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_IOS_MVK + {"VK_MVK_ios_surface", VK_MVK_IOS_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_MACOS_MVK + {"VK_MVK_macos_surface", VK_MVK_MACOS_SURFACE_SPEC_VERSION}, +#endif + {"VK_EXT_debug_utils", VK_EXT_DEBUG_UTILS_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_FUCHSIA + {"VK_FUCHSIA_imagepipe_surface", VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_METAL_EXT + {"VK_EXT_metal_surface", VK_EXT_METAL_SURFACE_SPEC_VERSION}, +#endif + {"VK_EXT_validation_features", VK_EXT_VALIDATION_FEATURES_SPEC_VERSION}, + {"VK_EXT_headless_surface", VK_EXT_HEADLESS_SURFACE_SPEC_VERSION}, + {"VK_EXT_surface_maintenance1", VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION}, + {"VK_EXT_acquire_drm_display", VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + {"VK_EXT_directfb_surface", VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"VK_QNX_screen_surface", VK_QNX_SCREEN_SURFACE_SPEC_VERSION}, +#endif + {"VK_GOOGLE_surfaceless_query", VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION}, + {"VK_LUNARG_direct_driver_loading", VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION}, + {"VK_EXT_layer_settings", VK_EXT_LAYER_SETTINGS_SPEC_VERSION}, + {"VK_NV_display_stereo", VK_NV_DISPLAY_STEREO_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_OHOS + {"VK_OHOS_surface", VK_OHOS_SURFACE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_UBM_SEC + {"VK_SEC_ubm_surface", VK_SEC_UBM_SURFACE_SPEC_VERSION}, +#endif }; // Map of device extension name to version static const std::unordered_map<std::string, uint32_t> device_extension_map = { - {"VK_KHR_swapchain", 70}, - {"VK_KHR_display_swapchain", 10}, - {"VK_NV_glsl_shader", 1}, - {"VK_EXT_depth_range_unrestricted", 1}, - {"VK_KHR_sampler_mirror_clamp_to_edge", 3}, - {"VK_IMG_filter_cubic", 1}, - {"VK_AMD_rasterization_order", 1}, - {"VK_AMD_shader_trinary_minmax", 1}, - {"VK_AMD_shader_explicit_vertex_parameter", 1}, - {"VK_EXT_debug_marker", 4}, - {"VK_KHR_video_queue", 8}, - {"VK_KHR_video_decode_queue", 8}, - {"VK_AMD_gcn_shader", 1}, - {"VK_NV_dedicated_allocation", 1}, - {"VK_EXT_transform_feedback", 1}, - {"VK_NVX_binary_import", 2}, - {"VK_NVX_image_view_handle", 3}, - {"VK_AMD_draw_indirect_count", 2}, - {"VK_AMD_negative_viewport_height", 1}, - {"VK_AMD_gpu_shader_half_float", 2}, - {"VK_AMD_shader_ballot", 1}, - {"VK_KHR_video_encode_h264", 14}, - {"VK_KHR_video_encode_h265", 14}, - {"VK_KHR_video_decode_h264", 9}, - {"VK_AMD_texture_gather_bias_lod", 1}, - {"VK_AMD_shader_info", 1}, - {"VK_KHR_dynamic_rendering", 1}, - {"VK_AMD_shader_image_load_store_lod", 1}, - {"VK_NV_corner_sampled_image", 2}, - {"VK_KHR_multiview", 1}, - {"VK_IMG_format_pvrtc", 1}, - {"VK_NV_external_memory", 1}, - {"VK_NV_external_memory_win32", 1}, - {"VK_NV_win32_keyed_mutex", 2}, - {"VK_KHR_device_group", 4}, - {"VK_KHR_shader_draw_parameters", 1}, - {"VK_EXT_shader_subgroup_ballot", 1}, - {"VK_EXT_shader_subgroup_vote", 1}, - {"VK_EXT_texture_compression_astc_hdr", 1}, - {"VK_EXT_astc_decode_mode", 1}, - {"VK_EXT_pipeline_robustness", 1}, - {"VK_KHR_maintenance1", 2}, - {"VK_KHR_external_memory", 1}, - {"VK_KHR_external_memory_win32", 1}, - {"VK_KHR_external_memory_fd", 1}, - {"VK_KHR_win32_keyed_mutex", 1}, - {"VK_KHR_external_semaphore", 1}, - {"VK_KHR_external_semaphore_win32", 1}, - {"VK_KHR_external_semaphore_fd", 1}, - {"VK_KHR_push_descriptor", 2}, - {"VK_EXT_conditional_rendering", 2}, - {"VK_KHR_shader_float16_int8", 1}, - {"VK_KHR_16bit_storage", 1}, - {"VK_KHR_incremental_present", 2}, - {"VK_KHR_descriptor_update_template", 1}, - {"VK_NV_clip_space_w_scaling", 1}, - {"VK_EXT_display_control", 1}, - {"VK_GOOGLE_display_timing", 1}, - {"VK_NV_sample_mask_override_coverage", 1}, - {"VK_NV_geometry_shader_passthrough", 1}, - {"VK_NV_viewport_array2", 1}, - {"VK_NVX_multiview_per_view_attributes", 1}, - {"VK_NV_viewport_swizzle", 1}, - {"VK_EXT_discard_rectangles", 2}, - {"VK_EXT_conservative_rasterization", 1}, - {"VK_EXT_depth_clip_enable", 1}, - {"VK_EXT_hdr_metadata", 3}, - {"VK_KHR_imageless_framebuffer", 1}, - {"VK_KHR_create_renderpass2", 1}, - {"VK_IMG_relaxed_line_rasterization", 1}, - {"VK_KHR_shared_presentable_image", 1}, - {"VK_KHR_external_fence", 1}, - {"VK_KHR_external_fence_win32", 1}, - {"VK_KHR_external_fence_fd", 1}, - {"VK_KHR_performance_query", 1}, - {"VK_KHR_maintenance2", 1}, - {"VK_KHR_variable_pointers", 1}, - {"VK_EXT_external_memory_dma_buf", 1}, - {"VK_EXT_queue_family_foreign", 1}, - {"VK_KHR_dedicated_allocation", 3}, - {"VK_ANDROID_external_memory_android_hardware_buffer", 5}, - {"VK_EXT_sampler_filter_minmax", 2}, - {"VK_KHR_storage_buffer_storage_class", 1}, - {"VK_AMD_gpu_shader_int16", 2}, - {"VK_AMDX_shader_enqueue", 2}, - {"VK_AMD_mixed_attachment_samples", 1}, - {"VK_AMD_shader_fragment_mask", 1}, - {"VK_EXT_inline_uniform_block", 1}, - {"VK_EXT_shader_stencil_export", 1}, - {"VK_EXT_sample_locations", 1}, - {"VK_KHR_relaxed_block_layout", 1}, - {"VK_KHR_get_memory_requirements2", 1}, - {"VK_KHR_image_format_list", 1}, - {"VK_EXT_blend_operation_advanced", 2}, - {"VK_NV_fragment_coverage_to_color", 1}, - {"VK_KHR_acceleration_structure", 13}, - {"VK_KHR_ray_tracing_pipeline", 1}, - {"VK_KHR_ray_query", 1}, - {"VK_NV_framebuffer_mixed_samples", 1}, - {"VK_NV_fill_rectangle", 1}, - {"VK_NV_shader_sm_builtins", 1}, - {"VK_EXT_post_depth_coverage", 1}, - {"VK_KHR_sampler_ycbcr_conversion", 14}, - {"VK_KHR_bind_memory2", 1}, - {"VK_EXT_image_drm_format_modifier", 2}, - {"VK_EXT_descriptor_indexing", 2}, - {"VK_EXT_shader_viewport_index_layer", 1}, - {"VK_NV_shading_rate_image", 3}, - {"VK_NV_ray_tracing", 3}, - {"VK_NV_representative_fragment_test", 2}, - {"VK_KHR_maintenance3", 1}, - {"VK_KHR_draw_indirect_count", 1}, - {"VK_EXT_filter_cubic", 3}, - {"VK_QCOM_render_pass_shader_resolve", 4}, - {"VK_EXT_global_priority", 2}, - {"VK_KHR_shader_subgroup_extended_types", 1}, - {"VK_KHR_8bit_storage", 1}, - {"VK_EXT_external_memory_host", 1}, - {"VK_AMD_buffer_marker", 1}, - {"VK_KHR_shader_atomic_int64", 1}, - {"VK_KHR_shader_clock", 1}, - {"VK_AMD_pipeline_compiler_control", 1}, - {"VK_EXT_calibrated_timestamps", 2}, - {"VK_AMD_shader_core_properties", 2}, - {"VK_KHR_video_decode_h265", 8}, - {"VK_KHR_global_priority", 1}, - {"VK_AMD_memory_overallocation_behavior", 1}, - {"VK_EXT_vertex_attribute_divisor", 3}, - {"VK_GGP_frame_token", 1}, - {"VK_EXT_pipeline_creation_feedback", 1}, - {"VK_KHR_driver_properties", 1}, - {"VK_KHR_shader_float_controls", 4}, - {"VK_NV_shader_subgroup_partitioned", 1}, - {"VK_KHR_depth_stencil_resolve", 1}, - {"VK_KHR_swapchain_mutable_format", 1}, - {"VK_NV_compute_shader_derivatives", 1}, - {"VK_NV_mesh_shader", 1}, - {"VK_NV_fragment_shader_barycentric", 1}, - {"VK_NV_shader_image_footprint", 2}, - {"VK_NV_scissor_exclusive", 2}, - {"VK_NV_device_diagnostic_checkpoints", 2}, - {"VK_KHR_timeline_semaphore", 2}, - {"VK_INTEL_shader_integer_functions2", 1}, - {"VK_INTEL_performance_query", 2}, - {"VK_KHR_vulkan_memory_model", 3}, - {"VK_EXT_pci_bus_info", 2}, - {"VK_AMD_display_native_hdr", 1}, - {"VK_KHR_shader_terminate_invocation", 1}, - {"VK_EXT_fragment_density_map", 2}, - {"VK_EXT_scalar_block_layout", 1}, - {"VK_GOOGLE_hlsl_functionality1", 1}, - {"VK_GOOGLE_decorate_string", 1}, - {"VK_EXT_subgroup_size_control", 2}, - {"VK_KHR_fragment_shading_rate", 2}, - {"VK_AMD_shader_core_properties2", 1}, - {"VK_AMD_device_coherent_memory", 1}, - {"VK_KHR_dynamic_rendering_local_read", 1}, - {"VK_EXT_shader_image_atomic_int64", 1}, - {"VK_KHR_shader_quad_control", 1}, - {"VK_KHR_spirv_1_4", 1}, - {"VK_EXT_memory_budget", 1}, - {"VK_EXT_memory_priority", 1}, - {"VK_NV_dedicated_allocation_image_aliasing", 1}, - {"VK_KHR_separate_depth_stencil_layouts", 1}, - {"VK_EXT_buffer_device_address", 2}, - {"VK_EXT_tooling_info", 1}, - {"VK_EXT_separate_stencil_usage", 1}, - {"VK_KHR_present_wait", 1}, - {"VK_NV_cooperative_matrix", 1}, - {"VK_NV_coverage_reduction_mode", 1}, - {"VK_EXT_fragment_shader_interlock", 1}, - {"VK_EXT_ycbcr_image_arrays", 1}, - {"VK_KHR_uniform_buffer_standard_layout", 1}, - {"VK_EXT_provoking_vertex", 1}, - {"VK_EXT_full_screen_exclusive", 4}, - {"VK_KHR_buffer_device_address", 1}, - {"VK_EXT_line_rasterization", 1}, - {"VK_EXT_shader_atomic_float", 1}, - {"VK_EXT_host_query_reset", 1}, - {"VK_EXT_index_type_uint8", 1}, - {"VK_EXT_extended_dynamic_state", 1}, - {"VK_KHR_deferred_host_operations", 4}, - {"VK_KHR_pipeline_executable_properties", 1}, - {"VK_EXT_host_image_copy", 1}, - {"VK_KHR_map_memory2", 1}, - {"VK_EXT_map_memory_placed", 1}, - {"VK_EXT_shader_atomic_float2", 1}, - {"VK_EXT_swapchain_maintenance1", 1}, - {"VK_EXT_shader_demote_to_helper_invocation", 1}, - {"VK_NV_device_generated_commands", 3}, - {"VK_NV_inherited_viewport_scissor", 1}, - {"VK_KHR_shader_integer_dot_product", 1}, - {"VK_EXT_texel_buffer_alignment", 1}, - {"VK_QCOM_render_pass_transform", 4}, - {"VK_EXT_depth_bias_control", 1}, - {"VK_EXT_device_memory_report", 2}, - {"VK_EXT_robustness2", 1}, - {"VK_EXT_custom_border_color", 12}, - {"VK_GOOGLE_user_type", 1}, - {"VK_KHR_pipeline_library", 1}, - {"VK_NV_present_barrier", 1}, - {"VK_KHR_shader_non_semantic_info", 1}, - {"VK_KHR_present_id", 1}, - {"VK_EXT_private_data", 1}, - {"VK_EXT_pipeline_creation_cache_control", 3}, - {"VK_KHR_video_encode_queue", 12}, - {"VK_NV_device_diagnostics_config", 2}, - {"VK_QCOM_render_pass_store_ops", 2}, - {"VK_NV_cuda_kernel_launch", 2}, - {"VK_NV_low_latency", 1}, - {"VK_EXT_metal_objects", 2}, - {"VK_KHR_synchronization2", 1}, - {"VK_EXT_descriptor_buffer", 1}, - {"VK_EXT_graphics_pipeline_library", 1}, - {"VK_AMD_shader_early_and_late_fragment_tests", 1}, - {"VK_KHR_fragment_shader_barycentric", 1}, - {"VK_KHR_shader_subgroup_uniform_control_flow", 1}, - {"VK_KHR_zero_initialize_workgroup_memory", 1}, - {"VK_NV_fragment_shading_rate_enums", 1}, - {"VK_NV_ray_tracing_motion_blur", 1}, - {"VK_EXT_mesh_shader", 1}, - {"VK_EXT_ycbcr_2plane_444_formats", 1}, - {"VK_EXT_fragment_density_map2", 1}, - {"VK_QCOM_rotated_copy_commands", 2}, - {"VK_EXT_image_robustness", 1}, - {"VK_KHR_workgroup_memory_explicit_layout", 1}, - {"VK_KHR_copy_commands2", 1}, - {"VK_EXT_image_compression_control", 1}, - {"VK_EXT_attachment_feedback_loop_layout", 2}, - {"VK_EXT_4444_formats", 1}, - {"VK_EXT_device_fault", 2}, - {"VK_ARM_rasterization_order_attachment_access", 1}, - {"VK_EXT_rgba10x6_formats", 1}, - {"VK_NV_acquire_winrt_display", 1}, - {"VK_VALVE_mutable_descriptor_type", 1}, - {"VK_EXT_vertex_input_dynamic_state", 2}, - {"VK_EXT_physical_device_drm", 1}, - {"VK_EXT_device_address_binding_report", 1}, - {"VK_EXT_depth_clip_control", 1}, - {"VK_EXT_primitive_topology_list_restart", 1}, - {"VK_KHR_format_feature_flags2", 2}, - {"VK_EXT_present_mode_fifo_latest_ready", 1}, - {"VK_FUCHSIA_external_memory", 1}, - {"VK_FUCHSIA_external_semaphore", 1}, - {"VK_FUCHSIA_buffer_collection", 2}, - {"VK_HUAWEI_subpass_shading", 3}, - {"VK_HUAWEI_invocation_mask", 1}, - {"VK_NV_external_memory_rdma", 1}, - {"VK_EXT_pipeline_properties", 1}, - {"VK_EXT_frame_boundary", 1}, - {"VK_EXT_multisampled_render_to_single_sampled", 1}, - {"VK_EXT_extended_dynamic_state2", 1}, - {"VK_EXT_color_write_enable", 1}, - {"VK_EXT_primitives_generated_query", 1}, - {"VK_KHR_ray_tracing_maintenance1", 1}, - {"VK_EXT_global_priority_query", 1}, - {"VK_EXT_image_view_min_lod", 1}, - {"VK_EXT_multi_draw", 1}, - {"VK_EXT_image_2d_view_of_3d", 1}, - {"VK_EXT_shader_tile_image", 1}, - {"VK_EXT_opacity_micromap", 2}, - {"VK_NV_displacement_micromap", 2}, - {"VK_EXT_load_store_op_none", 1}, - {"VK_HUAWEI_cluster_culling_shader", 3}, - {"VK_EXT_border_color_swizzle", 1}, - {"VK_EXT_pageable_device_local_memory", 1}, - {"VK_KHR_maintenance4", 2}, - {"VK_ARM_shader_core_properties", 1}, - {"VK_KHR_shader_subgroup_rotate", 2}, - {"VK_ARM_scheduling_controls", 1}, - {"VK_EXT_image_sliced_view_of_3d", 1}, - {"VK_VALVE_descriptor_set_host_mapping", 1}, - {"VK_EXT_depth_clamp_zero_one", 1}, - {"VK_EXT_non_seamless_cube_map", 1}, - {"VK_ARM_render_pass_striped", 1}, - {"VK_QCOM_fragment_density_map_offset", 2}, - {"VK_NV_copy_memory_indirect", 1}, - {"VK_NV_memory_decompression", 1}, - {"VK_NV_device_generated_commands_compute", 2}, - {"VK_NV_linear_color_attachment", 1}, - {"VK_KHR_shader_maximal_reconvergence", 1}, - {"VK_EXT_image_compression_control_swapchain", 1}, - {"VK_QCOM_image_processing", 1}, - {"VK_EXT_nested_command_buffer", 1}, - {"VK_EXT_external_memory_acquire_unmodified", 1}, - {"VK_EXT_extended_dynamic_state3", 2}, - {"VK_EXT_subpass_merge_feedback", 2}, - {"VK_EXT_shader_module_identifier", 1}, - {"VK_EXT_rasterization_order_attachment_access", 1}, - {"VK_NV_optical_flow", 1}, - {"VK_EXT_legacy_dithering", 2}, - {"VK_EXT_pipeline_protected_access", 1}, - {"VK_ANDROID_external_format_resolve", 1}, - {"VK_KHR_maintenance5", 1}, - {"VK_AMD_anti_lag", 1}, - {"VK_KHR_ray_tracing_position_fetch", 1}, - {"VK_EXT_shader_object", 1}, - {"VK_KHR_pipeline_binary", 1}, - {"VK_QCOM_tile_properties", 1}, - {"VK_SEC_amigo_profiling", 1}, - {"VK_QCOM_multiview_per_view_viewports", 1}, - {"VK_NV_ray_tracing_invocation_reorder", 1}, - {"VK_NV_extended_sparse_address_space", 1}, - {"VK_EXT_mutable_descriptor_type", 1}, - {"VK_EXT_legacy_vertex_attributes", 1}, - {"VK_ARM_shader_core_builtins", 2}, - {"VK_EXT_pipeline_library_group_handles", 1}, - {"VK_EXT_dynamic_rendering_unused_attachments", 1}, - {"VK_NV_low_latency2", 2}, - {"VK_KHR_cooperative_matrix", 2}, - {"VK_QCOM_multiview_per_view_render_areas", 1}, - {"VK_KHR_compute_shader_derivatives", 1}, - {"VK_KHR_video_decode_av1", 1}, - {"VK_KHR_video_encode_av1", 1}, - {"VK_KHR_video_maintenance1", 1}, - {"VK_NV_per_stage_descriptor_set", 1}, - {"VK_QCOM_image_processing2", 1}, - {"VK_QCOM_filter_cubic_weights", 1}, - {"VK_QCOM_ycbcr_degamma", 1}, - {"VK_QCOM_filter_cubic_clamp", 1}, - {"VK_EXT_attachment_feedback_loop_dynamic_state", 1}, - {"VK_KHR_vertex_attribute_divisor", 1}, - {"VK_KHR_load_store_op_none", 1}, - {"VK_KHR_shader_float_controls2", 1}, - {"VK_QNX_external_memory_screen_buffer", 1}, - {"VK_MSFT_layered_driver", 1}, - {"VK_KHR_index_type_uint8", 1}, - {"VK_KHR_line_rasterization", 1}, - {"VK_KHR_calibrated_timestamps", 1}, - {"VK_KHR_shader_expect_assume", 1}, - {"VK_KHR_maintenance6", 1}, - {"VK_NV_descriptor_pool_overallocation", 1}, - {"VK_KHR_video_encode_quantization_map", 2}, - {"VK_NV_raw_access_chains", 1}, - {"VK_KHR_shader_relaxed_extended_instruction", 1}, - {"VK_NV_command_buffer_inheritance", 1}, - {"VK_KHR_maintenance7", 1}, - {"VK_NV_shader_atomic_float16_vector", 1}, - {"VK_EXT_shader_replicated_composites", 1}, - {"VK_NV_ray_tracing_validation", 1}, - {"VK_EXT_device_generated_commands", 1}, - {"VK_MESA_image_alignment_control", 1}, - {"VK_EXT_depth_clamp_control", 1}, - {"VK_HUAWEI_hdr_vivid", 1}, - {"VK_NV_cooperative_matrix2", 1}, - {"VK_EXT_vertex_attribute_robustness", 1}, + {"VK_KHR_swapchain", VK_KHR_SWAPCHAIN_SPEC_VERSION}, + {"VK_KHR_display_swapchain", VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION}, + {"VK_KHR_sampler_mirror_clamp_to_edge", VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION}, + {"VK_KHR_video_queue", VK_KHR_VIDEO_QUEUE_SPEC_VERSION}, + {"VK_KHR_video_decode_queue", VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION}, + {"VK_KHR_video_encode_h264", VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION}, + {"VK_KHR_video_encode_h265", VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION}, + {"VK_KHR_video_decode_h264", VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION}, + {"VK_KHR_dynamic_rendering", VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION}, + {"VK_KHR_multiview", VK_KHR_MULTIVIEW_SPEC_VERSION}, + {"VK_KHR_device_group", VK_KHR_DEVICE_GROUP_SPEC_VERSION}, + {"VK_KHR_shader_draw_parameters", VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION}, + {"VK_KHR_maintenance1", VK_KHR_MAINTENANCE_1_SPEC_VERSION}, + {"VK_KHR_external_memory", VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_KHR_external_memory_win32", VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION}, +#endif + {"VK_KHR_external_memory_fd", VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_KHR_win32_keyed_mutex", VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION}, +#endif + {"VK_KHR_external_semaphore", VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_KHR_external_semaphore_win32", VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION}, +#endif + {"VK_KHR_external_semaphore_fd", VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION}, + {"VK_KHR_push_descriptor", VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION}, + {"VK_KHR_shader_float16_int8", VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION}, + {"VK_KHR_16bit_storage", VK_KHR_16BIT_STORAGE_SPEC_VERSION}, + {"VK_KHR_incremental_present", VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION}, + {"VK_KHR_descriptor_update_template", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION}, + {"VK_KHR_imageless_framebuffer", VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION}, + {"VK_KHR_create_renderpass2", VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION}, + {"VK_KHR_shared_presentable_image", VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION}, + {"VK_KHR_external_fence", VK_KHR_EXTERNAL_FENCE_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_KHR_external_fence_win32", VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION}, +#endif + {"VK_KHR_external_fence_fd", VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION}, + {"VK_KHR_performance_query", VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION}, + {"VK_KHR_maintenance2", VK_KHR_MAINTENANCE_2_SPEC_VERSION}, + {"VK_KHR_variable_pointers", VK_KHR_VARIABLE_POINTERS_SPEC_VERSION}, + {"VK_KHR_dedicated_allocation", VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION}, + {"VK_KHR_storage_buffer_storage_class", VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION}, + {"VK_KHR_shader_bfloat16", VK_KHR_SHADER_BFLOAT16_SPEC_VERSION}, + {"VK_KHR_relaxed_block_layout", VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION}, + {"VK_KHR_get_memory_requirements2", VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION}, + {"VK_KHR_image_format_list", VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION}, + {"VK_KHR_sampler_ycbcr_conversion", VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION}, + {"VK_KHR_bind_memory2", VK_KHR_BIND_MEMORY_2_SPEC_VERSION}, + {"VK_KHR_maintenance3", VK_KHR_MAINTENANCE_3_SPEC_VERSION}, + {"VK_KHR_draw_indirect_count", VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION}, + {"VK_KHR_shader_subgroup_extended_types", VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION}, + {"VK_KHR_8bit_storage", VK_KHR_8BIT_STORAGE_SPEC_VERSION}, + {"VK_KHR_shader_atomic_int64", VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION}, + {"VK_KHR_shader_clock", VK_KHR_SHADER_CLOCK_SPEC_VERSION}, + {"VK_KHR_video_decode_h265", VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION}, + {"VK_KHR_global_priority", VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION}, + {"VK_KHR_driver_properties", VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION}, + {"VK_KHR_shader_float_controls", VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION}, + {"VK_KHR_depth_stencil_resolve", VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION}, + {"VK_KHR_swapchain_mutable_format", VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION}, + {"VK_KHR_timeline_semaphore", VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION}, + {"VK_KHR_vulkan_memory_model", VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION}, + {"VK_KHR_shader_terminate_invocation", VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION}, + {"VK_KHR_fragment_shading_rate", VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION}, + {"VK_KHR_shader_constant_data", VK_KHR_SHADER_CONSTANT_DATA_SPEC_VERSION}, + {"VK_KHR_dynamic_rendering_local_read", VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION}, + {"VK_KHR_shader_abort", VK_KHR_SHADER_ABORT_SPEC_VERSION}, + {"VK_KHR_shader_quad_control", VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION}, + {"VK_KHR_spirv_1_4", VK_KHR_SPIRV_1_4_SPEC_VERSION}, + {"VK_KHR_separate_depth_stencil_layouts", VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION}, + {"VK_KHR_present_wait", VK_KHR_PRESENT_WAIT_SPEC_VERSION}, + {"VK_KHR_uniform_buffer_standard_layout", VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION}, + {"VK_KHR_buffer_device_address", VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION}, + {"VK_KHR_deferred_host_operations", VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION}, + {"VK_KHR_pipeline_executable_properties", VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION}, + {"VK_KHR_map_memory2", VK_KHR_MAP_MEMORY_2_SPEC_VERSION}, + {"VK_KHR_shader_integer_dot_product", VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION}, + {"VK_KHR_pipeline_library", VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION}, + {"VK_KHR_shader_non_semantic_info", VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION}, + {"VK_KHR_present_id", VK_KHR_PRESENT_ID_SPEC_VERSION}, + {"VK_KHR_video_encode_queue", VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION}, + {"VK_KHR_synchronization2", VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION}, + {"VK_KHR_device_address_commands", VK_KHR_DEVICE_ADDRESS_COMMANDS_SPEC_VERSION}, + {"VK_KHR_fragment_shader_barycentric", VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION}, + {"VK_KHR_shader_subgroup_uniform_control_flow", VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION}, + {"VK_KHR_zero_initialize_workgroup_memory", VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION}, + {"VK_KHR_workgroup_memory_explicit_layout", VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION}, + {"VK_KHR_copy_commands2", VK_KHR_COPY_COMMANDS_2_SPEC_VERSION}, + {"VK_KHR_format_feature_flags2", VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION}, + {"VK_KHR_ray_tracing_maintenance1", VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION}, + {"VK_KHR_shader_untyped_pointers", VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION}, + {"VK_KHR_maintenance4", VK_KHR_MAINTENANCE_4_SPEC_VERSION}, + {"VK_KHR_shader_subgroup_rotate", VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION}, + {"VK_KHR_shader_maximal_reconvergence", VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION}, + {"VK_KHR_maintenance5", VK_KHR_MAINTENANCE_5_SPEC_VERSION}, + {"VK_KHR_present_id2", VK_KHR_PRESENT_ID_2_SPEC_VERSION}, + {"VK_KHR_present_wait2", VK_KHR_PRESENT_WAIT_2_SPEC_VERSION}, + {"VK_KHR_ray_tracing_position_fetch", VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION}, + {"VK_KHR_pipeline_binary", VK_KHR_PIPELINE_BINARY_SPEC_VERSION}, + {"VK_KHR_swapchain_maintenance1", VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION}, + {"VK_KHR_internally_synchronized_queues", VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION}, + {"VK_KHR_cooperative_matrix", VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION}, + {"VK_KHR_compute_shader_derivatives", VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION}, + {"VK_KHR_video_decode_av1", VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION}, + {"VK_KHR_video_encode_av1", VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION}, + {"VK_KHR_video_decode_vp9", VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION}, + {"VK_KHR_video_maintenance1", VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION}, + {"VK_KHR_vertex_attribute_divisor", VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION}, + {"VK_KHR_load_store_op_none", VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION}, + {"VK_KHR_unified_image_layouts", VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION}, + {"VK_KHR_shader_float_controls2", VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION}, + {"VK_KHR_index_type_uint8", VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION}, + {"VK_KHR_line_rasterization", VK_KHR_LINE_RASTERIZATION_SPEC_VERSION}, + {"VK_KHR_calibrated_timestamps", VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION}, + {"VK_KHR_shader_expect_assume", VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION}, + {"VK_KHR_maintenance6", VK_KHR_MAINTENANCE_6_SPEC_VERSION}, + {"VK_KHR_copy_memory_indirect", VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION}, + {"VK_KHR_video_encode_intra_refresh", VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION}, + {"VK_KHR_video_encode_quantization_map", VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION}, + {"VK_KHR_shader_relaxed_extended_instruction", VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION}, + {"VK_KHR_maintenance7", VK_KHR_MAINTENANCE_7_SPEC_VERSION}, + {"VK_KHR_device_fault", VK_KHR_DEVICE_FAULT_SPEC_VERSION}, + {"VK_KHR_maintenance8", VK_KHR_MAINTENANCE_8_SPEC_VERSION}, + {"VK_KHR_shader_fma", VK_KHR_SHADER_FMA_SPEC_VERSION}, + {"VK_KHR_maintenance9", VK_KHR_MAINTENANCE_9_SPEC_VERSION}, + {"VK_KHR_video_maintenance2", VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION}, + {"VK_KHR_depth_clamp_zero_one", VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION}, + {"VK_KHR_robustness2", VK_KHR_ROBUSTNESS_2_SPEC_VERSION}, + {"VK_KHR_present_mode_fifo_latest_ready", VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION}, + {"VK_KHR_maintenance10", VK_KHR_MAINTENANCE_10_SPEC_VERSION}, + {"VK_KHR_maintenance11", VK_KHR_MAINTENANCE_11_SPEC_VERSION}, + {"VK_NV_glsl_shader", VK_NV_GLSL_SHADER_SPEC_VERSION}, + {"VK_EXT_depth_range_unrestricted", VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION}, + {"VK_IMG_filter_cubic", VK_IMG_FILTER_CUBIC_SPEC_VERSION}, + {"VK_AMD_rasterization_order", VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION}, + {"VK_AMD_shader_trinary_minmax", VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION}, + {"VK_AMD_shader_explicit_vertex_parameter", VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION}, + {"VK_EXT_debug_marker", VK_EXT_DEBUG_MARKER_SPEC_VERSION}, + {"VK_AMD_gcn_shader", VK_AMD_GCN_SHADER_SPEC_VERSION}, + {"VK_NV_dedicated_allocation", VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION}, + {"VK_EXT_transform_feedback", VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION}, + {"VK_NVX_binary_import", VK_NVX_BINARY_IMPORT_SPEC_VERSION}, + {"VK_NVX_image_view_handle", VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION}, + {"VK_AMD_draw_indirect_count", VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION}, + {"VK_AMD_negative_viewport_height", VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION}, + {"VK_AMD_gpu_shader_half_float", VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION}, + {"VK_AMD_shader_ballot", VK_AMD_SHADER_BALLOT_SPEC_VERSION}, + {"VK_AMD_texture_gather_bias_lod", VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION}, + {"VK_AMD_shader_info", VK_AMD_SHADER_INFO_SPEC_VERSION}, + {"VK_AMD_shader_image_load_store_lod", VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION}, + {"VK_NV_corner_sampled_image", VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION}, + {"VK_IMG_format_pvrtc", VK_IMG_FORMAT_PVRTC_SPEC_VERSION}, + {"VK_NV_external_memory", VK_NV_EXTERNAL_MEMORY_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_NV_external_memory_win32", VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_NV_win32_keyed_mutex", VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION}, +#endif + {"VK_EXT_shader_subgroup_ballot", VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION}, + {"VK_EXT_shader_subgroup_vote", VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION}, + {"VK_EXT_texture_compression_astc_hdr", VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION}, + {"VK_EXT_astc_decode_mode", VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION}, + {"VK_EXT_pipeline_robustness", VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION}, + {"VK_EXT_conditional_rendering", VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION}, + {"VK_NV_clip_space_w_scaling", VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION}, + {"VK_EXT_display_control", VK_EXT_DISPLAY_CONTROL_SPEC_VERSION}, + {"VK_GOOGLE_display_timing", VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION}, + {"VK_NV_sample_mask_override_coverage", VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION}, + {"VK_NV_geometry_shader_passthrough", VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION}, + {"VK_NV_viewport_array2", VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION}, + {"VK_NVX_multiview_per_view_attributes", VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION}, + {"VK_NV_viewport_swizzle", VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION}, + {"VK_EXT_discard_rectangles", VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION}, + {"VK_EXT_conservative_rasterization", VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION}, + {"VK_EXT_depth_clip_enable", VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION}, + {"VK_EXT_hdr_metadata", VK_EXT_HDR_METADATA_SPEC_VERSION}, + {"VK_IMG_relaxed_line_rasterization", VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION}, + {"VK_EXT_external_memory_dma_buf", VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION}, + {"VK_EXT_queue_family_foreign", VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"VK_ANDROID_external_memory_android_hardware_buffer", VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION}, +#endif + {"VK_EXT_sampler_filter_minmax", VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION}, + {"VK_AMD_gpu_shader_int16", VK_AMD_GPU_SHADER_INT16_SPEC_VERSION}, +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"VK_AMDX_shader_enqueue", VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION}, +#endif + {"VK_EXT_descriptor_heap", VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION}, + {"VK_AMD_mixed_attachment_samples", VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION}, + {"VK_AMD_shader_fragment_mask", VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION}, + {"VK_EXT_inline_uniform_block", VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION}, + {"VK_EXT_shader_stencil_export", VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION}, + {"VK_EXT_sample_locations", VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION}, + {"VK_EXT_blend_operation_advanced", VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION}, + {"VK_NV_fragment_coverage_to_color", VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION}, + {"VK_NV_framebuffer_mixed_samples", VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION}, + {"VK_NV_fill_rectangle", VK_NV_FILL_RECTANGLE_SPEC_VERSION}, + {"VK_NV_shader_sm_builtins", VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION}, + {"VK_EXT_post_depth_coverage", VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION}, + {"VK_EXT_image_drm_format_modifier", VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION}, + {"VK_EXT_descriptor_indexing", VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION}, + {"VK_EXT_shader_viewport_index_layer", VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION}, + {"VK_NV_shading_rate_image", VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION}, + {"VK_NV_ray_tracing", VK_NV_RAY_TRACING_SPEC_VERSION}, + {"VK_NV_representative_fragment_test", VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION}, + {"VK_EXT_filter_cubic", VK_EXT_FILTER_CUBIC_SPEC_VERSION}, + {"VK_QCOM_render_pass_shader_resolve", VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION}, + {"VK_QCOM_cooperative_matrix_conversion", VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION}, + {"VK_EXT_global_priority", VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION}, + {"VK_EXT_external_memory_host", VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION}, + {"VK_AMD_buffer_marker", VK_AMD_BUFFER_MARKER_SPEC_VERSION}, + {"VK_AMD_pipeline_compiler_control", VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION}, + {"VK_EXT_calibrated_timestamps", VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION}, + {"VK_AMD_shader_core_properties", VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION}, + {"VK_AMD_memory_overallocation_behavior", VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION}, + {"VK_EXT_vertex_attribute_divisor", VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_GGP + {"VK_GGP_frame_token", VK_GGP_FRAME_TOKEN_SPEC_VERSION}, +#endif + {"VK_EXT_pipeline_creation_feedback", VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION}, + {"VK_NV_shader_subgroup_partitioned", VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION}, + {"VK_NV_compute_shader_derivatives", VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION}, + {"VK_NV_mesh_shader", VK_NV_MESH_SHADER_SPEC_VERSION}, + {"VK_NV_fragment_shader_barycentric", VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION}, + {"VK_NV_shader_image_footprint", VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION}, + {"VK_NV_scissor_exclusive", VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION}, + {"VK_NV_device_diagnostic_checkpoints", VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION}, + {"VK_EXT_present_timing", VK_EXT_PRESENT_TIMING_SPEC_VERSION}, + {"VK_INTEL_shader_integer_functions2", VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION}, + {"VK_INTEL_performance_query", VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION}, + {"VK_EXT_pci_bus_info", VK_EXT_PCI_BUS_INFO_SPEC_VERSION}, + {"VK_AMD_display_native_hdr", VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION}, + {"VK_EXT_fragment_density_map", VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION}, + {"VK_EXT_scalar_block_layout", VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION}, + {"VK_GOOGLE_hlsl_functionality1", VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION}, + {"VK_GOOGLE_decorate_string", VK_GOOGLE_DECORATE_STRING_SPEC_VERSION}, + {"VK_EXT_subgroup_size_control", VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION}, + {"VK_AMD_shader_core_properties2", VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION}, + {"VK_AMD_device_coherent_memory", VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION}, + {"VK_EXT_shader_image_atomic_int64", VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION}, + {"VK_EXT_memory_budget", VK_EXT_MEMORY_BUDGET_SPEC_VERSION}, + {"VK_EXT_memory_priority", VK_EXT_MEMORY_PRIORITY_SPEC_VERSION}, + {"VK_NV_dedicated_allocation_image_aliasing", VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION}, + {"VK_EXT_buffer_device_address", VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION}, + {"VK_EXT_tooling_info", VK_EXT_TOOLING_INFO_SPEC_VERSION}, + {"VK_EXT_separate_stencil_usage", VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION}, + {"VK_NV_cooperative_matrix", VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION}, + {"VK_NV_coverage_reduction_mode", VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION}, + {"VK_EXT_fragment_shader_interlock", VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION}, + {"VK_EXT_ycbcr_image_arrays", VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION}, + {"VK_EXT_provoking_vertex", VK_EXT_PROVOKING_VERTEX_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_EXT_full_screen_exclusive", VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION}, +#endif + {"VK_EXT_line_rasterization", VK_EXT_LINE_RASTERIZATION_SPEC_VERSION}, + {"VK_EXT_shader_atomic_float", VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION}, + {"VK_EXT_host_query_reset", VK_EXT_HOST_QUERY_RESET_SPEC_VERSION}, + {"VK_EXT_index_type_uint8", VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION}, + {"VK_EXT_extended_dynamic_state", VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION}, + {"VK_EXT_host_image_copy", VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION}, + {"VK_EXT_map_memory_placed", VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION}, + {"VK_EXT_shader_atomic_float2", VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION}, + {"VK_EXT_swapchain_maintenance1", VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION}, + {"VK_EXT_shader_demote_to_helper_invocation", VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION}, + {"VK_NV_device_generated_commands", VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION}, + {"VK_NV_inherited_viewport_scissor", VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION}, + {"VK_EXT_texel_buffer_alignment", VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION}, + {"VK_QCOM_render_pass_transform", VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION}, + {"VK_EXT_depth_bias_control", VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION}, + {"VK_EXT_device_memory_report", VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION}, + {"VK_EXT_robustness2", VK_EXT_ROBUSTNESS_2_SPEC_VERSION}, + {"VK_EXT_custom_border_color", VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION}, + {"VK_EXT_texture_compression_astc_3d", VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION}, + {"VK_GOOGLE_user_type", VK_GOOGLE_USER_TYPE_SPEC_VERSION}, + {"VK_NV_present_barrier", VK_NV_PRESENT_BARRIER_SPEC_VERSION}, + {"VK_EXT_private_data", VK_EXT_PRIVATE_DATA_SPEC_VERSION}, + {"VK_EXT_pipeline_creation_cache_control", VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION}, + {"VK_NV_device_diagnostics_config", VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION}, + {"VK_QCOM_render_pass_store_ops", VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION}, + {"VK_QCOM_queue_perf_hint", VK_QCOM_QUEUE_PERF_HINT_SPEC_VERSION}, +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"VK_NV_cuda_kernel_launch", VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION}, +#endif + {"VK_QCOM_tile_shading", VK_QCOM_TILE_SHADING_SPEC_VERSION}, + {"VK_NV_low_latency", VK_NV_LOW_LATENCY_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_METAL_EXT + {"VK_EXT_metal_objects", VK_EXT_METAL_OBJECTS_SPEC_VERSION}, +#endif + {"VK_EXT_descriptor_buffer", VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION}, + {"VK_EXT_graphics_pipeline_library", VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION}, + {"VK_AMD_shader_early_and_late_fragment_tests", VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION}, + {"VK_NV_fragment_shading_rate_enums", VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION}, + {"VK_NV_ray_tracing_motion_blur", VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION}, + {"VK_EXT_ycbcr_2plane_444_formats", VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION}, + {"VK_EXT_fragment_density_map2", VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION}, + {"VK_QCOM_rotated_copy_commands", VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION}, + {"VK_EXT_image_robustness", VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION}, + {"VK_EXT_image_compression_control", VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION}, + {"VK_EXT_attachment_feedback_loop_layout", VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION}, + {"VK_EXT_4444_formats", VK_EXT_4444_FORMATS_SPEC_VERSION}, + {"VK_EXT_device_fault", VK_EXT_DEVICE_FAULT_SPEC_VERSION}, + {"VK_ARM_rasterization_order_attachment_access", VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION}, + {"VK_EXT_rgba10x6_formats", VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"VK_NV_acquire_winrt_display", VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION}, +#endif + {"VK_VALVE_mutable_descriptor_type", VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION}, + {"VK_EXT_vertex_input_dynamic_state", VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION}, + {"VK_EXT_physical_device_drm", VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION}, + {"VK_EXT_device_address_binding_report", VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION}, + {"VK_EXT_depth_clip_control", VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION}, + {"VK_EXT_primitive_topology_list_restart", VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION}, + {"VK_EXT_present_mode_fifo_latest_ready", VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_FUCHSIA + {"VK_FUCHSIA_external_memory", VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"VK_FUCHSIA_external_semaphore", VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"VK_FUCHSIA_buffer_collection", VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION}, +#endif + {"VK_HUAWEI_subpass_shading", VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION}, + {"VK_HUAWEI_invocation_mask", VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION}, + {"VK_NV_external_memory_rdma", VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION}, + {"VK_EXT_pipeline_properties", VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION}, + {"VK_EXT_frame_boundary", VK_EXT_FRAME_BOUNDARY_SPEC_VERSION}, + {"VK_EXT_multisampled_render_to_single_sampled", VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION}, + {"VK_EXT_extended_dynamic_state2", VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION}, + {"VK_EXT_color_write_enable", VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION}, + {"VK_EXT_primitives_generated_query", VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION}, + {"VK_EXT_global_priority_query", VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION}, + {"VK_VALVE_video_encode_rgb_conversion", VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION}, + {"VK_EXT_image_view_min_lod", VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION}, + {"VK_EXT_multi_draw", VK_EXT_MULTI_DRAW_SPEC_VERSION}, + {"VK_EXT_image_2d_view_of_3d", VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION}, + {"VK_EXT_shader_tile_image", VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION}, + {"VK_EXT_opacity_micromap", VK_EXT_OPACITY_MICROMAP_SPEC_VERSION}, +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"VK_NV_displacement_micromap", VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION}, +#endif + {"VK_EXT_load_store_op_none", VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION}, + {"VK_HUAWEI_cluster_culling_shader", VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION}, + {"VK_EXT_border_color_swizzle", VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION}, + {"VK_EXT_pageable_device_local_memory", VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION}, + {"VK_ARM_shader_core_properties", VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION}, + {"VK_ARM_scheduling_controls", VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION}, + {"VK_EXT_image_sliced_view_of_3d", VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION}, + {"VK_VALVE_descriptor_set_host_mapping", VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION}, + {"VK_EXT_depth_clamp_zero_one", VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION}, + {"VK_EXT_non_seamless_cube_map", VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION}, + {"VK_ARM_render_pass_striped", VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION}, + {"VK_QCOM_fragment_density_map_offset", VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION}, + {"VK_NV_copy_memory_indirect", VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION}, + {"VK_NV_memory_decompression", VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION}, + {"VK_NV_device_generated_commands_compute", VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION}, + {"VK_NV_ray_tracing_linear_swept_spheres", VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION}, + {"VK_NV_linear_color_attachment", VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION}, + {"VK_EXT_image_compression_control_swapchain", VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION}, + {"VK_QCOM_image_processing", VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION}, + {"VK_EXT_nested_command_buffer", VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_OHOS + {"VK_OHOS_external_memory", VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION}, +#endif + {"VK_EXT_external_memory_acquire_unmodified", VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION}, + {"VK_EXT_extended_dynamic_state3", VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION}, + {"VK_EXT_subpass_merge_feedback", VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION}, + {"VK_ARM_tensors", VK_ARM_TENSORS_SPEC_VERSION}, + {"VK_EXT_shader_module_identifier", VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION}, + {"VK_EXT_rasterization_order_attachment_access", VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION}, + {"VK_NV_optical_flow", VK_NV_OPTICAL_FLOW_SPEC_VERSION}, + {"VK_EXT_legacy_dithering", VK_EXT_LEGACY_DITHERING_SPEC_VERSION}, + {"VK_EXT_pipeline_protected_access", VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"VK_ANDROID_external_format_resolve", VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION}, +#endif + {"VK_AMD_anti_lag", VK_AMD_ANTI_LAG_SPEC_VERSION}, +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"VK_AMDX_dense_geometry_format", VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION}, +#endif + {"VK_EXT_shader_object", VK_EXT_SHADER_OBJECT_SPEC_VERSION}, + {"VK_QCOM_tile_properties", VK_QCOM_TILE_PROPERTIES_SPEC_VERSION}, + {"VK_SEC_amigo_profiling", VK_SEC_AMIGO_PROFILING_SPEC_VERSION}, + {"VK_QCOM_multiview_per_view_viewports", VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION}, + {"VK_NV_ray_tracing_invocation_reorder", VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION}, + {"VK_NV_cooperative_vector", VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION}, + {"VK_NV_extended_sparse_address_space", VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION}, + {"VK_EXT_mutable_descriptor_type", VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION}, + {"VK_EXT_legacy_vertex_attributes", VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION}, + {"VK_ARM_shader_core_builtins", VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION}, + {"VK_EXT_pipeline_library_group_handles", VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION}, + {"VK_EXT_dynamic_rendering_unused_attachments", VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION}, + {"VK_NV_low_latency2", VK_NV_LOW_LATENCY_2_SPEC_VERSION}, + {"VK_ARM_data_graph", VK_ARM_DATA_GRAPH_SPEC_VERSION}, + {"VK_ARM_data_graph_instruction_set_tosa", VK_ARM_DATA_GRAPH_INSTRUCTION_SET_TOSA_SPEC_VERSION}, + {"VK_QCOM_multiview_per_view_render_areas", VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION}, + {"VK_NV_per_stage_descriptor_set", VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION}, + {"VK_QCOM_image_processing2", VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION}, + {"VK_QCOM_filter_cubic_weights", VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION}, + {"VK_QCOM_ycbcr_degamma", VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION}, + {"VK_QCOM_filter_cubic_clamp", VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION}, + {"VK_EXT_attachment_feedback_loop_dynamic_state", VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"VK_QNX_external_memory_screen_buffer", VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION}, +#endif + {"VK_MSFT_layered_driver", VK_MSFT_LAYERED_DRIVER_SPEC_VERSION}, + {"VK_NV_descriptor_pool_overallocation", VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION}, + {"VK_QCOM_tile_memory_heap", VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION}, + {"VK_EXT_memory_decompression", VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION}, + {"VK_NV_raw_access_chains", VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION}, + {"VK_NV_external_compute_queue", VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION}, + {"VK_NV_command_buffer_inheritance", VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION}, + {"VK_NV_shader_atomic_float16_vector", VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION}, + {"VK_EXT_shader_replicated_composites", VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION}, + {"VK_EXT_shader_float8", VK_EXT_SHADER_FLOAT8_SPEC_VERSION}, + {"VK_NV_ray_tracing_validation", VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION}, + {"VK_NV_cluster_acceleration_structure", VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION}, + {"VK_NV_partitioned_acceleration_structure", VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION}, + {"VK_EXT_device_generated_commands", VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION}, + {"VK_MESA_image_alignment_control", VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION}, + {"VK_NV_push_constant_bank", VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION}, + {"VK_EXT_ray_tracing_invocation_reorder", VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION}, + {"VK_EXT_depth_clamp_control", VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION}, + {"VK_HUAWEI_hdr_vivid", VK_HUAWEI_HDR_VIVID_SPEC_VERSION}, + {"VK_NV_cooperative_matrix2", VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION}, + {"VK_ARM_pipeline_opacity_micromap", VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION}, +#ifdef VK_USE_PLATFORM_METAL_EXT + {"VK_EXT_external_memory_metal", VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION}, +#endif + {"VK_ARM_performance_counters_by_region", VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION}, + {"VK_ARM_shader_instrumentation", VK_ARM_SHADER_INSTRUMENTATION_SPEC_VERSION}, + {"VK_EXT_vertex_attribute_robustness", VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION}, + {"VK_ARM_format_pack", VK_ARM_FORMAT_PACK_SPEC_VERSION}, + {"VK_VALVE_fragment_density_map_layered", VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION}, + {"VK_NV_present_metering", VK_NV_PRESENT_METERING_SPEC_VERSION}, + {"VK_EXT_fragment_density_map_offset", VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION}, + {"VK_EXT_zero_initialize_device_memory", VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION}, + {"VK_EXT_shader_64bit_indexing", VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION}, + {"VK_EXT_custom_resolve", VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION}, + {"VK_QCOM_data_graph_model", VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION}, + {"VK_ARM_data_graph_optical_flow", VK_ARM_DATA_GRAPH_OPTICAL_FLOW_SPEC_VERSION}, + {"VK_EXT_shader_long_vector", VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION}, + {"VK_SEC_pipeline_cache_incremental_mode", VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION}, + {"VK_EXT_shader_uniform_buffer_unsized_array", VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION}, + {"VK_NV_compute_occupancy_priority", VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION}, + {"VK_EXT_shader_subgroup_partitioned", VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION}, + {"VK_VALVE_shader_mixed_float_dot_product", VK_VALVE_SHADER_MIXED_FLOAT_DOT_PRODUCT_SPEC_VERSION}, + {"VK_SEC_throttle_hint", VK_SEC_THROTTLE_HINT_SPEC_VERSION}, + {"VK_ARM_data_graph_neural_accelerator_statistics", VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_SPEC_VERSION}, + {"VK_EXT_primitive_restart_index", VK_EXT_PRIMITIVE_RESTART_INDEX_SPEC_VERSION}, + {"VK_KHR_acceleration_structure", VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION}, + {"VK_KHR_ray_tracing_pipeline", VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION}, + {"VK_KHR_ray_query", VK_KHR_RAY_QUERY_SPEC_VERSION}, + {"VK_EXT_mesh_shader", VK_EXT_MESH_SHADER_SPEC_VERSION}, }; +static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); -static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance); +static VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); -static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties* pFormatProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkImageType type, VkImageTiling tiling, + VkImageUsageFlags usage, VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties); +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* pName); -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( - VkInstance instance, - const char* pName); +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* pName); -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( - VkDevice device, - const char* pName); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); -static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice); +static VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, + VkLayerProperties* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue); +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence); +static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue); -static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( - VkQueue queue); +static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device); -static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( - VkDevice device); +static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); -static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( - VkDevice device, - const VkMemoryAllocateInfo* pAllocateInfo, - const VkAllocationCallbacks* pAllocator, - VkDeviceMemory* pMemory); +static VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL FreeMemory( - VkDevice device, - VkDeviceMemory memory, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, + VkMemoryMapFlags flags, void** ppData); -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); +static VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory); -static VKAPI_ATTR void VKAPI_CALL UnmapMemory( - VkDevice device, - VkDeviceMemory memory); +static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); -static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); +static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); -static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); +static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); -static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes); +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, + VkDeviceSize memoryOffset); -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, + VkDeviceSize memoryOffset); -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, + VkMemoryRequirements* pMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkImageType type, VkSampleCountFlagBits samples, + VkImageUsageFlags usage, VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, + VkFence fence); -static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( - VkQueue queue, - uint32_t bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence); +static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkFence* pFence); -static VKAPI_ATTR VkResult VKAPI_CALL CreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); +static VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyFence( - VkDevice device, - VkFence fence, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -static VKAPI_ATTR VkResult VKAPI_CALL ResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence); -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( - VkDevice device, - VkFence fence); +static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, + uint64_t timeout); -static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout); +static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); -static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore); +static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); -static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent); +static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, + VkQueryResultFlags flags); -static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( - VkDevice device, - VkEvent event); +static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); -static VKAPI_ATTR VkResult VKAPI_CALL SetEvent( - VkDevice device, - VkEvent event); +static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( - VkDevice device, - VkEvent event); +static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkImage* pImage); -static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool); +static VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); -static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void* pData, - VkDeviceSize stride, - VkQueryResultFlags flags); +static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkImageView* pView); -static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBuffer* pBuffer); +static VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyBuffer( - VkDevice device, - VkBuffer buffer, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); -static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView); +static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); -static VKAPI_ATTR VkResult VKAPI_CALL CreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImage* pImage); +static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); -static VKAPI_ATTR void VKAPI_CALL DestroyImage( - VkDevice device, - VkImage image, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); +static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImageView* pView); +static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer); -static VKAPI_ATTR void VKAPI_CALL DestroyImageView( - VkDevice device, - VkImageView imageView, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); -static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkShaderModule* pShaderModule); +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, + uint32_t regionCount, const VkBufferCopy* pRegions); -static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageCopy* pRegions); -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache); +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkBufferImageCopy* pRegions); -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, + VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, + const VkBufferImageCopy* pRegions); -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - size_t* pDataSize, - void* pData); +static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, + VkDeviceSize dataSize, const void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); +static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, + VkDeviceSize size, uint32_t data); -static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); -static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); +static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, + VkQueryControlFlags flags); -static VKAPI_ATTR void VKAPI_CALL DestroyPipeline( - VkDevice device, - VkPipeline pipeline, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout); +static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount); -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, uint32_t query); -static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler); +static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, + VkDeviceSize stride, VkQueryResultFlags flags); -static VKAPI_ATTR void VKAPI_CALL DestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout); +static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool); +static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event); -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event); -static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags); - -static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets); - -static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets); - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( - VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies); +static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event); -static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer); +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkBufferView* pView); -static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); -static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); -static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool); +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, + void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags); +static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); -static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers); +static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( - VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); +static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); -static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( - VkCommandBuffer commandBuffer); +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags); +static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); -static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); +static VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdSetViewport( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); -static VKAPI_ATTR void VKAPI_CALL CmdSetScissor( - VkCommandBuffer commandBuffer, - uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors); +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( - VkCommandBuffer commandBuffer, - float lineWidth); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( - VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor); +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( - VkCommandBuffer commandBuffer, - const float blendConstants[4]); +static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( - VkCommandBuffer commandBuffer, - float minDepthBounds, - float maxDepthBounds); +static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t compareMask); +static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t writeMask); +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t reference); +static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); -static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); +static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, + const VkClearColorValue* pColor, uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); -static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); +static VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ); -static VKAPI_ATTR void VKAPI_CALL CmdDraw( - VkCommandBuffer commandBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance); +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -static VKAPI_ATTR void VKAPI_CALL CmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, + VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, + const void* pValues); -static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset); +static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); +static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); +static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkFilter filter); +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); +static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); +static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData); +static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, + const VkViewport* pViewports); -static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data); +static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, + const VkRect2D* pScissors); -static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); +static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth); -static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, + float depthBiasClamp, float depthBiasSlopeFactor); -static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment* pAttachments, - uint32_t rectCount, - const VkClearRect* pRects); +static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]); -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, + uint32_t compareMask); -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, + uint32_t writeMask); -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, + uint32_t reference); -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkIndexType indexType); -static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags); +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, + const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -static VKAPI_ATTR void VKAPI_CALL CmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query); +static VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, + uint32_t firstVertex, uint32_t firstInstance); -static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, + uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL CmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues); +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageBlit* pRegions, VkFilter filter); -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkSubpassContents contents); +static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( - VkCommandBuffer commandBuffer, - VkSubpassContents contents); +static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, + const VkClearAttachment* pAttachments, uint32_t rectCount, + const VkClearRect* pRects); -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( - VkCommandBuffer commandBuffer); +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageResolve* pRegions); -static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion( - uint32_t* pApiVersion); +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer); -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(uint32_t* pApiVersion); -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); -static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(VkDevice device, uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); -static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2* pFormatProperties); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); +static VKAPI_ATTR VkResult VKAPI_CALL +GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); -static VKAPI_ATTR void VKAPI_CALL TrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); +static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( - VkDevice device, - const VkDeviceQueueInfo2* pQueueInfo, - VkQueue* pQueue); - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); - -static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, + uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo); +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo); +static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -static VKAPI_ATTR void VKAPI_CALL ResetQueryPool( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue); +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); -static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout); +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); -static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo); +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); -static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, uint32_t stride); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties); +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot); +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); -static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); -static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data); +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); -static VKAPI_ATTR void VKAPI_CALL GetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask); +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos); +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t data); -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo); +static VKAPI_ATTR void VKAPI_CALL GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t* pData); -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query); +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence); +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, + VkQueryPool queryPool, uint32_t query); -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo); +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, + VkFence fence); -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo); +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdEndRendering( - VkCommandBuffer commandBuffer); - -static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode); - -static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace); - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology); - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports); - -static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors); - -static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp); - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable); - -static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, + const VkDependencyInfo* pDependencyInfo); -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStipple( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2( - VkDevice device, - const VkMemoryMapInfo* pMemoryMapInfo, - void** ppData); +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); -static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2( - VkDevice device, - const VkMemoryUnmapInfo* pMemoryUnmapInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); -static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkDeviceSize size, - VkIndexType indexType); +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); -static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularity( - VkDevice device, - const VkRenderingAreaInfo* pRenderingAreaInfo, - VkExtent2D* pGranularity); +static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayout( - VkDevice device, - const VkDeviceImageSubresourceInfo* pInfo, - VkSubresourceLayout2* pLayout); +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering(VkCommandBuffer commandBuffer); -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout); +static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites); +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace); -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData); +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); -static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocations( - VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo* pLocationInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, + const VkViewport* pViewports); -static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndices( - VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, + const VkRect2D* pScissors); -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2( - VkCommandBuffer commandBuffer, - const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, + const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); -static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2( - VkCommandBuffer commandBuffer, - const VkPushConstantsInfo* pPushConstantsInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, + VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); + +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, + VkSubresourceLayout2* pLayout); + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2(VkDevice device, VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayout(VkDevice device, uint32_t transitionCount, + const VkHostImageLayoutTransitionInfo* pTransitions); + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, uint32_t set, const void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImage( - VkDevice device, - const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, + uint16_t lineStipplePattern); -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemory( - VkDevice device, - const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkDeviceSize size, VkIndexType indexType); -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImage( - VkDevice device, - const VkCopyImageToImageInfo* pCopyImageToImageInfo); +static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, + VkExtent2D* pGranularity); -static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayout( - VkDevice device, - uint32_t transitionCount, - const VkHostImageLayoutTransitionInfo* pTransitions); +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo* pLocationInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndices( + VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); -static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + VkSurfaceKHR surface, VkBool32* pSupported); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); -static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain); +static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pSwapchainImageCount, - VkImage* pSwapchainImages); +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, + VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); -static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t timeout, - VkSemaphore semaphore, - VkFence fence, - uint32_t* pImageIndex); +static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); -static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo); +static VKAPI_ATTR VkResult VKAPI_CALL +GetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pRectCount, VkRect2D* pRects); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects); +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); -static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - uint32_t* pImageIndex); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPropertiesKHR* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, + uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlanePropertiesKHR* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( - VkPhysicalDevice physicalDevice, - uint32_t planeIndex, - uint32_t* pDisplayCount, - VkDisplayKHR* pDisplays); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModePropertiesKHR* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); -static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDisplayModeKHR* pMode); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR* pCapabilities); - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchains); - +static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); #ifdef VK_USE_PLATFORM_XLIB_KHR -static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( - VkInstance instance, - const VkXlibSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - Display* dpy, - VisualID visualID); +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, Display* dpy, + VisualID visualID); #endif /* VK_USE_PLATFORM_XLIB_KHR */ #ifdef VK_USE_PLATFORM_XCB_KHR +static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( - VkInstance instance, - const VkXcbSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t* connection, - xcb_visualid_t visual_id); +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); #endif /* VK_USE_PLATFORM_XCB_KHR */ #ifdef VK_USE_PLATFORM_WAYLAND_KHR +static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( - VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display* display); +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ #ifdef VK_USE_PLATFORM_ANDROID_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( - VkInstance instance, - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif /* VK_USE_PLATFORM_ANDROID_KHR */ #ifdef VK_USE_PLATFORM_WIN32_KHR +static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( - VkInstance instance, - const VkWin32SurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex); +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); #endif /* VK_USE_PLATFORM_WIN32_KHR */ - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - const VkVideoProfileInfoKHR* pVideoProfile, - VkVideoCapabilitiesKHR* pCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities); static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, - uint32_t* pVideoFormatPropertyCount, - VkVideoFormatPropertiesKHR* pVideoFormatProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); -static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR( - VkDevice device, - const VkVideoSessionCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionKHR* pVideoSession); +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession); -static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t* pMemoryRequirementsCount, - VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +static VKAPI_ATTR VkResult VKAPI_CALL +GetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); -static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t bindSessionMemoryInfoCount, - const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); -static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR( - VkDevice device, - const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionParametersKHR* pVideoSessionParameters); +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR(VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters); -static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR(VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); -static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR(VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoBeginCodingInfoKHR* pBeginInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo); -static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoEndCodingInfoKHR* pEndCodingInfo); +static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo); -static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoCodingControlInfoKHR* pCodingControlInfo); +static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); -static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoDecodeInfoKHR* pDecodeInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(VkCommandBuffer commandBuffer); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR( - VkCommandBuffer commandBuffer); - - - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2* pFormatProperties); static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, + uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask); -static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, + uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ); -static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - - - -static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); - +static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - + VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); - - + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); #ifdef VK_USE_PLATFORM_WIN32_KHR -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( - VkDevice device, - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); #endif /* VK_USE_PLATFORM_WIN32_KHR */ +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( - VkDevice device, - const VkMemoryGetFdInfoKHR* pGetFdInfo, - int* pFd); - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - int fd, - VkMemoryFdPropertiesKHR* pMemoryFdProperties); - -#ifdef VK_USE_PLATFORM_WIN32_KHR -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, + int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - - + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); #ifdef VK_USE_PLATFORM_WIN32_KHR -static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +static VKAPI_ATTR VkResult VKAPI_CALL +ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( - VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); #endif /* VK_USE_PLATFORM_WIN32_KHR */ +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); -static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( - VkDevice device, - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( - VkDevice device, - const VkSemaphoreGetFdInfoKHR* pGetFdInfo, - int* pFd); +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, uint32_t set, const void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites); +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData); +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo); - - -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain); - +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); - - + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); #ifdef VK_USE_PLATFORM_WIN32_KHR -static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( - VkDevice device, - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( - VkDevice device, - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); #endif /* VK_USE_PLATFORM_WIN32_KHR */ +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); - -static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( - VkDevice device, - const VkImportFenceFdInfoKHR* pImportFenceFdInfo); - -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( - VkDevice device, - const VkFenceGetFdInfoKHR* pGetFdInfo, - int* pFd); - +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t* pCounterCount, - VkPerformanceCounterKHR* pCounters, - VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - VkPhysicalDevice physicalDevice, - const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, - uint32_t* pNumPasses); + VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); -static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR( - VkDevice device, - const VkAcquireProfilingLockInfoKHR* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); -static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR( - VkDevice device); +static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(VkDevice device); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayProperties2KHR* pProperties); +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlaneProperties2KHR* pProperties); +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModeProperties2KHR* pProperties); +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR* pCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); +static VKAPI_ATTR VkResult VKAPI_CALL +GetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); -static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); - -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); - -#ifdef VK_ENABLE_BETA_EXTENSIONS -#endif /* VK_ENABLE_BETA_EXTENSIONS */ - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - - - - - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue); - -static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout); - -static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo); - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pFragmentShadingRateCount, - VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); - -static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR( - VkCommandBuffer commandBuffer, - const VkExtent2D* pFragmentSize, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - - -static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR( - VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo* pLocationInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo* pLocationInfo); static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndicesKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); + VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, + uint64_t timeout); +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation); -static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t presentId, - uint64_t timeout); +static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation); +static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation); -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation); -static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties); -static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR( - VkDevice device, - const VkAllocationCallbacks* pAllocator, - VkDeferredOperationKHR* pDeferredOperation); - -static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR( - VkDevice device, - VkDeferredOperationKHR operation, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR( - VkDevice device, - VkDeferredOperationKHR operation); - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR( - VkDevice device, - VkDeferredOperationKHR operation); - -static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR( - VkDevice device, - VkDeferredOperationKHR operation); - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( - VkDevice device, - const VkPipelineInfoKHR* pPipelineInfo, - uint32_t* pExecutableCount, - VkPipelineExecutablePropertiesKHR* pProperties); - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pStatisticCount, - VkPipelineExecutableStatisticKHR* pStatistics); +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics); static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pInternalRepresentationCount, + VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR( - VkDevice device, - const VkMemoryMapInfo* pMemoryMapInfo, - void** ppData); - -static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR( - VkDevice device, - const VkMemoryUnmapInfo* pMemoryUnmapInfo); - - - - - +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, - VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); -static VKAPI_ATTR VkResult VKAPI_CALL GetEncodedVideoSessionParametersKHR( - VkDevice device, - const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, - VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, - size_t* pDataSize, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL +GetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); -static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoEncodeInfoKHR* pEncodeInfo); +static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, + const VkDependencyInfo* pDependencyInfo); -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo); +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask); +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos); +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo); +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, + VkQueryPool queryPool, uint32_t query); -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query); +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, + VkFence fence); -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence); +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer3KHR(VkCommandBuffer commandBuffer, const VkBindIndexBuffer3InfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers3KHR(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, const VkBindVertexBuffer3InfoKHR* pBindingInfos); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect2KHR(VkCommandBuffer commandBuffer, const VkDispatchIndirect2InfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo); -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageKHR(VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToMemoryKHR(VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdUpdateMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, VkDeviceSize dataSize, const void* pData); -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +static VKAPI_ATTR void VKAPI_CALL CmdFillMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, uint32_t data); -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResultsToMemoryKHR(VkCommandBuffer commandBuffer, VkQueryPool queryPool, + uint32_t firstQuery, uint32_t queryCount, + const VkStridedDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkQueryResultFlags queryResultFlags); -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount2KHR(VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRendering2EXT( + VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin); -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectDeviceAddress); +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos); +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); -static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCount2EXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, + uint32_t firstInstance, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo, + uint32_t counterOffset, uint32_t vertexStride); -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirect2EXT(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCount2EXT(VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteMarkerToMemoryAMD(VkCommandBuffer commandBuffer, const VkMemoryMarkerInfoAMD* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructure2KHR(VkDevice device, + const VkAccelerationStructureCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkDeviceSize size, VkIndexType indexType); +static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, + VkExtent2D* pGranularity); +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, + VkSubresourceLayout2* pLayout); -static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkDeviceSize size, - VkIndexType indexType); +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR(VkDevice device, VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout); -static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR( - VkDevice device, - const VkRenderingAreaInfo* pRenderingAreaInfo, - VkExtent2D* pGranularity); +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, + const VkPresentWait2InfoKHR* pPresentWait2Info); -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR( - VkDevice device, - const VkDeviceImageSubresourceInfo* pInfo, - VkSubresourceLayout2* pLayout); +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineBinaryHandlesInfoKHR* pBinaries); -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout); +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, + VkPipelineBinaryKeyKHR* pPipelineKey); +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, + VkPipelineBinaryKeyKHR* pPipelineBinaryKey, + size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData); -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR( - VkDevice device, - const VkPipelineBinaryCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineBinaryHandlesInfoKHR* pBinaries); +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR(VkDevice device, + const VkReleaseCapturedPipelineDataInfoKHR* pInfo, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR( - VkDevice device, - VkPipelineBinaryKHR pipelineBinary, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR( - VkDevice device, - const VkPipelineCreateInfoKHR* pPipelineCreateInfo, - VkPipelineBinaryKeyKHR* pPipelineKey); - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR( - VkDevice device, - const VkPipelineBinaryDataInfoKHR* pInfo, - VkPipelineBinaryKeyKHR* pPipelineBinaryKey, - size_t* pPipelineBinaryDataSize, - void* pPipelineBinaryData); - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR( - VkDevice device, - const VkReleaseCapturedPipelineDataInfoKHR* pInfo, - const VkAllocationCallbacks* pAllocator); - +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesKHR(VkDevice device, + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesKHR* pProperties); + VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, + uint16_t lineStipplePattern); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains); +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, uint64_t* pMaxDeviation); +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfo* pPushConstantsInfo); - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainKHR* pTimeDomains); - -static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation); - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR( - VkCommandBuffer commandBuffer, - const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR( - VkCommandBuffer commandBuffer, - const VkPushConstantsInfo* pPushConstantsInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( - VkCommandBuffer commandBuffer, - const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( - VkCommandBuffer commandBuffer, - const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, + const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectKHR( + VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultReportsKHR(VkDevice device, uint64_t timeout, uint32_t* pFaultCounts, + VkDeviceFaultInfoKHR* pFaultInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultDebugInfoKHR(VkDevice device, VkDeviceFaultDebugInfoKHR* pDebugInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( - VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugReportCallbackEXT* pCallback); +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2KHR(VkCommandBuffer commandBuffer, + const VkRenderingEndInfoKHR* pRenderingEndInfo); -static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( - VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); -static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( - VkInstance instance, - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage); +static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, + int32_t messageCode, const char* pLayerPrefix, const char* pMessage); +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer); +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); -static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( - VkDevice device, - const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, + uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); -static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( - VkDevice device, - const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, + uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, + VkQueryControlFlags flags, uint32_t index); -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( - VkCommandBuffer commandBuffer); +static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, + uint32_t index); -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, + uint32_t firstInstance, VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, uint32_t counterOffset, + uint32_t vertexStride); +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); +static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes); +static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets); +static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); -static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets); +static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); -static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags, - uint32_t index); +static VKAPI_ATTR uint64_t VKAPI_CALL GetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); -static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - uint32_t index); +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(VkDevice device, VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties); -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT( - VkCommandBuffer commandBuffer, - uint32_t instanceCount, - uint32_t firstInstance, - VkBuffer counterBuffer, - VkDeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride); +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, + uint64_t samplerIndex); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, uint32_t stride); -static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX( - VkDevice device, - const VkCuModuleCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuModuleNVX* pModule); +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride); -static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX( - VkDevice device, - const VkCuFunctionCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuFunctionNVX* pFunction); - -static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX( - VkDevice device, - VkCuModuleNVX module, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX( - VkDevice device, - VkCuFunctionNVX function, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX( - VkCommandBuffer commandBuffer, - const VkCuLaunchInfoNVX* pLaunchInfo); - - -static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo); - -static VKAPI_ATTR uint64_t VKAPI_CALL GetImageViewHandle64NVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo); - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( - VkDevice device, - VkImageView imageView, - VkImageViewAddressPropertiesNVX* pProperties); - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( - VkDevice device, - VkPipeline pipeline, - VkShaderStageFlagBits shaderStage, - VkShaderInfoTypeAMD infoType, - size_t* pInfoSize, - void* pInfo); - - +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); #ifdef VK_USE_PLATFORM_GGP -static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( - VkInstance instance, - const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); #endif /* VK_USE_PLATFORM_GGP */ - - - - static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); - - + VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, + VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); #ifdef VK_USE_PLATFORM_WIN32_KHR -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - HANDLE* pHandle); +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); #endif /* VK_USE_PLATFORM_WIN32_KHR */ -#ifdef VK_USE_PLATFORM_WIN32_KHR -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - #ifdef VK_USE_PLATFORM_VI_NN - -static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( - VkInstance instance, - const VkViSurfaceCreateInfoNN* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif /* VK_USE_PLATFORM_VI_NN */ - - - - - - - static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( - VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); + VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); -static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( - VkCommandBuffer commandBuffer); +static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer); +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, + uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportWScalingNV* pViewportWScalings); - - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); - +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display); #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - VkDisplayKHR display); +static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); -static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - RROutput rrOutput, - VkDisplayKHR* pDisplay); +static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, + VkDisplayKHR* pDisplay); #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, VkFence* pFence); +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, VkFence* pFence); -static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); -static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( - VkDevice device, - const VkDeviceEventInfoEXT* pDeviceEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); +static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); -static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT* pDisplayEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); +static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - uint64_t* pCounterValue); +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); -static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode); -static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings); - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( - VkCommandBuffer commandBuffer, - uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const VkRect2D* pDiscardRectangles); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 discardRectangleEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT( - VkCommandBuffer commandBuffer, - VkDiscardRectangleModeEXT discardRectangleMode); - - - - - -static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainKHR* pSwapchains, - const VkHdrMetadataEXT* pMetadata); - - +static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); #ifdef VK_USE_PLATFORM_IOS_MVK -static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( - VkInstance instance, - const VkIOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif /* VK_USE_PLATFORM_IOS_MVK */ #ifdef VK_USE_PLATFORM_MACOS_MVK - -static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( - VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif /* VK_USE_PLATFORM_MACOS_MVK */ +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(VkQueue queue); -static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( - VkDevice device, - const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( - VkDevice device, - const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); +static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer); -static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( - VkQueue queue); +static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); -static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); -static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); +static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer); - -static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( - VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pMessenger); - -static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( - VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( - VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); - +static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); #ifdef VK_USE_PLATFORM_ANDROID_KHR static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( - VkDevice device, - const struct AHardwareBuffer* buffer, - VkAndroidHardwareBufferPropertiesANDROID* pProperties); + VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( - VkDevice device, - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, - struct AHardwareBuffer** pBuffer); + VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); #endif /* VK_USE_PLATFORM_ANDROID_KHR */ - - #ifdef VK_ENABLE_BETA_EXTENSIONS +static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); -static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX( - VkDevice device, - VkPipeline executionGraph, - VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph, + VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineNodeIndexAMDX( - VkDevice device, - VkPipeline executionGraph, - const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, - uint32_t* pNodeIndex); + VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex); -static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX( - VkCommandBuffer commandBuffer, - VkPipeline executionGraph, - VkDeviceAddress scratch, - VkDeviceSize scratchSize); +static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph, + VkDeviceAddress scratch, VkDeviceSize scratchSize); -static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX* pCountInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, + VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo); -static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX* pCountInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, + VkDeviceSize scratchSize, + const VkDispatchGraphCountInfoAMDX* pCountInfo); -static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - VkDeviceAddress countInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, + VkDeviceSize scratchSize, VkDeviceAddress countInfo); #endif /* VK_ENABLE_BETA_EXTENSIONS */ +static VKAPI_ATTR VkResult VKAPI_CALL WriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount, + const VkSamplerCreateInfo* pSamplers, + const VkHostAddressRangeEXT* pDescriptors); +static VKAPI_ATTR VkResult VKAPI_CALL WriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount, + const VkResourceDescriptorInfoEXT* pResources, + const VkHostAddressRangeEXT* pDescriptors); +static VKAPI_ATTR void VKAPI_CALL CmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo); +static VKAPI_ATTR void VKAPI_CALL CmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages, + VkHostAddressRangeEXT* pDatas); -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( - VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, + VkDescriptorType descriptorType); -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( - VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT* pMultisampleProperties); +static VKAPI_ATTR VkResult VKAPI_CALL RegisterCustomBorderColorEXT(VkDevice device, + const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, + VkBool32 requestIndex, uint32_t* pIndex); +static VKAPI_ATTR void VKAPI_CALL UnregisterCustomBorderColorEXT(VkDevice device, uint32_t index); +static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, + const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas); +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); +static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( - VkDevice device, - VkImage image, - VkImageDrmFormatModifierPropertiesEXT* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, + size_t* pDataSize, void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( - VkDevice device, - const VkValidationCacheCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkValidationCacheEXT* pValidationCache); +static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, + VkImageLayout imageLayout); -static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes); -static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( - VkDevice device, - VkValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const VkValidationCacheEXT* pSrcCaches); +static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); -static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - size_t* pDataSize, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure); - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout); - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkShadingRatePaletteNV* pShadingRatePalettes); - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( - VkCommandBuffer commandBuffer, - VkCoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( - VkDevice device, - const VkAccelerationStructureCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureNV* pAccelerationStructure); - -static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator); static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( - VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements); + VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); -static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( - VkDevice device, - uint32_t bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); -static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV( - VkCommandBuffer commandBuffer, - const VkAccelerationStructureInfoNV* pInfo, - VkBuffer instanceData, - VkDeviceSize instanceOffset, - VkBool32 update, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkBuffer scratch, - VkDeviceSize scratchOffset); +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, + VkDeviceSize instanceOffset, VkBool32 update, + VkAccelerationStructureNV dst, VkAccelerationStructureNV src, + VkBuffer scratch, VkDeviceSize scratchOffset); -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( - VkCommandBuffer commandBuffer, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkCopyAccelerationStructureModeKHR mode); +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode); -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV( - VkCommandBuffer commandBuffer, - VkBuffer raygenShaderBindingTableBuffer, - VkDeviceSize raygenShaderBindingOffset, - VkBuffer missShaderBindingTableBuffer, - VkDeviceSize missShaderBindingOffset, - VkDeviceSize missShaderBindingStride, - VkBuffer hitShaderBindingTableBuffer, - VkDeviceSize hitShaderBindingOffset, - VkDeviceSize hitShaderBindingStride, - VkBuffer callableShaderBindingTableBuffer, - VkDeviceSize callableShaderBindingOffset, - VkDeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth); +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, + uint32_t width, uint32_t height, uint32_t depth); -static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoNV* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, + uint32_t groupCount, size_t dataSize, void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, + uint32_t groupCount, size_t dataSize, void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - size_t dataSize, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, void* pData); static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureNV* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); + VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( - VkDevice device, - VkPipeline pipeline, - uint32_t shader); +static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader); +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains); +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, uint64_t* pMaxDeviation); -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHostPointer, - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker); +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables); +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); +static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainKHR* pTimeDomains); +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData); -static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation); +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData); +static VKAPI_ATTR VkResult VKAPI_CALL SetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, + uint32_t size); +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, + VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, + uint64_t* pSwapchainTimingPropertiesCounter); +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimeDomainPropertiesEXT( + VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, + uint64_t* pTimeDomainsCounter); -#ifdef VK_USE_PLATFORM_GGP -#endif /* VK_USE_PLATFORM_GGP */ +static VKAPI_ATTR VkResult VKAPI_CALL +GetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, + VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties); +static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(VkDevice device); +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV( - VkCommandBuffer commandBuffer, - uint32_t taskCount, - uint32_t firstTask); +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo); -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); +static VKAPI_ATTR VkResult VKAPI_CALL +AcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration); -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); +static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(VkDevice device, + VkPerformanceConfigurationINTEL configuration); +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(VkQueue queue, + VkPerformanceConfigurationINTEL configuration); +static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue); - -static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkBool32* pExclusiveScissorEnables); - -static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkRect2D* pExclusiveScissors); - - -static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( - VkCommandBuffer commandBuffer, - const void* pCheckpointMarker); - -static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointDataNV* pCheckpointData); - -static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointData2NV* pCheckpointData); - - - -static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( - VkDevice device, - const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); - -static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( - VkDevice device); - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceMarkerInfoINTEL* pMarkerInfo); - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceOverrideInfoINTEL* pOverrideInfo); - -static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( - VkDevice device, - const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, - VkPerformanceConfigurationINTEL* pConfiguration); - -static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( - VkDevice device, - VkPerformanceConfigurationINTEL configuration); - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( - VkQueue queue, - VkPerformanceConfigurationINTEL configuration); - -static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( - VkDevice device, - VkPerformanceParameterTypeINTEL parameter, - VkPerformanceValueINTEL* pValue); - - - -static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( - VkDevice device, - VkSwapchainKHR swapChain, - VkBool32 localDimmingEnable); - +static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); #ifdef VK_USE_PLATFORM_FUCHSIA -static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( - VkInstance instance, - const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); #endif /* VK_USE_PLATFORM_FUCHSIA */ #ifdef VK_USE_PLATFORM_METAL_EXT - -static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( - VkInstance instance, - const VkMetalSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif /* VK_USE_PLATFORM_METAL_EXT */ +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); - - - - - - - - - - - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties); - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesNV* pProperties); - +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties); static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - VkPhysicalDevice physicalDevice, - uint32_t* pCombinationCount, - VkFramebufferMixedSamplesCombinationNV* pCombinations); - - - - + VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); #ifdef VK_USE_PLATFORM_WIN32_KHR -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); -static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain); +static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain); -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain); +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain); -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( - VkDevice device, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkDeviceGroupPresentModeFlagsKHR* pModes); +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes); #endif /* VK_USE_PLATFORM_WIN32_KHR */ +static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, + uint16_t lineStipplePattern); -static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( - VkInstance instance, - const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount); +static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, + const VkViewport* pViewports); -static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, + const VkRect2D* pScissors); +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports); +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors); +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, + VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); -static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides); +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable); +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable); +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp); +static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, + const VkHostImageLayoutTransitionInfo* pTransitions); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable); +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT(VkDevice device, VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout); -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable); +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT(VkDevice device, + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp); +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT( - VkDevice device, - const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT( - VkDevice device, - const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, uint32_t groupIndex); -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT( - VkDevice device, - const VkCopyImageToImageInfo* pCopyImageToImageInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); -static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT( - VkDevice device, - uint32_t transitionCount, - const VkHostImageLayoutTransitionInfo* pTransitions); +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo); +static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); +static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, + VkDisplayKHR* display); +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( - VkDevice device, - const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); - - - -static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); - -static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline, - uint32_t groupIndex); - -static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); - -static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV( - VkDevice device, - VkIndirectCommandsLayoutNV indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator); - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT( - VkCommandBuffer commandBuffer, - const VkDepthBiasInfoEXT* pDepthBiasInfo); - - - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - VkDisplayKHR display); - -static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - uint32_t connectorId, - VkDisplayKHR* display); - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot); - -static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator); - -static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data); - -static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData); - +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t data); +static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t* pData); +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerfHintQCOM(VkQueue queue, const VkPerfHintInfoQCOM* pPerfHintInfo); +#ifdef VK_ENABLE_BETA_EXTENSIONS -static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV( - VkDevice device, - const VkCudaModuleCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCudaModuleNV* pModule); +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule); -static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV( - VkDevice device, - VkCudaModuleNV module, - size_t* pCacheSize, - void* pCacheData); +static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, + void* pCacheData); -static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV( - VkDevice device, - const VkCudaFunctionCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCudaFunctionNV* pFunction); +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction); -static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV( - VkDevice device, - VkCudaModuleNV module, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV( - VkDevice device, - VkCudaFunctionNV function, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV( - VkCommandBuffer commandBuffer, - const VkCudaLaunchInfoNV* pLaunchInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo); +#endif /* VK_ENABLE_BETA_EXTENSIONS */ +static VKAPI_ATTR void VKAPI_CALL CmdDispatchTileQCOM(VkCommandBuffer commandBuffer, + const VkDispatchTileInfoQCOM* pDispatchTileInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, + const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); +static VKAPI_ATTR void VKAPI_CALL CmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, + const VkPerTileEndInfoQCOM* pPerTileEndInfo); #ifdef VK_USE_PLATFORM_METAL_EXT -static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT( - VkDevice device, - VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); +static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); #endif /* VK_USE_PLATFORM_METAL_EXT */ +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes); +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, + uint32_t binding, VkDeviceSize* pOffset); -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT( - VkDevice device, - VkDescriptorSetLayout layout, - VkDeviceSize* pLayoutSizeInBytes); +static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, + void* pDescriptor); -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT( - VkDevice device, - VkDescriptorSetLayout layout, - uint32_t binding, - VkDeviceSize* pOffset); +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos); -static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT( - VkDevice device, - const VkDescriptorGetInfoEXT* pDescriptorInfo, - size_t dataSize, - void* pDescriptor); +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, + uint32_t firstSet, uint32_t setCount, + const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t bufferCount, - const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set); -static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const uint32_t* pBufferIndices, - const VkDeviceSize* pOffsets); +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData); -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set); +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkBufferCaptureDescriptorDataInfoEXT* pInfo, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL +GetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageCaptureDescriptorDataInfoEXT* pInfo, - void* pData); - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, - void* pData); - -static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData); static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, - void* pData); + VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - - -static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV( - VkCommandBuffer commandBuffer, - VkFragmentShadingRateNV shadingRate, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - - - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( - VkDevice device, - VkDeviceFaultCountsEXT* pFaultCounts, - VkDeviceFaultInfoEXT* pFaultInfo); - - - +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo); #ifdef VK_USE_PLATFORM_WIN32_KHR -static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); +static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display); -static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - uint32_t deviceRelativeId, - VkDisplayKHR* pDisplay); +static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay); #endif /* VK_USE_PLATFORM_WIN32_KHR */ #ifdef VK_USE_PLATFORM_DIRECTFB_EXT +static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT( - VkInstance instance, - const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - IDirectFB* dfb); +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, IDirectFB* dfb); #endif /* VK_USE_PLATFORM_DIRECTFB_EXT */ - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT( - VkCommandBuffer commandBuffer, - uint32_t vertexBindingDescriptionCount, - const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); - - - - - - +static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); #ifdef VK_USE_PLATFORM_FUCHSIA -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( - VkDevice device, - const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle); +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - zx_handle_t zirconHandle, - VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); -#endif /* VK_USE_PLATFORM_FUCHSIA */ - -#ifdef VK_USE_PLATFORM_FUCHSIA +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); + VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle); -#endif /* VK_USE_PLATFORM_FUCHSIA */ + VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); -#ifdef VK_USE_PLATFORM_FUCHSIA - -static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA( - VkDevice device, - const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferCollectionFUCHSIA* pCollection); +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection); static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); + VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); + VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); -static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - VkBufferCollectionPropertiesFUCHSIA* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties); #endif /* VK_USE_PLATFORM_FUCHSIA */ +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize); +static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer); -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - VkDevice device, - VkRenderPass renderpass, - VkExtent2D* pMaxWorkgroupSize); +static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, + VkImageLayout imageLayout); -static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI( - VkCommandBuffer commandBuffer); +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress); +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties); -static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout); +static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV( - VkDevice device, - const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, - VkRemoteAddressNV* pAddress); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp); -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT( - VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, - VkBaseOutStructure* pPipelineProperties); - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT( - VkCommandBuffer commandBuffer, - uint32_t patchControlPoints); - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable); - -static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT( - VkCommandBuffer commandBuffer, - VkLogicOp logicOp); - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable); - +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); #ifdef VK_USE_PLATFORM_SCREEN_QNX -static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX( - VkInstance instance, - const VkScreenSurfaceCreateInfoQNX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); +static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct _screen_window* window); +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window); #endif /* VK_USE_PLATFORM_SCREEN_QNX */ +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, + const VkBool32* pColorWriteEnables); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, + uint32_t firstInstance, uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkBool32* pColorWriteEnables); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, + uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawInfoEXT* pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride); +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo); -static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawIndexedInfoEXT* pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t* pVertexOffset); +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, VkQueryType queryType, + size_t dataSize, void* pData, size_t stride); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( - VkDevice device, - const VkMicromapCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkMicromapEXT* pMicromap); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo); -static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( - VkDevice device, - VkMicromapEXT micromap, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo); -static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos); +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, VkQueryType queryType, + VkQueryPool queryPool, uint32_t firstQuery); -static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos); +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); -static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapInfoEXT* pInfo); +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapToMemoryInfoEXT* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ); -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToMicromapInfoEXT* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( - VkDevice device, - uint32_t micromapCount, - const VkMicromapEXT* pMicromaps, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride); +static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority); -static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapInfoEXT* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdSetDispatchParametersARM(VkCommandBuffer commandBuffer, + const VkDispatchParametersARM* pDispatchParameters); -static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapToMemoryInfoEXT* pInfo); +static VKAPI_ATTR void VKAPI_CALL +GetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToMicromapInfoEXT* pInfo); +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData); -static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( - VkCommandBuffer commandBuffer, - uint32_t micromapCount, - const VkMicromapEXT* pMicromaps, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, + uint32_t copyCount, uint32_t stride); -static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( - VkDevice device, - const VkMicromapVersionInfoEXT* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, + uint32_t copyCount, uint32_t stride, VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources); -static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkMicromapBuildInfoEXT* pBuildInfo, - VkMicromapBuildSizesInfoEXT* pSizeInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); -#ifdef VK_ENABLE_BETA_EXTENSIONS -#endif /* VK_ENABLE_BETA_EXTENSIONS */ +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); +static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV(VkDevice device, + const VkComputePipelineCreateInfo* pCreateInfo, + VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset); - - - -static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( - VkDevice device, - VkDeviceMemory memory, - float priority); - - - - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( - VkDevice device, - const VkDescriptorSetBindingReferenceVALVE* pBindingReference, - VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( - VkDevice device, - VkDescriptorSet descriptorSet, - void** ppData); - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride); - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - VkImage dstImage, - VkImageLayout dstImageLayout, - const VkImageSubresourceLayers* pImageSubresources); - - -static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV( - VkCommandBuffer commandBuffer, - uint32_t decompressRegionCount, - const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); - -static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectCommandsAddress, - VkDeviceAddress indirectCommandsCountAddress, - uint32_t stride); - - -static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV( - VkDevice device, - const VkComputePipelineCreateInfo* pCreateInfo, - VkMemoryRequirements2* pMemoryRequirements); - -static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetPipelineIndirectDeviceAddressNV( - VkDevice device, - const VkPipelineIndirectDeviceAddressInfoNV* pInfo); - - - - - - +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetPipelineIndirectDeviceAddressNV(VkDevice device, + const VkPipelineIndirectDeviceAddressInfoNV* pInfo); +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClampEnable); +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); +#endif /* VK_USE_PLATFORM_OHOS */ +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( - VkCommandBuffer commandBuffer, - VkPolygonMode polygonMode); +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits rasterizationSamples); +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples); -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits samples, - const VkSampleMask* pSampleMask); +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask); -static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToCoverageEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToOneEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 logicOpEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkBool32* pColorBlendEnables); +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, const VkBool32* pColorBlendEnables); -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendEquationEXT* pColorBlendEquations); +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations); -static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorComponentFlags* pColorWriteMasks); +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); -static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( - VkCommandBuffer commandBuffer, - VkTessellationDomainOrigin domainOrigin); +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( - VkCommandBuffer commandBuffer, - uint32_t rasterizationStream); +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkConservativeRasterizationModeEXT conservativeRasterizationMode); + VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); -static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( - VkCommandBuffer commandBuffer, - float extraPrimitiveOverestimationSize); +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClipEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 sampleLocationsEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced); -static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( - VkCommandBuffer commandBuffer, - VkProvokingVertexModeEXT provokingVertexMode); +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode); -static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkLineRasterizationModeEXT lineRasterizationMode); +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode); -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stippledLineEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( - VkCommandBuffer commandBuffer, - VkBool32 negativeOneToOne); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 viewportWScalingEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportSwizzleNV* pViewportSwizzles); +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, + uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageToColorEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( - VkCommandBuffer commandBuffer, - uint32_t coverageToColorLocation); +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( - VkCommandBuffer commandBuffer, - VkCoverageModulationModeNV coverageModulationMode); +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode); -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageModulationTableEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( - VkCommandBuffer commandBuffer, - uint32_t coverageModulationTableCount, - const float* pCoverageModulationTable); +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable); -static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 shadingRateImageEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 representativeFragmentTestEnable); +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable); -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( - VkCommandBuffer commandBuffer, - VkCoverageReductionModeNV coverageReductionMode); +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode); +static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor); +static VKAPI_ATTR void VKAPI_CALL DestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView); -static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( - VkDevice device, - VkShaderModule shaderModule, - VkShaderModuleIdentifierEXT* pIdentifier); +static VKAPI_ATTR void VKAPI_CALL DestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModuleIdentifierEXT* pIdentifier); +static VKAPI_ATTR void VKAPI_CALL GetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR VkResult VKAPI_CALL BindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, + const VkBindTensorMemoryInfoARM* pBindInfos); +static VKAPI_ATTR void VKAPI_CALL GetDeviceTensorMemoryRequirementsARM(VkDevice device, + const VkDeviceTensorMemoryRequirementsARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalTensorPropertiesARM( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, + VkExternalTensorPropertiesARM* pExternalTensorProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, + const VkTensorCaptureDescriptorDataInfoARM* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL +GetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData); + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier); + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT(VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier); static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( - VkPhysicalDevice physicalDevice, - const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, - uint32_t* pFormatCount, - VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); + VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); -static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( - VkDevice device, - const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkOpticalFlowSessionNV* pSession); +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV(VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession); -static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( - VkDevice device, - VkOpticalFlowSessionNV session, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( - VkDevice device, - VkOpticalFlowSessionNV session, - VkOpticalFlowSessionBindingPointNV bindingPoint, - VkImageView view, - VkImageLayout layout); +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, VkImageLayout layout); -static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( - VkCommandBuffer commandBuffer, - VkOpticalFlowSessionNV session, - const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData); +static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT(VkDevice device, uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); -#ifdef VK_USE_PLATFORM_ANDROID_KHR -#endif /* VK_USE_PLATFORM_ANDROID_KHR */ +static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); -static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD( - VkDevice device, - const VkAntiLagDataAMD* pData); +static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, + const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange); -static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT( - VkDevice device, - uint32_t createInfoCount, - const VkShaderCreateInfoEXT* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkShaderEXT* pShaders); +static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties); -static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT( - VkDevice device, - VkShaderEXT shader, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT( - VkDevice device, - VkShaderEXT shader, - size_t* pDataSize, - void* pData); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeVectorPropertiesNV* pProperties); -static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( - VkCommandBuffer commandBuffer, - uint32_t stageCount, - const VkShaderStageFlagBits* pStages, - const VkShaderEXT* pShaders); +static VKAPI_ATTR VkResult VKAPI_CALL ConvertCooperativeVectorMatrixNV(VkDevice device, + const VkConvertCooperativeVectorMatrixInfoNV* pInfo); -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT( - VkCommandBuffer commandBuffer, - VkDepthClampModeEXT depthClampMode, - const VkDepthClampRangeEXT* pDepthClampRange); +static VKAPI_ATTR void VKAPI_CALL CmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount, + const VkConvertCooperativeVectorMatrixInfoNV* pInfos); +static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, + const VkLatencySleepModeInfoNV* pSleepModeInfo); -static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( - VkDevice device, - VkFramebuffer framebuffer, - uint32_t* pPropertiesCount, - VkTilePropertiesQCOM* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, + const VkLatencySleepInfoNV* pSleepInfo); -static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( - VkDevice device, - const VkRenderingInfo* pRenderingInfo, - VkTilePropertiesQCOM* pProperties); +static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, + const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); +static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, + VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); +static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, uint32_t createInfoCount, + const VkDataGraphPipelineCreateInfoARM* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelineSessionARM(VkDevice device, + const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDataGraphPipelineSessionARM* pSession); +static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineSessionBindPointRequirementsARM( + VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, + VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements); +static VKAPI_ATTR void VKAPI_CALL GetDataGraphPipelineSessionMemoryRequirementsARM( + VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); +static VKAPI_ATTR VkResult VKAPI_CALL BindDataGraphPipelineSessionMemoryARM( + VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); +static VKAPI_ATTR void VKAPI_CALL DestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL CmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, + const VkDataGraphPipelineDispatchInfoARM* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineAvailablePropertiesARM(VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t* pPropertiesCount, + VkDataGraphPipelinePropertyARM* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelinePropertiesARM(VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t propertiesCount, + VkDataGraphPipelinePropertyQueryResultARM* pProperties); -static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkLatencySleepModeInfoNV* pSleepModeInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, + VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties); -static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkLatencySleepInfoNV* pSleepInfo); +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, + VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties); -static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, VkBaseOutStructure* pProperties); -static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV( - VkDevice device, - VkSwapchainKHR swapchain, - VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); - -static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV( - VkQueue queue, - const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); - - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( - VkCommandBuffer commandBuffer, - VkImageAspectFlags aspectMask); - +static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask); #ifdef VK_USE_PLATFORM_SCREEN_QNX -static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX( - VkDevice device, - const struct _screen_buffer* buffer, - VkScreenBufferPropertiesQNX* pProperties); +static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties); #endif /* VK_USE_PLATFORM_SCREEN_QNX */ +static VKAPI_ATTR void VKAPI_CALL CmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer, + const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryEXT(VkCommandBuffer commandBuffer, + const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer, + VkMemoryDecompressionMethodFlagsEXT decompressionMethod, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, uint32_t stride); +static VKAPI_ATTR VkResult VKAPI_CALL CreateExternalComputeQueueNV(VkDevice device, + const VkExternalComputeQueueCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkExternalComputeQueueNV* pExternalQueue); +static VKAPI_ATTR void VKAPI_CALL DestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue, + const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL GetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue, + VkExternalComputeQueueDataParamsNV* params, void* pData); +static VKAPI_ATTR void VKAPI_CALL GetClusterAccelerationStructureBuildSizesNV( + VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBuildClusterAccelerationStructureIndirectNV( + VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); +static VKAPI_ATTR void VKAPI_CALL +GetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +static VKAPI_ATTR void VKAPI_CALL CmdBuildPartitionedAccelerationStructuresNV( + VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, - VkMemoryRequirements2* pMemoryRequirements); + VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements); -static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, - VkCommandBuffer stateCommandBuffer); +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer); -static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT(VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); -static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT( - VkDevice device, - VkIndirectCommandsLayoutEXT indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT(VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); -static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT( - VkDevice device, - const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectExecutionSetEXT* pIndirectExecutionSet); +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT(VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet); -static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator); static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, + VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, + VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); +#ifdef VK_USE_PLATFORM_OHOS - - - - +static VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_OHOS */ static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); + VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); +#ifdef VK_USE_PLATFORM_METAL_EXT +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryMetalHandleEXT(VkDevice device, + const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, + void** pHandle); +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, + VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties); +#endif /* VK_USE_PLATFORM_METAL_EXT */ +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, + VkPerformanceCounterDescriptionARM* pCounterDescriptions); -static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( - VkDevice device, - const VkAccelerationStructureCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureKHR* pAccelerationStructure); +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceShaderInstrumentationMetricsARM( + VkPhysicalDevice physicalDevice, uint32_t* pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM* pDescriptions); -static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( - VkDevice device, - VkAccelerationStructureKHR accelerationStructure, - const VkAllocationCallbacks* pAllocator); +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderInstrumentationARM(VkDevice device, + const VkShaderInstrumentationCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderInstrumentationARM* pInstrumentation); + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderInstrumentationARM(VkDevice device, VkShaderInstrumentationARM instrumentation, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginShaderInstrumentationARM(VkCommandBuffer commandBuffer, + VkShaderInstrumentationARM instrumentation); + +static VKAPI_ATTR void VKAPI_CALL CmdEndShaderInstrumentationARM(VkCommandBuffer commandBuffer); + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInstrumentationValuesARM(VkDevice device, VkShaderInstrumentationARM instrumentation, + uint32_t* pMetricBlockCount, void* pMetricValues, + VkShaderInstrumentationValuesFlagsARM flags); + +static VKAPI_ATTR void VKAPI_CALL ClearShaderInstrumentationMetricsARM(VkDevice device, VkShaderInstrumentationARM instrumentation); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2EXT(VkCommandBuffer commandBuffer, + const VkRenderingEndInfoKHR* pRenderingEndInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, + const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties); + +static VKAPI_ATTR void VKAPI_CALL CmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer, + const VkComputeOccupancyPriorityParametersNV* pParameters); +#ifdef VK_USE_PLATFORM_UBM_SEC + +static VKAPI_ATTR VkResult VKAPI_CALL CreateUbmSurfaceSEC(VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceUbmPresentationSupportSEC(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct ubm_device* device); +#endif /* VK_USE_PLATFORM_UBM_SEC */ +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartIndexEXT(VkCommandBuffer commandBuffer, uint32_t primitiveRestartIndex); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator); static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkDeviceAddress* pIndirectDeviceAddresses, - const uint32_t* pIndirectStrides, - const uint32_t* const* ppMaxPrimitiveCounts); + VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); -static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +static VKAPI_ATTR VkResult VKAPI_CALL +BuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureInfoKHR* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( - VkDevice device, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride); + VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureInfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo); -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( - VkDevice device, - const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL +GetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); + VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( - VkDevice device, - const VkAccelerationStructureVersionInfoKHR* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility); +static VKAPI_ATTR void VKAPI_CALL +GetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, - const uint32_t* pMaxPrimitiveCounts, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); + VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, uint32_t height, uint32_t depth); -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth); +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, + uint32_t firstGroup, uint32_t groupCount, + size_t dataSize, void* pData); -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress); -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - VkDeviceAddress indirectDeviceAddress); +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, + VkShaderGroupShaderKHR groupShader); -static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t group, - VkShaderGroupShaderKHR groupShader); +static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); -static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR( - VkCommandBuffer commandBuffer, - uint32_t pipelineStackSize); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ); +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride); - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride); // Map of all APIs to be intercepted by this layer static const std::unordered_map<std::string, void*> name_to_funcptr_map = { {"vkCreateInstance", (void*)CreateInstance}, @@ -4790,30 +3237,50 @@ {"vkWaitForFences", (void*)WaitForFences}, {"vkCreateSemaphore", (void*)CreateSemaphore}, {"vkDestroySemaphore", (void*)DestroySemaphore}, - {"vkCreateEvent", (void*)CreateEvent}, - {"vkDestroyEvent", (void*)DestroyEvent}, - {"vkGetEventStatus", (void*)GetEventStatus}, - {"vkSetEvent", (void*)SetEvent}, - {"vkResetEvent", (void*)ResetEvent}, {"vkCreateQueryPool", (void*)CreateQueryPool}, {"vkDestroyQueryPool", (void*)DestroyQueryPool}, {"vkGetQueryPoolResults", (void*)GetQueryPoolResults}, {"vkCreateBuffer", (void*)CreateBuffer}, {"vkDestroyBuffer", (void*)DestroyBuffer}, - {"vkCreateBufferView", (void*)CreateBufferView}, - {"vkDestroyBufferView", (void*)DestroyBufferView}, {"vkCreateImage", (void*)CreateImage}, {"vkDestroyImage", (void*)DestroyImage}, {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout}, {"vkCreateImageView", (void*)CreateImageView}, {"vkDestroyImageView", (void*)DestroyImageView}, + {"vkCreateCommandPool", (void*)CreateCommandPool}, + {"vkDestroyCommandPool", (void*)DestroyCommandPool}, + {"vkResetCommandPool", (void*)ResetCommandPool}, + {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers}, + {"vkFreeCommandBuffers", (void*)FreeCommandBuffers}, + {"vkBeginCommandBuffer", (void*)BeginCommandBuffer}, + {"vkEndCommandBuffer", (void*)EndCommandBuffer}, + {"vkResetCommandBuffer", (void*)ResetCommandBuffer}, + {"vkCmdCopyBuffer", (void*)CmdCopyBuffer}, + {"vkCmdCopyImage", (void*)CmdCopyImage}, + {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage}, + {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer}, + {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer}, + {"vkCmdFillBuffer", (void*)CmdFillBuffer}, + {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier}, + {"vkCmdBeginQuery", (void*)CmdBeginQuery}, + {"vkCmdEndQuery", (void*)CmdEndQuery}, + {"vkCmdResetQueryPool", (void*)CmdResetQueryPool}, + {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp}, + {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults}, + {"vkCmdExecuteCommands", (void*)CmdExecuteCommands}, + {"vkCreateEvent", (void*)CreateEvent}, + {"vkDestroyEvent", (void*)DestroyEvent}, + {"vkGetEventStatus", (void*)GetEventStatus}, + {"vkSetEvent", (void*)SetEvent}, + {"vkResetEvent", (void*)ResetEvent}, + {"vkCreateBufferView", (void*)CreateBufferView}, + {"vkDestroyBufferView", (void*)DestroyBufferView}, {"vkCreateShaderModule", (void*)CreateShaderModule}, {"vkDestroyShaderModule", (void*)DestroyShaderModule}, {"vkCreatePipelineCache", (void*)CreatePipelineCache}, {"vkDestroyPipelineCache", (void*)DestroyPipelineCache}, {"vkGetPipelineCacheData", (void*)GetPipelineCacheData}, {"vkMergePipelineCaches", (void*)MergePipelineCaches}, - {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines}, {"vkCreateComputePipelines", (void*)CreateComputePipelines}, {"vkDestroyPipeline", (void*)DestroyPipeline}, {"vkCreatePipelineLayout", (void*)CreatePipelineLayout}, @@ -4828,20 +3295,21 @@ {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets}, {"vkFreeDescriptorSets", (void*)FreeDescriptorSets}, {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets}, + {"vkCmdBindPipeline", (void*)CmdBindPipeline}, + {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets}, + {"vkCmdClearColorImage", (void*)CmdClearColorImage}, + {"vkCmdDispatch", (void*)CmdDispatch}, + {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect}, + {"vkCmdSetEvent", (void*)CmdSetEvent}, + {"vkCmdResetEvent", (void*)CmdResetEvent}, + {"vkCmdWaitEvents", (void*)CmdWaitEvents}, + {"vkCmdPushConstants", (void*)CmdPushConstants}, + {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines}, {"vkCreateFramebuffer", (void*)CreateFramebuffer}, {"vkDestroyFramebuffer", (void*)DestroyFramebuffer}, {"vkCreateRenderPass", (void*)CreateRenderPass}, {"vkDestroyRenderPass", (void*)DestroyRenderPass}, {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity}, - {"vkCreateCommandPool", (void*)CreateCommandPool}, - {"vkDestroyCommandPool", (void*)DestroyCommandPool}, - {"vkResetCommandPool", (void*)ResetCommandPool}, - {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers}, - {"vkFreeCommandBuffers", (void*)FreeCommandBuffers}, - {"vkBeginCommandBuffer", (void*)BeginCommandBuffer}, - {"vkEndCommandBuffer", (void*)EndCommandBuffer}, - {"vkResetCommandBuffer", (void*)ResetCommandBuffer}, - {"vkCmdBindPipeline", (void*)CmdBindPipeline}, {"vkCmdSetViewport", (void*)CmdSetViewport}, {"vkCmdSetScissor", (void*)CmdSetScissor}, {"vkCmdSetLineWidth", (void*)CmdSetLineWidth}, @@ -4851,46 +3319,24 @@ {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask}, {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask}, {"vkCmdSetStencilReference", (void*)CmdSetStencilReference}, - {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets}, {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer}, {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers}, {"vkCmdDraw", (void*)CmdDraw}, {"vkCmdDrawIndexed", (void*)CmdDrawIndexed}, {"vkCmdDrawIndirect", (void*)CmdDrawIndirect}, {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect}, - {"vkCmdDispatch", (void*)CmdDispatch}, - {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect}, - {"vkCmdCopyBuffer", (void*)CmdCopyBuffer}, - {"vkCmdCopyImage", (void*)CmdCopyImage}, {"vkCmdBlitImage", (void*)CmdBlitImage}, - {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage}, - {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer}, - {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer}, - {"vkCmdFillBuffer", (void*)CmdFillBuffer}, - {"vkCmdClearColorImage", (void*)CmdClearColorImage}, {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage}, {"vkCmdClearAttachments", (void*)CmdClearAttachments}, {"vkCmdResolveImage", (void*)CmdResolveImage}, - {"vkCmdSetEvent", (void*)CmdSetEvent}, - {"vkCmdResetEvent", (void*)CmdResetEvent}, - {"vkCmdWaitEvents", (void*)CmdWaitEvents}, - {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier}, - {"vkCmdBeginQuery", (void*)CmdBeginQuery}, - {"vkCmdEndQuery", (void*)CmdEndQuery}, - {"vkCmdResetQueryPool", (void*)CmdResetQueryPool}, - {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp}, - {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults}, - {"vkCmdPushConstants", (void*)CmdPushConstants}, {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass}, {"vkCmdNextSubpass", (void*)CmdNextSubpass}, {"vkCmdEndRenderPass", (void*)CmdEndRenderPass}, - {"vkCmdExecuteCommands", (void*)CmdExecuteCommands}, {"vkEnumerateInstanceVersion", (void*)EnumerateInstanceVersion}, {"vkBindBufferMemory2", (void*)BindBufferMemory2}, {"vkBindImageMemory2", (void*)BindImageMemory2}, {"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures}, {"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask}, - {"vkCmdDispatchBase", (void*)CmdDispatchBase}, {"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups}, {"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2}, {"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2}, @@ -4904,21 +3350,16 @@ {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2}, {"vkTrimCommandPool", (void*)TrimCommandPool}, {"vkGetDeviceQueue2", (void*)GetDeviceQueue2}, - {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion}, - {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion}, - {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate}, - {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate}, - {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate}, {"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties}, {"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties}, {"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties}, + {"vkCmdDispatchBase", (void*)CmdDispatchBase}, + {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate}, + {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate}, + {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate}, {"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport}, - {"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount}, - {"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount}, - {"vkCreateRenderPass2", (void*)CreateRenderPass2}, - {"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2}, - {"vkCmdNextSubpass2", (void*)CmdNextSubpass2}, - {"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2}, + {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion}, + {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion}, {"vkResetQueryPool", (void*)ResetQueryPool}, {"vkGetSemaphoreCounterValue", (void*)GetSemaphoreCounterValue}, {"vkWaitSemaphores", (void*)WaitSemaphores}, @@ -4926,14 +3367,17 @@ {"vkGetBufferDeviceAddress", (void*)GetBufferDeviceAddress}, {"vkGetBufferOpaqueCaptureAddress", (void*)GetBufferOpaqueCaptureAddress}, {"vkGetDeviceMemoryOpaqueCaptureAddress", (void*)GetDeviceMemoryOpaqueCaptureAddress}, + {"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount}, + {"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount}, + {"vkCreateRenderPass2", (void*)CreateRenderPass2}, + {"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2}, + {"vkCmdNextSubpass2", (void*)CmdNextSubpass2}, + {"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2}, {"vkGetPhysicalDeviceToolProperties", (void*)GetPhysicalDeviceToolProperties}, {"vkCreatePrivateDataSlot", (void*)CreatePrivateDataSlot}, {"vkDestroyPrivateDataSlot", (void*)DestroyPrivateDataSlot}, {"vkSetPrivateData", (void*)SetPrivateData}, {"vkGetPrivateData", (void*)GetPrivateData}, - {"vkCmdSetEvent2", (void*)CmdSetEvent2}, - {"vkCmdResetEvent2", (void*)CmdResetEvent2}, - {"vkCmdWaitEvents2", (void*)CmdWaitEvents2}, {"vkCmdPipelineBarrier2", (void*)CmdPipelineBarrier2}, {"vkCmdWriteTimestamp2", (void*)CmdWriteTimestamp2}, {"vkQueueSubmit2", (void*)QueueSubmit2}, @@ -4941,6 +3385,12 @@ {"vkCmdCopyImage2", (void*)CmdCopyImage2}, {"vkCmdCopyBufferToImage2", (void*)CmdCopyBufferToImage2}, {"vkCmdCopyImageToBuffer2", (void*)CmdCopyImageToBuffer2}, + {"vkGetDeviceBufferMemoryRequirements", (void*)GetDeviceBufferMemoryRequirements}, + {"vkGetDeviceImageMemoryRequirements", (void*)GetDeviceImageMemoryRequirements}, + {"vkGetDeviceImageSparseMemoryRequirements", (void*)GetDeviceImageSparseMemoryRequirements}, + {"vkCmdSetEvent2", (void*)CmdSetEvent2}, + {"vkCmdResetEvent2", (void*)CmdResetEvent2}, + {"vkCmdWaitEvents2", (void*)CmdWaitEvents2}, {"vkCmdBlitImage2", (void*)CmdBlitImage2}, {"vkCmdResolveImage2", (void*)CmdResolveImage2}, {"vkCmdBeginRendering", (void*)CmdBeginRendering}, @@ -4960,28 +3410,25 @@ {"vkCmdSetRasterizerDiscardEnable", (void*)CmdSetRasterizerDiscardEnable}, {"vkCmdSetDepthBiasEnable", (void*)CmdSetDepthBiasEnable}, {"vkCmdSetPrimitiveRestartEnable", (void*)CmdSetPrimitiveRestartEnable}, - {"vkGetDeviceBufferMemoryRequirements", (void*)GetDeviceBufferMemoryRequirements}, - {"vkGetDeviceImageMemoryRequirements", (void*)GetDeviceImageMemoryRequirements}, - {"vkGetDeviceImageSparseMemoryRequirements", (void*)GetDeviceImageSparseMemoryRequirements}, - {"vkCmdSetLineStipple", (void*)CmdSetLineStipple}, {"vkMapMemory2", (void*)MapMemory2}, {"vkUnmapMemory2", (void*)UnmapMemory2}, - {"vkCmdBindIndexBuffer2", (void*)CmdBindIndexBuffer2}, - {"vkGetRenderingAreaGranularity", (void*)GetRenderingAreaGranularity}, {"vkGetDeviceImageSubresourceLayout", (void*)GetDeviceImageSubresourceLayout}, {"vkGetImageSubresourceLayout2", (void*)GetImageSubresourceLayout2}, - {"vkCmdPushDescriptorSet", (void*)CmdPushDescriptorSet}, - {"vkCmdPushDescriptorSetWithTemplate", (void*)CmdPushDescriptorSetWithTemplate}, - {"vkCmdSetRenderingAttachmentLocations", (void*)CmdSetRenderingAttachmentLocations}, - {"vkCmdSetRenderingInputAttachmentIndices", (void*)CmdSetRenderingInputAttachmentIndices}, - {"vkCmdBindDescriptorSets2", (void*)CmdBindDescriptorSets2}, - {"vkCmdPushConstants2", (void*)CmdPushConstants2}, - {"vkCmdPushDescriptorSet2", (void*)CmdPushDescriptorSet2}, - {"vkCmdPushDescriptorSetWithTemplate2", (void*)CmdPushDescriptorSetWithTemplate2}, {"vkCopyMemoryToImage", (void*)CopyMemoryToImage}, {"vkCopyImageToMemory", (void*)CopyImageToMemory}, {"vkCopyImageToImage", (void*)CopyImageToImage}, {"vkTransitionImageLayout", (void*)TransitionImageLayout}, + {"vkCmdPushDescriptorSet", (void*)CmdPushDescriptorSet}, + {"vkCmdPushDescriptorSetWithTemplate", (void*)CmdPushDescriptorSetWithTemplate}, + {"vkCmdBindDescriptorSets2", (void*)CmdBindDescriptorSets2}, + {"vkCmdPushConstants2", (void*)CmdPushConstants2}, + {"vkCmdPushDescriptorSet2", (void*)CmdPushDescriptorSet2}, + {"vkCmdPushDescriptorSetWithTemplate2", (void*)CmdPushDescriptorSetWithTemplate2}, + {"vkCmdSetLineStipple", (void*)CmdSetLineStipple}, + {"vkCmdBindIndexBuffer2", (void*)CmdBindIndexBuffer2}, + {"vkGetRenderingAreaGranularity", (void*)GetRenderingAreaGranularity}, + {"vkCmdSetRenderingAttachmentLocations", (void*)CmdSetRenderingAttachmentLocations}, + {"vkCmdSetRenderingInputAttachmentIndices", (void*)CmdSetRenderingInputAttachmentIndices}, {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR}, {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR}, {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR}, @@ -5095,7 +3542,8 @@ #endif {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR}, {"vkGetFenceFdKHR", (void*)GetFenceFdKHR}, - {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR}, + {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", + (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR}, {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", (void*)GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR}, {"vkAcquireProfilingLockKHR", (void*)AcquireProfilingLockKHR}, {"vkReleaseProfilingLockKHR", (void*)ReleaseProfilingLockKHR}, @@ -5145,6 +3593,28 @@ {"vkCmdPipelineBarrier2KHR", (void*)CmdPipelineBarrier2KHR}, {"vkCmdWriteTimestamp2KHR", (void*)CmdWriteTimestamp2KHR}, {"vkQueueSubmit2KHR", (void*)QueueSubmit2KHR}, + {"vkCmdBindIndexBuffer3KHR", (void*)CmdBindIndexBuffer3KHR}, + {"vkCmdBindVertexBuffers3KHR", (void*)CmdBindVertexBuffers3KHR}, + {"vkCmdDrawIndirect2KHR", (void*)CmdDrawIndirect2KHR}, + {"vkCmdDrawIndexedIndirect2KHR", (void*)CmdDrawIndexedIndirect2KHR}, + {"vkCmdDispatchIndirect2KHR", (void*)CmdDispatchIndirect2KHR}, + {"vkCmdCopyMemoryKHR", (void*)CmdCopyMemoryKHR}, + {"vkCmdCopyMemoryToImageKHR", (void*)CmdCopyMemoryToImageKHR}, + {"vkCmdCopyImageToMemoryKHR", (void*)CmdCopyImageToMemoryKHR}, + {"vkCmdUpdateMemoryKHR", (void*)CmdUpdateMemoryKHR}, + {"vkCmdFillMemoryKHR", (void*)CmdFillMemoryKHR}, + {"vkCmdCopyQueryPoolResultsToMemoryKHR", (void*)CmdCopyQueryPoolResultsToMemoryKHR}, + {"vkCmdDrawIndirectCount2KHR", (void*)CmdDrawIndirectCount2KHR}, + {"vkCmdDrawIndexedIndirectCount2KHR", (void*)CmdDrawIndexedIndirectCount2KHR}, + {"vkCmdBeginConditionalRendering2EXT", (void*)CmdBeginConditionalRendering2EXT}, + {"vkCmdBindTransformFeedbackBuffers2EXT", (void*)CmdBindTransformFeedbackBuffers2EXT}, + {"vkCmdBeginTransformFeedback2EXT", (void*)CmdBeginTransformFeedback2EXT}, + {"vkCmdEndTransformFeedback2EXT", (void*)CmdEndTransformFeedback2EXT}, + {"vkCmdDrawIndirectByteCount2EXT", (void*)CmdDrawIndirectByteCount2EXT}, + {"vkCmdDrawMeshTasksIndirect2EXT", (void*)CmdDrawMeshTasksIndirect2EXT}, + {"vkCmdDrawMeshTasksIndirectCount2EXT", (void*)CmdDrawMeshTasksIndirectCount2EXT}, + {"vkCmdWriteMarkerToMemoryAMD", (void*)CmdWriteMarkerToMemoryAMD}, + {"vkCreateAccelerationStructure2KHR", (void*)CreateAccelerationStructure2KHR}, {"vkCmdCopyBuffer2KHR", (void*)CmdCopyBuffer2KHR}, {"vkCmdCopyImage2KHR", (void*)CmdCopyImage2KHR}, {"vkCmdCopyBufferToImage2KHR", (void*)CmdCopyBufferToImage2KHR}, @@ -5159,11 +3629,13 @@ {"vkGetRenderingAreaGranularityKHR", (void*)GetRenderingAreaGranularityKHR}, {"vkGetDeviceImageSubresourceLayoutKHR", (void*)GetDeviceImageSubresourceLayoutKHR}, {"vkGetImageSubresourceLayout2KHR", (void*)GetImageSubresourceLayout2KHR}, + {"vkWaitForPresent2KHR", (void*)WaitForPresent2KHR}, {"vkCreatePipelineBinariesKHR", (void*)CreatePipelineBinariesKHR}, {"vkDestroyPipelineBinaryKHR", (void*)DestroyPipelineBinaryKHR}, {"vkGetPipelineKeyKHR", (void*)GetPipelineKeyKHR}, {"vkGetPipelineBinaryDataKHR", (void*)GetPipelineBinaryDataKHR}, {"vkReleaseCapturedPipelineDataKHR", (void*)ReleaseCapturedPipelineDataKHR}, + {"vkReleaseSwapchainImagesKHR", (void*)ReleaseSwapchainImagesKHR}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesKHR}, {"vkCmdSetLineStippleKHR", (void*)CmdSetLineStippleKHR}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", (void*)GetPhysicalDeviceCalibrateableTimeDomainsKHR}, @@ -5174,6 +3646,11 @@ {"vkCmdPushDescriptorSetWithTemplate2KHR", (void*)CmdPushDescriptorSetWithTemplate2KHR}, {"vkCmdSetDescriptorBufferOffsets2EXT", (void*)CmdSetDescriptorBufferOffsets2EXT}, {"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", (void*)CmdBindDescriptorBufferEmbeddedSamplers2EXT}, + {"vkCmdCopyMemoryIndirectKHR", (void*)CmdCopyMemoryIndirectKHR}, + {"vkCmdCopyMemoryToImageIndirectKHR", (void*)CmdCopyMemoryToImageIndirectKHR}, + {"vkGetDeviceFaultReportsKHR", (void*)GetDeviceFaultReportsKHR}, + {"vkGetDeviceFaultDebugInfoKHR", (void*)GetDeviceFaultDebugInfoKHR}, + {"vkCmdEndRendering2KHR", (void*)CmdEndRendering2KHR}, {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT}, {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT}, {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT}, @@ -5196,6 +3673,7 @@ {"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX}, {"vkGetImageViewHandle64NVX", (void*)GetImageViewHandle64NVX}, {"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX}, + {"vkGetDeviceCombinedImageSamplerIndexNVX", (void*)GetDeviceCombinedImageSamplerIndexNVX}, {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD}, {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD}, {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD}, @@ -5274,6 +3752,16 @@ #ifdef VK_ENABLE_BETA_EXTENSIONS {"vkCmdDispatchGraphIndirectCountAMDX", (void*)CmdDispatchGraphIndirectCountAMDX}, #endif + {"vkWriteSamplerDescriptorsEXT", (void*)WriteSamplerDescriptorsEXT}, + {"vkWriteResourceDescriptorsEXT", (void*)WriteResourceDescriptorsEXT}, + {"vkCmdBindSamplerHeapEXT", (void*)CmdBindSamplerHeapEXT}, + {"vkCmdBindResourceHeapEXT", (void*)CmdBindResourceHeapEXT}, + {"vkCmdPushDataEXT", (void*)CmdPushDataEXT}, + {"vkGetImageOpaqueCaptureDataEXT", (void*)GetImageOpaqueCaptureDataEXT}, + {"vkGetPhysicalDeviceDescriptorSizeEXT", (void*)GetPhysicalDeviceDescriptorSizeEXT}, + {"vkRegisterCustomBorderColorEXT", (void*)RegisterCustomBorderColorEXT}, + {"vkUnregisterCustomBorderColorEXT", (void*)UnregisterCustomBorderColorEXT}, + {"vkGetTensorOpaqueCaptureDataARM", (void*)GetTensorOpaqueCaptureDataARM}, {"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT}, {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT}, {"vkGetImageDrmFormatModifierPropertiesEXT", (void*)GetImageDrmFormatModifierPropertiesEXT}, @@ -5310,6 +3798,10 @@ {"vkCmdSetCheckpointNV", (void*)CmdSetCheckpointNV}, {"vkGetQueueCheckpointDataNV", (void*)GetQueueCheckpointDataNV}, {"vkGetQueueCheckpointData2NV", (void*)GetQueueCheckpointData2NV}, + {"vkSetSwapchainPresentTimingQueueSizeEXT", (void*)SetSwapchainPresentTimingQueueSizeEXT}, + {"vkGetSwapchainTimingPropertiesEXT", (void*)GetSwapchainTimingPropertiesEXT}, + {"vkGetSwapchainTimeDomainPropertiesEXT", (void*)GetSwapchainTimeDomainPropertiesEXT}, + {"vkGetPastPresentationTimingEXT", (void*)GetPastPresentationTimingEXT}, {"vkInitializePerformanceApiINTEL", (void*)InitializePerformanceApiINTEL}, {"vkUninitializePerformanceApiINTEL", (void*)UninitializePerformanceApiINTEL}, {"vkCmdSetPerformanceMarkerINTEL", (void*)CmdSetPerformanceMarkerINTEL}, @@ -5329,7 +3821,8 @@ {"vkGetBufferDeviceAddressEXT", (void*)GetBufferDeviceAddressEXT}, {"vkGetPhysicalDeviceToolPropertiesEXT", (void*)GetPhysicalDeviceToolPropertiesEXT}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV}, - {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV}, + {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", + (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV}, #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetPhysicalDeviceSurfacePresentModes2EXT", (void*)GetPhysicalDeviceSurfacePresentModes2EXT}, #endif @@ -5376,12 +3869,28 @@ {"vkDestroyPrivateDataSlotEXT", (void*)DestroyPrivateDataSlotEXT}, {"vkSetPrivateDataEXT", (void*)SetPrivateDataEXT}, {"vkGetPrivateDataEXT", (void*)GetPrivateDataEXT}, + {"vkQueueSetPerfHintQCOM", (void*)QueueSetPerfHintQCOM}, +#ifdef VK_ENABLE_BETA_EXTENSIONS {"vkCreateCudaModuleNV", (void*)CreateCudaModuleNV}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS {"vkGetCudaModuleCacheNV", (void*)GetCudaModuleCacheNV}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS {"vkCreateCudaFunctionNV", (void*)CreateCudaFunctionNV}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS {"vkDestroyCudaModuleNV", (void*)DestroyCudaModuleNV}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS {"vkDestroyCudaFunctionNV", (void*)DestroyCudaFunctionNV}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS {"vkCmdCudaLaunchKernelNV", (void*)CmdCudaLaunchKernelNV}, +#endif + {"vkCmdDispatchTileQCOM", (void*)CmdDispatchTileQCOM}, + {"vkCmdBeginPerTileExecutionQCOM", (void*)CmdBeginPerTileExecutionQCOM}, + {"vkCmdEndPerTileExecutionQCOM", (void*)CmdEndPerTileExecutionQCOM}, #ifdef VK_USE_PLATFORM_METAL_EXT {"vkExportMetalObjectsEXT", (void*)ExportMetalObjectsEXT}, #endif @@ -5474,6 +3983,7 @@ {"vkCmdDrawClusterHUAWEI", (void*)CmdDrawClusterHUAWEI}, {"vkCmdDrawClusterIndirectHUAWEI", (void*)CmdDrawClusterIndirectHUAWEI}, {"vkSetDeviceMemoryPriorityEXT", (void*)SetDeviceMemoryPriorityEXT}, + {"vkCmdSetDispatchParametersARM", (void*)CmdSetDispatchParametersARM}, {"vkGetDescriptorSetLayoutHostMappingInfoVALVE", (void*)GetDescriptorSetLayoutHostMappingInfoVALVE}, {"vkGetDescriptorSetHostMappingVALVE", (void*)GetDescriptorSetHostMappingVALVE}, {"vkCmdCopyMemoryIndirectNV", (void*)CmdCopyMemoryIndirectNV}, @@ -5483,6 +3993,12 @@ {"vkGetPipelineIndirectMemoryRequirementsNV", (void*)GetPipelineIndirectMemoryRequirementsNV}, {"vkCmdUpdatePipelineIndirectBufferNV", (void*)CmdUpdatePipelineIndirectBufferNV}, {"vkGetPipelineIndirectDeviceAddressNV", (void*)GetPipelineIndirectDeviceAddressNV}, +#ifdef VK_USE_PLATFORM_OHOS + {"vkGetNativeBufferPropertiesOHOS", (void*)GetNativeBufferPropertiesOHOS}, +#endif +#ifdef VK_USE_PLATFORM_OHOS + {"vkGetMemoryNativeBufferOHOS", (void*)GetMemoryNativeBufferOHOS}, +#endif {"vkCmdSetDepthClampEnableEXT", (void*)CmdSetDepthClampEnableEXT}, {"vkCmdSetPolygonModeEXT", (void*)CmdSetPolygonModeEXT}, {"vkCmdSetRasterizationSamplesEXT", (void*)CmdSetRasterizationSamplesEXT}, @@ -5514,6 +4030,17 @@ {"vkCmdSetShadingRateImageEnableNV", (void*)CmdSetShadingRateImageEnableNV}, {"vkCmdSetRepresentativeFragmentTestEnableNV", (void*)CmdSetRepresentativeFragmentTestEnableNV}, {"vkCmdSetCoverageReductionModeNV", (void*)CmdSetCoverageReductionModeNV}, + {"vkCreateTensorARM", (void*)CreateTensorARM}, + {"vkDestroyTensorARM", (void*)DestroyTensorARM}, + {"vkCreateTensorViewARM", (void*)CreateTensorViewARM}, + {"vkDestroyTensorViewARM", (void*)DestroyTensorViewARM}, + {"vkGetTensorMemoryRequirementsARM", (void*)GetTensorMemoryRequirementsARM}, + {"vkBindTensorMemoryARM", (void*)BindTensorMemoryARM}, + {"vkGetDeviceTensorMemoryRequirementsARM", (void*)GetDeviceTensorMemoryRequirementsARM}, + {"vkCmdCopyTensorARM", (void*)CmdCopyTensorARM}, + {"vkGetPhysicalDeviceExternalTensorPropertiesARM", (void*)GetPhysicalDeviceExternalTensorPropertiesARM}, + {"vkGetTensorOpaqueCaptureDescriptorDataARM", (void*)GetTensorOpaqueCaptureDescriptorDataARM}, + {"vkGetTensorViewOpaqueCaptureDescriptorDataARM", (void*)GetTensorViewOpaqueCaptureDescriptorDataARM}, {"vkGetShaderModuleIdentifierEXT", (void*)GetShaderModuleIdentifierEXT}, {"vkGetShaderModuleCreateInfoIdentifierEXT", (void*)GetShaderModuleCreateInfoIdentifierEXT}, {"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", (void*)GetPhysicalDeviceOpticalFlowImageFormatsNV}, @@ -5529,15 +4056,42 @@ {"vkCmdSetDepthClampRangeEXT", (void*)CmdSetDepthClampRangeEXT}, {"vkGetFramebufferTilePropertiesQCOM", (void*)GetFramebufferTilePropertiesQCOM}, {"vkGetDynamicRenderingTilePropertiesQCOM", (void*)GetDynamicRenderingTilePropertiesQCOM}, + {"vkGetPhysicalDeviceCooperativeVectorPropertiesNV", (void*)GetPhysicalDeviceCooperativeVectorPropertiesNV}, + {"vkConvertCooperativeVectorMatrixNV", (void*)ConvertCooperativeVectorMatrixNV}, + {"vkCmdConvertCooperativeVectorMatrixNV", (void*)CmdConvertCooperativeVectorMatrixNV}, {"vkSetLatencySleepModeNV", (void*)SetLatencySleepModeNV}, {"vkLatencySleepNV", (void*)LatencySleepNV}, {"vkSetLatencyMarkerNV", (void*)SetLatencyMarkerNV}, {"vkGetLatencyTimingsNV", (void*)GetLatencyTimingsNV}, {"vkQueueNotifyOutOfBandNV", (void*)QueueNotifyOutOfBandNV}, + {"vkCreateDataGraphPipelinesARM", (void*)CreateDataGraphPipelinesARM}, + {"vkCreateDataGraphPipelineSessionARM", (void*)CreateDataGraphPipelineSessionARM}, + {"vkGetDataGraphPipelineSessionBindPointRequirementsARM", (void*)GetDataGraphPipelineSessionBindPointRequirementsARM}, + {"vkGetDataGraphPipelineSessionMemoryRequirementsARM", (void*)GetDataGraphPipelineSessionMemoryRequirementsARM}, + {"vkBindDataGraphPipelineSessionMemoryARM", (void*)BindDataGraphPipelineSessionMemoryARM}, + {"vkDestroyDataGraphPipelineSessionARM", (void*)DestroyDataGraphPipelineSessionARM}, + {"vkCmdDispatchDataGraphARM", (void*)CmdDispatchDataGraphARM}, + {"vkGetDataGraphPipelineAvailablePropertiesARM", (void*)GetDataGraphPipelineAvailablePropertiesARM}, + {"vkGetDataGraphPipelinePropertiesARM", (void*)GetDataGraphPipelinePropertiesARM}, + {"vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM", (void*)GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM}, + {"vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM", + (void*)GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM}, + {"vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM", + (void*)GetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM}, {"vkCmdSetAttachmentFeedbackLoopEnableEXT", (void*)CmdSetAttachmentFeedbackLoopEnableEXT}, #ifdef VK_USE_PLATFORM_SCREEN_QNX {"vkGetScreenBufferPropertiesQNX", (void*)GetScreenBufferPropertiesQNX}, #endif + {"vkCmdBindTileMemoryQCOM", (void*)CmdBindTileMemoryQCOM}, + {"vkCmdDecompressMemoryEXT", (void*)CmdDecompressMemoryEXT}, + {"vkCmdDecompressMemoryIndirectCountEXT", (void*)CmdDecompressMemoryIndirectCountEXT}, + {"vkCreateExternalComputeQueueNV", (void*)CreateExternalComputeQueueNV}, + {"vkDestroyExternalComputeQueueNV", (void*)DestroyExternalComputeQueueNV}, + {"vkGetExternalComputeQueueDataNV", (void*)GetExternalComputeQueueDataNV}, + {"vkGetClusterAccelerationStructureBuildSizesNV", (void*)GetClusterAccelerationStructureBuildSizesNV}, + {"vkCmdBuildClusterAccelerationStructureIndirectNV", (void*)CmdBuildClusterAccelerationStructureIndirectNV}, + {"vkGetPartitionedAccelerationStructuresBuildSizesNV", (void*)GetPartitionedAccelerationStructuresBuildSizesNV}, + {"vkCmdBuildPartitionedAccelerationStructuresNV", (void*)CmdBuildPartitionedAccelerationStructuresNV}, {"vkGetGeneratedCommandsMemoryRequirementsEXT", (void*)GetGeneratedCommandsMemoryRequirementsEXT}, {"vkCmdPreprocessGeneratedCommandsEXT", (void*)CmdPreprocessGeneratedCommandsEXT}, {"vkCmdExecuteGeneratedCommandsEXT", (void*)CmdExecuteGeneratedCommandsEXT}, @@ -5547,7 +4101,38 @@ {"vkDestroyIndirectExecutionSetEXT", (void*)DestroyIndirectExecutionSetEXT}, {"vkUpdateIndirectExecutionSetPipelineEXT", (void*)UpdateIndirectExecutionSetPipelineEXT}, {"vkUpdateIndirectExecutionSetShaderEXT", (void*)UpdateIndirectExecutionSetShaderEXT}, - {"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV}, +#ifdef VK_USE_PLATFORM_OHOS + {"vkCreateSurfaceOHOS", (void*)CreateSurfaceOHOS}, +#endif + {"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV", + (void*)GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV}, +#ifdef VK_USE_PLATFORM_METAL_EXT + {"vkGetMemoryMetalHandleEXT", (void*)GetMemoryMetalHandleEXT}, +#endif +#ifdef VK_USE_PLATFORM_METAL_EXT + {"vkGetMemoryMetalHandlePropertiesEXT", (void*)GetMemoryMetalHandlePropertiesEXT}, +#endif + {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM", + (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM}, + {"vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM", (void*)EnumeratePhysicalDeviceShaderInstrumentationMetricsARM}, + {"vkCreateShaderInstrumentationARM", (void*)CreateShaderInstrumentationARM}, + {"vkDestroyShaderInstrumentationARM", (void*)DestroyShaderInstrumentationARM}, + {"vkCmdBeginShaderInstrumentationARM", (void*)CmdBeginShaderInstrumentationARM}, + {"vkCmdEndShaderInstrumentationARM", (void*)CmdEndShaderInstrumentationARM}, + {"vkGetShaderInstrumentationValuesARM", (void*)GetShaderInstrumentationValuesARM}, + {"vkClearShaderInstrumentationMetricsARM", (void*)ClearShaderInstrumentationMetricsARM}, + {"vkCmdEndRendering2EXT", (void*)CmdEndRendering2EXT}, + {"vkCmdBeginCustomResolveEXT", (void*)CmdBeginCustomResolveEXT}, + {"vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM", + (void*)GetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM}, + {"vkCmdSetComputeOccupancyPriorityNV", (void*)CmdSetComputeOccupancyPriorityNV}, +#ifdef VK_USE_PLATFORM_UBM_SEC + {"vkCreateUbmSurfaceSEC", (void*)CreateUbmSurfaceSEC}, +#endif +#ifdef VK_USE_PLATFORM_UBM_SEC + {"vkGetPhysicalDeviceUbmPresentationSupportSEC", (void*)GetPhysicalDeviceUbmPresentationSupportSEC}, +#endif + {"vkCmdSetPrimitiveRestartIndexEXT", (void*)CmdSetPrimitiveRestartIndexEXT}, {"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR}, {"vkDestroyAccelerationStructureKHR", (void*)DestroyAccelerationStructureKHR}, {"vkCmdBuildAccelerationStructuresKHR", (void*)CmdBuildAccelerationStructuresKHR}, @@ -5575,5 +4160,4 @@ {"vkCmdDrawMeshTasksIndirectCountEXT", (void*)CmdDrawMeshTasksIndirectCountEXT}, }; -} // namespace vkmock - +} // namespace vkmock
diff --git a/icd/generated/function_definitions.h b/icd/generated/function_definitions.h index 1ac3134..bd25b93 100644 --- a/icd/generated/function_definitions.h +++ b/icd/generated/function_definitions.h
@@ -1,5 +1,5 @@ /* -** Copyright (c) 2015-2024 The Khronos Group Inc. +** Copyright (c) 2015-2025 The Khronos Group Inc. ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. @@ -20,19 +20,11 @@ */ #pragma once - #include "mock_icd.h" #include "function_declarations.h" - namespace vkmock { - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance) -{ - +static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with // apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the // ICD should behave as normal. @@ -40,17 +32,11 @@ return VK_ERROR_INCOMPATIBLE_DRIVER; } *pInstance = (VkInstance)CreateDispObjHandle(); - for (auto& physical_device : physical_device_map[*pInstance]) - physical_device = (VkPhysicalDevice)CreateDispObjHandle(); + for (auto& physical_device : physical_device_map[*pInstance]) physical_device = (VkPhysicalDevice)CreateDispObjHandle(); // TODO: If emulating specific device caps, will need to add intelligence here return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator) -{ - +static VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { if (instance) { for (const auto physical_device : physical_device_map.at(instance)) { display_map.erase(physical_device); @@ -60,12 +46,8 @@ DestroyDispObjHandle((void*)instance); } } - -static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices) -{ +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices) { VkResult result_code = VK_SUCCESS; if (pPhysicalDevices) { const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count); @@ -77,26 +59,18 @@ } return result_code; } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); - VkBool32 *bool_array = &pFeatures->robustBufferAccess; + VkBool32* bool_array = &pFeatures->robustBufferAccess; SetBoolArrayTrue(bool_array, num_bools); } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties* pFormatProperties) { if (VK_FORMAT_UNDEFINED == format) { - *pFormatProperties = { 0x0, 0x0, 0x0 }; + *pFormatProperties = {0x0, 0x0, 0x0}; } else { // Default to a color format, skip DS bit - *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF }; + *pFormatProperties = {0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF}; switch (format) { case VK_FORMAT_D16_UNORM: case VK_FORMAT_X8_D24_UNORM_PACK32: @@ -106,7 +80,7 @@ case VK_FORMAT_D24_UNORM_S8_UINT: case VK_FORMAT_D32_SFLOAT_S8_UINT: // Don't set color bits for DS formats - *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F }; + *pFormatProperties = {0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F}; break; case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: @@ -114,23 +88,17 @@ case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: // Set decode/encode bits for these formats - *pFormatProperties = { 0x1EFFFDFF, 0x1EFFFDFF, 0x00FFFDFF }; + *pFormatProperties = {0x1EFFFDFF, 0x1EFFFDFF, 0x00FFFDFF}; break; default: break; } } } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkImageType type, VkImageTiling tiling, + VkImageUsageFlags usage, VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties) { // A hardcoded unsupported format if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) { return VK_ERROR_FORMAT_NOT_SUPPORTED; @@ -139,38 +107,32 @@ // TODO: Just hard-coding some values for now // TODO: If tiling is linear, limit the mips, levels, & sample count if (VK_IMAGE_TILING_LINEAR == tiling) { - *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 }; + *pImageFormatProperties = {{4096, 4096, 256}, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296}; } else { // We hard-code support for all sample counts except 64 bits. - *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 }; + *pImageFormatProperties = {{4096, 4096, 256}, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296}; } return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties) { pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE; pProperties->driverVersion = 1; pProperties->vendorID = 0xba5eba11; pProperties->deviceID = 0xf005ba11; pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; - //std::string devName = "Vulkan Mock Device"; + // std::string devName = "Vulkan Mock Device"; strcpy(pProperties->deviceName, "Vulkan Mock Device"); pProperties->pipelineCacheUUID[0] = 18; pProperties->limits = SetLimits(&pProperties->limits); - pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE }; + pProperties->sparseProperties = {VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE}; } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties) { if (pQueueFamilyProperties) { - std::vector<VkQueueFamilyProperties2KHR> props2(*pQueueFamilyPropertyCount, { - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR}); + std::vector<VkQueueFamilyProperties2KHR> props2(*pQueueFamilyPropertyCount, + {VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR}); GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, props2.data()); for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) { pQueueFamilyProperties[i] = props2[i].queueFamilyProperties; @@ -179,11 +141,8 @@ GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, nullptr); } } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties) { pMemoryProperties->memoryTypeCount = 6; // Host visible Coherent pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; @@ -192,7 +151,8 @@ pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; pMemoryProperties->memoryTypes[1].heapIndex = 0; // Device local and Host visible - pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; pMemoryProperties->memoryTypes[2].heapIndex = 1; // Device local lazily pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; @@ -209,48 +169,27 @@ pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; pMemoryProperties->memoryHeaps[1].size = 8000000000; } - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( - VkInstance instance, - const char* pName) -{ - +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* pName) { if (!negotiate_loader_icd_interface_called) { loader_interface_version = 0; } - const auto &item = name_to_funcptr_map.find(pName); + const auto& item = name_to_funcptr_map.find(pName); if (item != name_to_funcptr_map.end()) { return reinterpret_cast<PFN_vkVoidFunction>(item->second); } // Mock should intercept all functions so if we get here just return null return nullptr; } - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( - VkDevice device, - const char* pName) -{ - +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* pName) { return GetInstanceProcAddr(nullptr, pName); } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice) -{ - +static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { *pDevice = (VkDevice)CreateDispObjHandle(); // TODO: If emulating specific device caps, will need to add intelligence here return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator) -{ - +static VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { unique_lock_t lock(global_lock); // First destroy sub-device objects // Destroy Queues @@ -262,7 +201,7 @@ for (auto& cp : command_pool_map[device]) { for (auto& cb : command_pool_buffer_map[cp]) { - DestroyDispObjHandle((void*) cb); + DestroyDispObjHandle((void*)cb); } command_pool_buffer_map.erase(cp); } @@ -275,20 +214,15 @@ DestroyDispObjHandle((void*)device); // TODO: If emulating specific device caps, will need to add intelligence here } - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) -{ - +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { // If requesting number of extensions, return that if (!pLayerName) { if (!pProperties) { *pPropertyCount = (uint32_t)instance_extension_map.size(); } else { uint32_t i = 0; - for (const auto &name_ver_pair : instance_extension_map) { + for (const auto& name_ver_pair : instance_extension_map) { if (i == *pPropertyCount) { break; } @@ -305,21 +239,16 @@ // If requesting extension properties, fill in data struct for number of extensions return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) -{ - +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { // If requesting number of extensions, return that if (!pLayerName) { if (!pProperties) { *pPropertyCount = (uint32_t)device_extension_map.size(); } else { uint32_t i = 0; - for (const auto &name_ver_pair : device_extension_map) { + for (const auto& name_ver_pair : device_extension_map) { if (i == *pPropertyCount) { break; } @@ -328,6 +257,7 @@ pProperties[i].specVersion = name_ver_pair.second; ++i; } + *pPropertyCount = i; if (i != device_extension_map.size()) { return VK_INCOMPLETE; } @@ -336,30 +266,14 @@ // If requesting extension properties, fill in data struct for number of extensions return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, - VkLayerProperties* pProperties) -{ - +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkLayerProperties* pProperties) -{ - +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, + VkLayerProperties* pProperties) { return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue) -{ +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { unique_lock_t lock(global_lock); auto queue = queue_map[device][queueFamilyIndex][queueIndex]; if (queue) { @@ -370,71 +284,43 @@ // TODO: If emulating specific device caps, will need to add intelligence here return; } - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence) -{ +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, + VkFence fence) { // Special way to cause DEVICE_LOST // Picked VkExportFenceCreateInfo because needed some struct that wouldn't get cleared by validation Safe Struct // ... TODO - It would be MUCH nicer to have a layer or other setting control when this occured // For now this is used to allow Validation Layers test reacting to device losts if (submitCount > 0 && pSubmits) { - auto pNext = reinterpret_cast<const VkBaseInStructure *>(pSubmits[0].pNext); + auto pNext = reinterpret_cast<const VkBaseInStructure*>(pSubmits[0].pNext); if (pNext && pNext->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO && pNext->pNext == nullptr) { return VK_ERROR_DEVICE_LOST; } } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( - VkQueue queue) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( - VkDevice device) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( - VkDevice device, - const VkMemoryAllocateInfo* pAllocateInfo, - const VkAllocationCallbacks* pAllocator, - VkDeviceMemory* pMemory) -{ +static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { unique_lock_t lock(global_lock); allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize; *pMemory = (VkDeviceMemory)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL FreeMemory( - VkDevice device, - VkDeviceMemory memory, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { + // Destroy object UnmapMemory(device, memory); unique_lock_t lock(global_lock); allocated_memory_size_map.erase(memory); } - -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData) -{ +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, + VkMemoryMapFlags flags, void** ppData) { unique_lock_t lock(global_lock); if (VK_WHOLE_SIZE == size) { if (allocated_memory_size_map.count(memory) != 0) @@ -447,69 +333,39 @@ *ppData = map_addr; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL UnmapMemory( - VkDevice device, - VkDeviceMemory memory) -{ +static VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory) { unique_lock_t lock(global_lock); for (auto map_addr : mapped_memory_map[memory]) { free(map_addr); } mapped_memory_map.erase(memory); } - -static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory memory, - VkDeviceSize memoryOffset) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, + VkDeviceSize memoryOffset) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory memory, - VkDeviceSize memoryOffset) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, + VkDeviceSize memoryOffset) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements) { // TODO: Just hard-coding reqs for now pMemoryRequirements->size = 4096; pMemoryRequirements->alignment = 1; @@ -524,18 +380,14 @@ } } } - -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, + VkMemoryRequirements* pMemoryRequirements) { pMemoryRequirements->size = 0; pMemoryRequirements->alignment = 1; unique_lock_t lock(global_lock); auto d_iter = image_memory_size_map.find(device); - if(d_iter != image_memory_size_map.end()){ + if (d_iter != image_memory_size_map.end()) { auto iter = d_iter->second.find(image); if (iter != d_iter->second.end()) { pMemoryRequirements->size = iter->second; @@ -544,13 +396,9 @@ // Here we hard-code that the memory type at index 3 doesn't support this image. pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3); } - -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { if (!pSparseMemoryRequirements) { *pSparseMemoryRequirementCount = 1; } else { @@ -562,21 +410,15 @@ pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4}; pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; // Would need to track the VkImage to know format for better value here - pSparseMemoryRequirements->formatProperties.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; + pSparseMemoryRequirements->formatProperties.aspectMask = + VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; } - } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties* pProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkImageType type, VkSampleCountFlagBits samples, + VkImageUsageFlags usage, VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties) { if (!pProperties) { *pPropertyCount = 1; } else { @@ -603,563 +445,128 @@ } } } - -static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( - VkQueue queue, - uint32_t bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, + VkFence fence) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkFence* pFence) { unique_lock_t lock(global_lock); *pFence = (VkFence)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyFence( - VkDevice device, - VkFence fence, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL ResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( - VkDevice device, - VkFence fence) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, + uint64_t timeout) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { unique_lock_t lock(global_lock); *pSemaphore = (VkSemaphore)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent) -{ - unique_lock_t lock(global_lock); - *pEvent = (VkEvent)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( - VkDevice device, - VkEvent event) -{ -//Not a CREATE or DESTROY function - return VK_EVENT_SET; -} - -static VKAPI_ATTR VkResult VKAPI_CALL SetEvent( - VkDevice device, - VkEvent event) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( - VkDevice device, - VkEvent event) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { unique_lock_t lock(global_lock); *pQueryPool = (VkQueryPool)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void* pData, - VkDeviceSize stride, - VkQueryResultFlags flags) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, + VkQueryResultFlags flags) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBuffer* pBuffer) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { unique_lock_t lock(global_lock); *pBuffer = (VkBuffer)global_unique_handle++; - buffer_map[device][*pBuffer] = { - pCreateInfo->size, - current_available_address - }; - current_available_address += pCreateInfo->size; - // Always align to next 64-bit pointer - const uint64_t alignment = current_available_address % 64; - if (alignment != 0) { - current_available_address += (64 - alignment); - } + buffer_map[device][*pBuffer] = {pCreateInfo->size, current_available_address}; + current_available_address += pCreateInfo->size; + // Always align to next 64-bit pointer + const uint64_t alignment = current_available_address % 64; + if (alignment != 0) { + current_available_address += (64 - alignment); + } return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyBuffer( - VkDevice device, - VkBuffer buffer, - const VkAllocationCallbacks* pAllocator) -{ +static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { unique_lock_t lock(global_lock); buffer_map[device].erase(buffer); } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView) -{ - unique_lock_t lock(global_lock); - *pView = (VkBufferView)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImage* pImage) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkImage* pImage) { unique_lock_t lock(global_lock); *pImage = (VkImage)global_unique_handle++; image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo); return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyImage( - VkDevice device, - VkImage image, - const VkAllocationCallbacks* pAllocator) -{ +static VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { unique_lock_t lock(global_lock); image_memory_size_map[device].erase(image); } - -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout) -{ +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout) { // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. - *pLayout = VkSubresourceLayout(); // Default constructor zero values. + *pLayout = VkSubresourceLayout(); // Default constructor zero values. } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImageView* pView) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkImageView* pView) { unique_lock_t lock(global_lock); *pView = (VkImageView)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyImageView( - VkDevice device, - VkImageView imageView, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkShaderModule* pShaderModule) -{ - unique_lock_t lock(global_lock); - *pShaderModule = (VkShaderModule)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache) -{ - unique_lock_t lock(global_lock); - *pPipelineCache = (VkPipelineCache)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - pPipelines[i] = (VkPipeline)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - pPipelines[i] = (VkPipeline)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPipeline( - VkDevice device, - VkPipeline pipeline, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout) -{ - unique_lock_t lock(global_lock); - *pPipelineLayout = (VkPipelineLayout)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler) -{ - unique_lock_t lock(global_lock); - *pSampler = (VkSampler)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout) -{ - unique_lock_t lock(global_lock); - *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool) -{ - unique_lock_t lock(global_lock); - *pDescriptorPool = (VkDescriptorPool)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) { - pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets) -{ -//Destroy object - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( - VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer) -{ - unique_lock_t lock(global_lock); - *pFramebuffer = (VkFramebuffer)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) -{ - unique_lock_t lock(global_lock); - *pRenderPass = (VkRenderPass)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity) -{ - pGranularity->width = 1; - pGranularity->height = 1; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { unique_lock_t lock(global_lock); *pCommandPool = (VkCommandPool)global_unique_handle++; command_pool_map[device].insert(*pCommandPool); return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator) -{ - +static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator) { // destroy command buffers for this pool unique_lock_t lock(global_lock); auto it = command_pool_buffer_map.find(commandPool); if (it != command_pool_buffer_map.end()) { for (auto& cb : it->second) { - DestroyDispObjHandle((void*) cb); + DestroyDispObjHandle((void*)cb); } command_pool_buffer_map.erase(it); } command_pool_map[device].erase(commandPool); } - -static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers) -{ - +static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) { unique_lock_t lock(global_lock); for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) { pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle(); @@ -1167,14 +574,8 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( - VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers) -{ - +static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) { unique_lock_t lock(global_lock); for (auto i = 0u; i < commandBufferCount; ++i) { if (!pCommandBuffers[i]) { @@ -1189,676 +590,471 @@ } } - DestroyDispObjHandle((void*) pCommandBuffers[i]); + DestroyDispObjHandle((void*)pCommandBuffers[i]); } } - -static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, + uint32_t regionCount, const VkBufferCopy* pRegions) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewport( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageCopy* pRegions) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetScissor( - VkCommandBuffer commandBuffer, - uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkBufferImageCopy* pRegions) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( - VkCommandBuffer commandBuffer, - float lineWidth) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, + VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, + const VkBufferImageCopy* pRegions) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( - VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, + VkDeviceSize dataSize, const void* pData) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( - VkCommandBuffer commandBuffer, - const float blendConstants[4]) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, + VkDeviceSize size, uint32_t data) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( - VkCommandBuffer commandBuffer, - float minDepthBounds, - float maxDepthBounds) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t compareMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, + VkQueryControlFlags flags) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t writeMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t reference) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, uint32_t query) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, + VkDeviceSize stride, VkQueryResultFlags flags) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDraw( - VkCommandBuffer commandBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { + unique_lock_t lock(global_lock); + *pEvent = (VkEvent)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event) { + // Not a CREATE or DESTROY function + return VK_EVENT_SET; } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { + unique_lock_t lock(global_lock); + *pView = (VkBufferView)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { + unique_lock_t lock(global_lock); + *pShaderModule = (VkShaderModule)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkFilter filter) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache) { + unique_lock_t lock(global_lock); + *pPipelineCache = (VkPipelineCache)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, + void* pData) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment* pAttachments, - uint32_t rectCount, - const VkClearRect* pRects) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout) { + unique_lock_t lock(global_lock); + *pPipelineLayout = (VkPipelineLayout)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { + unique_lock_t lock(global_lock); + *pSampler = (VkSampler)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout) { + unique_lock_t lock(global_lock); + *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool) { + unique_lock_t lock(global_lock); + *pDescriptorPool = (VkDescriptorPool)global_unique_handle++; + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets) { + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) { + pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++; + } + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { + // Destroy object + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkSubpassContents contents) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( - VkCommandBuffer commandBuffer, - VkSubpassContents contents) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, + const VkClearColorValue* pColor, uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion( - uint32_t* pApiVersion) -{ - +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, + VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, + const void* pValues) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { + unique_lock_t lock(global_lock); + *pFramebuffer = (VkFramebuffer)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { + pGranularity->width = 1; + pGranularity->height = 1; +} +static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, + const VkViewport* pViewports) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, + const VkRect2D* pScissors) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, + float depthBiasClamp, float depthBiasSlopeFactor) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, + uint32_t compareMask) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, + uint32_t writeMask) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, + uint32_t reference) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkIndexType indexType) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, + const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, + uint32_t firstVertex, uint32_t firstInstance) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, + uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageBlit* pRegions, VkFilter filter) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, + const VkClearAttachment* pAttachments, uint32_t rectCount, + const VkClearRect* pRects) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageResolve* pRegions) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(uint32_t* pApiVersion) { *pApiVersion = VK_HEADER_VERSION_COMPLETE; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(VkDevice device, uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ -//Not a CREATE or DESTROY function -} - static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) -{ + VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { return EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); } - -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } - -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } - -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) { GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) { GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2* pFormatProperties) { GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties) -{ +static VKAPI_ATTR VkResult VKAPI_CALL +GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) { return GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) { GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); } - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) { GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } - -static VKAPI_ATTR void VKAPI_CALL TrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( - VkDevice device, - const VkDeviceQueueInfo2* pQueueInfo, - VkQueue* pQueue) -{ +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); // TODO: Add further support for GetDeviceQueue2 features } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion) -{ - unique_lock_t lock(global_lock); - *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) -{ - unique_lock_t lock(global_lock); - *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData) -{ -//Not a CREATE or DESTROY function -} - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) { constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF; if (pExternalBufferInfo->handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) { // Can't have dedicated memory with AHB - pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; + pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = pExternalBufferInfo->handleType; pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; } else if (pExternalBufferInfo->handleType & supported_flags) { @@ -1874,137 +1070,79 @@ pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; } } - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) { // Hard-code support for all handle types and features pExternalFenceProperties->exportFromImportedHandleTypes = 0xF; pExternalFenceProperties->compatibleHandleTypes = 0xF; pExternalFenceProperties->externalFenceFeatures = 0x3; } - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { // Hard code support for all handle types and features pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F; pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F; pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3; } - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport) -{ +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, + uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + unique_lock_t lock(global_lock); + *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport) { if (pSupport) { pSupport->supported = VK_TRUE; } } - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion) { unique_lock_t lock(global_lock); - *pRenderPass = (VkRenderPass)global_unique_handle++; + *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL ResetQueryPool( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { VkDeviceAddress address = 0; auto d_iter = buffer_map.find(device); if (d_iter != buffer_map.end()) { @@ -2015,300 +1153,95 @@ } return address; } - -static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot) -{ +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot) { unique_lock_t lock(global_lock); *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t data) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, + VkQueryPool queryPool, uint32_t query) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, + VkFence fence) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndRendering( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { // TODO: Just hard-coding reqs for now pMemoryRequirements->memoryRequirements.alignment = 1; pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; @@ -2316,207 +1249,180 @@ // Return a size based on the buffer size from the create info. pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096; } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo); pMemoryRequirements->memoryRequirements.alignment = 1; // Here we hard-code that the memory type at index 3 doesn't support this image. pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3); } - static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ -//Not a CREATE or DESTROY function + VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStipple( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, + const VkDependencyInfo* pDependencyInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2( - VkDevice device, - const VkMemoryMapInfo* pMemoryMapInfo, - void** ppData) -{ +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, + const VkViewport* pViewports) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, + const VkRect2D* pScissors) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, + const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, + VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { return MapMemory2KHR(device, pMemoryMapInfo, ppData); } - -static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2( - VkDevice device, - const VkMemoryUnmapInfo* pMemoryUnmapInfo) -{ +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { return UnmapMemory2KHR(device, pMemoryUnmapInfo); } - -static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkDeviceSize size, - VkIndexType indexType) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, + VkSubresourceLayout2* pLayout) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularity( - VkDevice device, - const VkRenderingAreaInfo* pRenderingAreaInfo, - VkExtent2D* pGranularity) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2(VkDevice device, VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayout( - VkDevice device, - const VkDeviceImageSubresourceInfo* pInfo, - VkSubresourceLayout2* pLayout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayout(VkDevice device, uint32_t transitionCount, + const VkHostImageLayoutTransitionInfo* pTransitions) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocations( - VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo* pLocationInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndices( - VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, uint32_t set, const void* pData) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2( - VkCommandBuffer commandBuffer, - const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2( - VkCommandBuffer commandBuffer, - const VkPushConstantsInfo* pPushConstantsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { + // Not a CREATE or DESTROY function } - static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImage( - VkDevice device, - const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, + uint16_t lineStipplePattern) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemory( - VkDevice device, - const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkDeviceSize size, VkIndexType indexType) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImage( - VkDevice device, - const VkCopyImageToImageInfo* pCopyImageToImageInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; +static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, + VkExtent2D* pGranularity) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayout( - VkDevice device, - uint32_t transitionCount, - const VkHostImageLayoutTransitionInfo* pTransitions) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo* pLocationInfo) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndices( + VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported) -{ +static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + VkSurfaceKHR surface, VkBool32* pSupported) { // Currently say that all surface/queue combos are supported *pSupported = VK_TRUE; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { // In general just say max supported is available for requested surface pSurfaceCapabilities->minImageCount = 1; pSurfaceCapabilities->maxImageCount = 0; @@ -2527,37 +1433,23 @@ pSurfaceCapabilities->maxImageExtent.width = 0xFFFF; pSurfaceCapabilities->maxImageExtent.height = 0xFFFF; pSurfaceCapabilities->maxImageArrayLayers = 128; - pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR | - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; + pSurfaceCapabilities->supportedTransforms = + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR | + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR | VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; - pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR | - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR | - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; - pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | - VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | - VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; + pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR | + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR | VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; + pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | + VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats) { // Currently always say that RGBA8 & BGRA8 are supported if (!pSurfaceFormats) { *pSurfaceFormatCount = 2; @@ -2573,13 +1465,9 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) { // Currently always say that all present modes are supported if (!pPresentModes) { *pPresentModeCount = 6; @@ -2590,116 +1478,73 @@ if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR; if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR; if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR; + *pPresentModeCount = *pPresentModeCount < 6 ? *pPresentModeCount : 6; } return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { unique_lock_t lock(global_lock); *pSwapchain = (VkSwapchainKHR)global_unique_handle++; - for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){ + for (uint32_t i = 0; i < icd_swapchain_image_count; ++i) { swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++; } return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator) -{ +static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator) { unique_lock_t lock(global_lock); swapchain_image_map.clear(); } - -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pSwapchainImageCount, - VkImage* pSwapchainImages) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { if (!pSwapchainImages) { *pSwapchainImageCount = icd_swapchain_image_count; } else { unique_lock_t lock(global_lock); - for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){ + for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i) { pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i]; } - if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE; - else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count; + if (*pSwapchainImageCount < icd_swapchain_image_count) + return VK_INCOMPLETE; + else if (*pSwapchainImageCount > icd_swapchain_image_count) + *pSwapchainImageCount = icd_swapchain_image_count; } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t timeout, - VkSemaphore semaphore, - VkFence fence, - uint32_t* pImageIndex) -{ +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, + VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { *pImageIndex = 0; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +GetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pRectCount, VkRect2D* pRects) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - uint32_t* pImageIndex) -{ +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex) { *pImageIndex = 0; return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPropertiesKHR* pProperties) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties) { if (!pProperties) { *pPropertyCount = 1; } else { @@ -2709,163 +1554,103 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlanePropertiesKHR* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( - VkPhysicalDevice physicalDevice, - uint32_t planeIndex, - uint32_t* pDisplayCount, - VkDisplayKHR* pDisplays) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, + uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModePropertiesKHR* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDisplayModeKHR* pMode) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { unique_lock_t lock(global_lock); *pMode = (VkDisplayModeKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR* pCapabilities) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchains) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains) { unique_lock_t lock(global_lock); for (uint32_t i = 0; i < swapchainCount; ++i) { pSwapchains[i] = (VkSwapchainKHR)global_unique_handle++; } return VK_SUCCESS; } - #ifdef VK_USE_PLATFORM_XLIB_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( - VkInstance instance, - const VkXlibSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - Display* dpy, - VisualID visualID) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, Display* dpy, + VisualID visualID) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_XLIB_KHR */ #ifdef VK_USE_PLATFORM_XCB_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( - VkInstance instance, - const VkXcbSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t* connection, - xcb_visualid_t visual_id) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_XCB_KHR */ #ifdef VK_USE_PLATFORM_WAYLAND_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( - VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display* display) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ #ifdef VK_USE_PLATFORM_ANDROID_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( - VkInstance instance, - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; @@ -2873,923 +1658,42 @@ #endif /* VK_USE_PLATFORM_ANDROID_KHR */ #ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( - VkInstance instance, - const VkWin32SurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WIN32_KHR */ - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - const VkVideoProfileInfoKHR* pVideoProfile, - VkVideoCapabilitiesKHR* pCapabilities) -{ - // We include some reasonable set of capability combinations to cover a wide range of use cases - auto caps = pCapabilities; - auto caps_decode = lvl_find_mod_in_chain<VkVideoDecodeCapabilitiesKHR>(pCapabilities->pNext); - auto caps_decode_h264 = lvl_find_mod_in_chain<VkVideoDecodeH264CapabilitiesKHR>(pCapabilities->pNext); - auto caps_decode_h265 = lvl_find_mod_in_chain<VkVideoDecodeH265CapabilitiesKHR>(pCapabilities->pNext); - auto caps_decode_av1 = lvl_find_mod_in_chain<VkVideoDecodeAV1CapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode = lvl_find_mod_in_chain<VkVideoEncodeCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeQuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h264_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeH264QuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h265_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeH265QuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_av1_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h264 = lvl_find_mod_in_chain<VkVideoEncodeH264CapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h265 = lvl_find_mod_in_chain<VkVideoEncodeH265CapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_av1 = lvl_find_mod_in_chain<VkVideoEncodeAV1CapabilitiesKHR>(pCapabilities->pNext); - - switch (pVideoProfile->videoCodecOperation) { - case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoDecodeH264ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_BASELINE && - profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 256; - caps->minBitstreamBufferSizeAlignment = 256; - caps->pictureAccessGranularity = {16,16}; - caps->minCodedExtent = {16,16}; - caps->maxCodedExtent = {1920,1080}; - caps->maxDpbSlots = 33; - caps->maxActiveReferencePictures = 32; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; - caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_2; - caps_decode_h264->fieldOffsetGranularity = {0,0}; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR && - profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_5_0; - caps_decode_h264->fieldOffsetGranularity = {0,16}; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR && - profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR - | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_3_2; - caps_decode_h264->fieldOffsetGranularity = {0,1}; - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoDecodeH265ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 64; - caps->minBitstreamBufferSizeAlignment = 64; - caps->pictureAccessGranularity = {32,32}; - caps->minCodedExtent = {48,48}; - caps->maxCodedExtent = {3840,2160}; - caps->maxDpbSlots = 16; - caps->maxActiveReferencePictures = 15; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; - caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_0; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_5_2; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR - | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_4_1; - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoDecodeAV1ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfile != STD_VIDEO_AV1_PROFILE_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 256; - caps->minBitstreamBufferSizeAlignment = 256; - caps->pictureAccessGranularity = {16,16}; - caps->minCodedExtent = {16,16}; - caps->maxCodedExtent = {1920,1080}; - caps->maxDpbSlots = 8; - caps->maxActiveReferencePictures = 7; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; - caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_6_2; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - if (profile->filmGrainSupport) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_5_0; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR - | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_3_2; - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoEncodeH264ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_BASELINE) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 4096; - caps->minBitstreamBufferSizeAlignment = 4096; - caps->pictureAccessGranularity = {16,16}; - caps->minCodedExtent = {160,128}; - caps->maxCodedExtent = {1920,1080}; - caps->maxDpbSlots = 10; - caps->maxActiveReferencePictures = 4; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 4; - caps_encode->maxBitrate = 800000000; - caps_encode->maxQualityLevels = 4; - caps_encode->encodeInputPictureGranularity = {16,16}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; - caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR; - caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_2; - caps_encode_h264->maxSliceCount = 8; - caps_encode_h264->maxPPictureL0ReferenceCount = 4; - caps_encode_h264->maxBPictureL0ReferenceCount = 3; - caps_encode_h264->maxL1ReferenceCount = 2; - caps_encode_h264->maxTemporalLayerCount = 4; - caps_encode_h264->expectDyadicTemporalLayerPattern = VK_FALSE; - caps_encode_h264->minQp = 0; - caps_encode_h264->maxQp = 51; - caps_encode_h264->prefersGopRemainingFrames = VK_FALSE; - caps_encode_h264->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 15) / 16, - (caps->maxCodedExtent.height + 15) / 16}; - } - - if (caps_encode_h264_quantization_map) { - caps_encode_h264_quantization_map->minQpDelta = -26; - caps_encode_h264_quantization_map->maxQpDelta = +25; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 480000000; - caps_encode->maxQualityLevels = 3; - caps_encode->encodeInputPictureGranularity = {32,32}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR; - caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_1; - caps_encode_h264->maxSliceCount = 4; - caps_encode_h264->maxPPictureL0ReferenceCount = 4; - caps_encode_h264->maxBPictureL0ReferenceCount = 0; - caps_encode_h264->maxL1ReferenceCount = 0; - caps_encode_h264->maxTemporalLayerCount = 4; - caps_encode_h264->expectDyadicTemporalLayerPattern = VK_TRUE; - caps_encode_h264->minQp = 0; - caps_encode_h264->maxQp = 30; - caps_encode_h264->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h264->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 15) / 16, - (caps->maxCodedExtent.height + 15) / 16}; - } - - if (caps_encode_h264_quantization_map) { - caps_encode_h264_quantization_map->minQpDelta = 0; - caps_encode_h264_quantization_map->maxQpDelta = 0; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_encode->flags = 0; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 240000000; - caps_encode->maxQualityLevels = 1; - caps_encode->encodeInputPictureGranularity = {1,1}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR; - caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_5_1; - caps_encode_h264->maxSliceCount = 1; - caps_encode_h264->maxPPictureL0ReferenceCount = 0; - caps_encode_h264->maxBPictureL0ReferenceCount = 2; - caps_encode_h264->maxL1ReferenceCount = 2; - caps_encode_h264->maxTemporalLayerCount = 1; - caps_encode_h264->expectDyadicTemporalLayerPattern = VK_FALSE; - caps_encode_h264->minQp = 5; - caps_encode_h264->maxQp = 40; - caps_encode_h264->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h264->requiresGopRemainingFrames = VK_TRUE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {0, 0}; - } - - if (caps_encode_h264_quantization_map) { - caps_encode_h264_quantization_map->minQpDelta = 0; - caps_encode_h264_quantization_map->maxQpDelta = 0; - } - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoEncodeH265ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 1; - caps->minBitstreamBufferSizeAlignment = 1; - caps->pictureAccessGranularity = {8,8}; - caps->minCodedExtent = {64,48}; - caps->maxCodedExtent = {4096,2560}; - caps->maxDpbSlots = 8; - caps->maxActiveReferencePictures = 2; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME, sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 800000000; - caps_encode->maxQualityLevels = 1; - caps_encode->encodeInputPictureGranularity = {64,64}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR; - caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_2; - caps_encode_h265->maxSliceSegmentCount = 8; - caps_encode_h265->maxTiles = {1,1}; - caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR - | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; - caps_encode_h265->maxPPictureL0ReferenceCount = 4; - caps_encode_h265->maxBPictureL0ReferenceCount = 3; - caps_encode_h265->maxL1ReferenceCount = 2; - caps_encode_h265->maxSubLayerCount = 1; - caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_FALSE; - caps_encode_h265->minQp = 16; - caps_encode_h265->maxQp = 32; - caps_encode_h265->prefersGopRemainingFrames = VK_FALSE; - caps_encode_h265->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 3) / 4, - (caps->maxCodedExtent.height + 3) / 4}; - } - - if (caps_encode_h265_quantization_map) { - caps_encode_h265_quantization_map->minQpDelta = -16; - caps_encode_h265_quantization_map->maxQpDelta = +15; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR; - caps_encode->maxRateControlLayers = 0; - caps_encode->maxBitrate = 480000000; - caps_encode->maxQualityLevels = 2; - caps_encode->encodeInputPictureGranularity = {32,32}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR; - caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_1; - caps_encode_h265->maxSliceSegmentCount = 4; - caps_encode_h265->maxTiles = {2,2}; - caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR - | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; - caps_encode_h265->maxPPictureL0ReferenceCount = 4; - caps_encode_h265->maxBPictureL0ReferenceCount = 0; - caps_encode_h265->maxL1ReferenceCount = 0; - caps_encode_h265->maxSubLayerCount = 1; - caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_FALSE; - caps_encode_h265->minQp = 0; - caps_encode_h265->maxQp = 51; - caps_encode_h265->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h265->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 31) / 32, - (caps->maxCodedExtent.height + 31) / 32}; - } - - if (caps_encode_h265_quantization_map) { - caps_encode_h265_quantization_map->minQpDelta = 0; - caps_encode_h265_quantization_map->maxQpDelta = 0; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 2; - caps_encode->maxBitrate = 240000000; - caps_encode->maxQualityLevels = 3; - caps_encode->encodeInputPictureGranularity = {16,16}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; - caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR; - caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_5_1; - caps_encode_h265->maxSliceSegmentCount = 1; - caps_encode_h265->maxTiles = {2,2}; - caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR; - caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; - caps_encode_h265->maxPPictureL0ReferenceCount = 0; - caps_encode_h265->maxBPictureL0ReferenceCount = 2; - caps_encode_h265->maxL1ReferenceCount = 2; - caps_encode_h265->maxSubLayerCount = 4; - caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_TRUE; - caps_encode_h265->minQp = 16; - caps_encode_h265->maxQp = 51; - caps_encode_h265->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h265->requiresGopRemainingFrames = VK_TRUE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {0, 0}; - } - - if (caps_encode_h265_quantization_map) { - caps_encode_h265_quantization_map->minQpDelta = 0; - caps_encode_h265_quantization_map->maxQpDelta = 0; - } - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoEncodeAV1ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfile != STD_VIDEO_AV1_PROFILE_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 1; - caps->minBitstreamBufferSizeAlignment = 1; - caps->pictureAccessGranularity = {8,8}; - caps->minCodedExtent = {192,128}; - caps->maxCodedExtent = {4096,2560}; - caps->maxDpbSlots = 8; - caps->maxActiveReferencePictures = 2; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME, sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 800000000; - caps_encode->maxQualityLevels = 1; - caps_encode->encodeInputPictureGranularity = {64,64}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_av1->flags = VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR; - caps_encode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_6_2; - caps_encode_av1->maxTiles = {1,1}; - caps_encode_av1->minTileSize = {64,64}; - caps_encode_av1->maxTileSize = {4096,2560}; - caps_encode_av1->superblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - caps_encode_av1->maxSingleReferenceCount = 1; - caps_encode_av1->singleReferenceNameMask = 0x7B; - caps_encode_av1->maxUnidirectionalCompoundReferenceCount = 0; - caps_encode_av1->maxUnidirectionalCompoundGroup1ReferenceCount = 0; - caps_encode_av1->unidirectionalCompoundReferenceNameMask = 0x00; - caps_encode_av1->maxBidirectionalCompoundReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup1ReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup2ReferenceCount = 0; - caps_encode_av1->bidirectionalCompoundReferenceNameMask = 0x00; - caps_encode_av1->maxTemporalLayerCount = 1; - caps_encode_av1->maxSpatialLayerCount = 1; - caps_encode_av1->maxOperatingPoints = 1; - caps_encode_av1->minQIndex = 32; - caps_encode_av1->maxQIndex = 128; - caps_encode_av1->prefersGopRemainingFrames = VK_FALSE; - caps_encode_av1->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 7) / 8, - (caps->maxCodedExtent.height + 7) / 8}; - } - - if (caps_encode_av1_quantization_map) { - caps_encode_av1_quantization_map->minQIndexDelta = -64; - caps_encode_av1_quantization_map->maxQIndexDelta = +64; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR; - caps_encode->maxRateControlLayers = 0; - caps_encode->maxBitrate = 480000000; - caps_encode->maxQualityLevels = 2; - caps_encode->encodeInputPictureGranularity = {32,32}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_av1->flags = VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR; - caps_encode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_6_1; - caps_encode_av1->maxTiles = {2,2}; - caps_encode_av1->minTileSize = {128,128}; - caps_encode_av1->maxTileSize = {4096,2048}; - caps_encode_av1->superblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR - | VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - caps_encode_av1->maxSingleReferenceCount = 0; - caps_encode_av1->singleReferenceNameMask = 0x00; - caps_encode_av1->maxUnidirectionalCompoundReferenceCount = 2; - caps_encode_av1->maxUnidirectionalCompoundGroup1ReferenceCount = 2; - caps_encode_av1->unidirectionalCompoundReferenceNameMask = 0x5F; - caps_encode_av1->maxBidirectionalCompoundReferenceCount = 2; - caps_encode_av1->maxBidirectionalCompoundGroup1ReferenceCount = 2; - caps_encode_av1->maxBidirectionalCompoundGroup2ReferenceCount = 2; - caps_encode_av1->bidirectionalCompoundReferenceNameMask = 0x5F; - caps_encode_av1->maxTemporalLayerCount = 4; - caps_encode_av1->maxSpatialLayerCount = 1; - caps_encode_av1->maxOperatingPoints = 4; - caps_encode_av1->minQIndex = 0; - caps_encode_av1->maxQIndex = 255; - caps_encode_av1->prefersGopRemainingFrames = VK_TRUE; - caps_encode_av1->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 63) / 64, - (caps->maxCodedExtent.height + 63) / 64}; - } - - if (caps_encode_av1_quantization_map) { - caps_encode_av1_quantization_map->minQIndexDelta = -255; - caps_encode_av1_quantization_map->maxQIndexDelta = +255; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 2; - caps_encode->maxBitrate = 240000000; - caps_encode->maxQualityLevels = 3; - caps_encode->encodeInputPictureGranularity = {16,16}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; - caps_encode_av1->flags = VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR; - caps_encode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_5_1; - caps_encode_av1->maxTiles = {4,4}; - caps_encode_av1->minTileSize = {128,128}; - caps_encode_av1->maxTileSize = {2048,2048}; - caps_encode_av1->superblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - caps_encode_av1->maxSingleReferenceCount = 1; - caps_encode_av1->singleReferenceNameMask = 0x5F; - caps_encode_av1->maxUnidirectionalCompoundReferenceCount = 4; - caps_encode_av1->maxUnidirectionalCompoundGroup1ReferenceCount = 4; - caps_encode_av1->unidirectionalCompoundReferenceNameMask = 0x5B; - caps_encode_av1->maxBidirectionalCompoundReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup1ReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup2ReferenceCount = 0; - caps_encode_av1->bidirectionalCompoundReferenceNameMask = 0x00; - caps_encode_av1->maxTemporalLayerCount = 4; - caps_encode_av1->maxSpatialLayerCount = 2; - caps_encode_av1->maxOperatingPoints = 2; - caps_encode_av1->minQIndex = 16; - caps_encode_av1->maxQIndex = 96; - caps_encode_av1->prefersGopRemainingFrames = VK_TRUE; - caps_encode_av1->requiresGopRemainingFrames = VK_TRUE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 127) / 128, - (caps->maxCodedExtent.height + 127) / 128}; - } - - if (caps_encode_av1_quantization_map) { - caps_encode_av1_quantization_map->minQIndexDelta = -64; - caps_encode_av1_quantization_map->maxQIndexDelta = +63; - } - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - default: - break; - } - return VK_SUCCESS; +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; } - static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, - uint32_t* pVideoFormatPropertyCount, - VkVideoFormatPropertiesKHR* pVideoFormatProperties) -{ - // We include some reasonable set of format combinations to cover a wide range of use cases - auto profile_list = lvl_find_in_chain<VkVideoProfileListInfoKHR>(pVideoFormatInfo->pNext); - if (profile_list->profileCount != 1) { - return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR; - } - - struct VideoFormatProperties { - VkVideoFormatPropertiesKHR props; - VkVideoFormatQuantizationMapPropertiesKHR props_quantization_map; - VkVideoFormatH265QuantizationMapPropertiesKHR props_h265_quantization_map; - VkVideoFormatAV1QuantizationMapPropertiesKHR props_av1_quantization_map; - }; - - std::vector<VideoFormatProperties> format_props{}; - - VideoFormatProperties fmt = {}; - fmt.props.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; - fmt.props.imageCreateFlags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_ALIAS_BIT | - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT | VK_IMAGE_CREATE_PROTECTED_BIT | VK_IMAGE_CREATE_DISJOINT_BIT; - fmt.props.imageType = VK_IMAGE_TYPE_2D; - fmt.props.imageTiling = VK_IMAGE_TILING_OPTIMAL; - fmt.props_quantization_map.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; - fmt.props_h265_quantization_map.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; - fmt.props_av1_quantization_map.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; - - // Populate DPB and input/output formats - switch (profile_list->pProfiles[0].videoCodecOperation) { - case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - - default: - break; - } - - // Populate quantization map formats - fmt.props.imageCreateFlags = VK_IMAGE_CREATE_PROTECTED_BIT; - fmt.props.imageTiling = VK_IMAGE_TILING_LINEAR; - switch (profile_list->pProfiles[0].videoCodecOperation) { - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {16, 16}; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {16, 16}; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - break; - default: - break; - } - break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {4, 4}; - fmt.props_h265_quantization_map.compatibleCtbSizes = - VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {8, 8}; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {32, 32}; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_h265_quantization_map.compatibleCtbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {32, 32}; - fmt.props_h265_quantization_map.compatibleCtbSizes = - VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_h265_quantization_map.compatibleCtbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - break; - default: - break; - } - break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {8, 8}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {128, 128}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {128, 128}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - format_props.push_back(fmt); - break; - default: - break; - } - break; - - default: - break; - } - - std::vector<VideoFormatProperties> filtered; - for (const auto& format : format_props) { - if ((pVideoFormatInfo->imageUsage & format.props.imageUsageFlags) == pVideoFormatInfo->imageUsage) { - filtered.push_back(format); - } - } - - if (pVideoFormatProperties != nullptr) { - for (uint32_t i = 0; i < (std::min)(*pVideoFormatPropertyCount, (uint32_t)filtered.size()); ++i) { - void* saved_pNext = pVideoFormatProperties[i].pNext; - pVideoFormatProperties[i] = filtered[i].props; - pVideoFormatProperties[i].pNext = saved_pNext; - - auto* props_quantization_map = lvl_find_mod_in_chain<VkVideoFormatQuantizationMapPropertiesKHR>(saved_pNext); - auto* props_h265_quantization_map = lvl_find_mod_in_chain<VkVideoFormatH265QuantizationMapPropertiesKHR>(saved_pNext); - auto* props_av1_quantization_map = lvl_find_mod_in_chain<VkVideoFormatAV1QuantizationMapPropertiesKHR>(saved_pNext); - - if (props_quantization_map != nullptr) { - saved_pNext = props_quantization_map->pNext; - *props_quantization_map = filtered[i].props_quantization_map; - props_quantization_map->pNext = saved_pNext; - } - - if (props_h265_quantization_map != nullptr) { - saved_pNext = props_h265_quantization_map->pNext; - *props_h265_quantization_map = filtered[i].props_h265_quantization_map; - props_h265_quantization_map->pNext = saved_pNext; - } - - if (props_av1_quantization_map != nullptr) { - saved_pNext = props_av1_quantization_map->pNext; - *props_av1_quantization_map = filtered[i].props_av1_quantization_map; - props_av1_quantization_map->pNext = saved_pNext; - } - } - } - *pVideoFormatPropertyCount = (uint32_t)filtered.size(); - return VK_SUCCESS; + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR( - VkDevice device, - const VkVideoSessionCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionKHR* pVideoSession) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession) { unique_lock_t lock(global_lock); *pVideoSession = (VkVideoSessionKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t* pMemoryRequirementsCount, - VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) -{ +static VKAPI_ATTR VkResult VKAPI_CALL +GetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) { if (!pMemoryRequirements) { *pMemoryRequirementsCount = 1; } else { @@ -3801,99 +1705,56 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t bindSessionMemoryInfoCount, - const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR( - VkDevice device, - const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionParametersKHR* pVideoSessionParameters) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR(VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters) { unique_lock_t lock(global_lock); *pVideoSessionParameters = (VkVideoSessionParametersKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR(VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR(VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoBeginCodingInfoKHR* pBeginInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoEndCodingInfoKHR* pEndCodingInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoCodingControlInfoKHR* pCodingControlInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoDecodeInfoKHR* pDecodeInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) { GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); - uint32_t num_bools = 0; // Count number of VkBool32s in extension structs + uint32_t num_bools = 0; // Count number of VkBool32s in extension structs VkBool32* feat_bools = nullptr; auto vk_1_1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Features>(pFeatures->pNext); if (vk_1_1_features) { @@ -3915,48 +1776,47 @@ if (video_maintenance1_features) { video_maintenance1_features->videoMaintenance1 = VK_TRUE; } - const auto *desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext); + const auto* desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext); if (desc_idx_features) { - const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing); - num_bools = bool_size/sizeof(VkBool32); + const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - + offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing); + num_bools = bool_size / sizeof(VkBool32); feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing; SetBoolArrayTrue(feat_bools, num_bools); } - const auto *blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext); + const auto* blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext); if (blendop_features) { - const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations); - num_bools = bool_size/sizeof(VkBool32); + const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - + offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations); + num_bools = bool_size / sizeof(VkBool32); feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations; SetBoolArrayTrue(feat_bools, num_bools); } - const auto *host_image_copy_features = lvl_find_in_chain<VkPhysicalDeviceHostImageCopyFeaturesEXT>(pFeatures->pNext); + const auto* host_image_copy_features = lvl_find_in_chain<VkPhysicalDeviceHostImageCopyFeaturesEXT>(pFeatures->pNext); if (host_image_copy_features) { - feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy; - SetBoolArrayTrue(feat_bools, 1); + feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy; + SetBoolArrayTrue(feat_bools, 1); } } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) { // The only value that need to be set are those the Profile layer can't set // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352 // All values set are arbitrary GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); - auto *props_11 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Properties>(pProperties->pNext); + auto* props_11 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Properties>(pProperties->pNext); if (props_11) { props_11->protectedNoFault = VK_FALSE; } - auto *props_12 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan12Properties>(pProperties->pNext); + auto* props_12 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan12Properties>(pProperties->pNext); if (props_12) { props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; } - auto *props_13 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Properties>(pProperties->pNext); + auto* props_13 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Properties>(pProperties->pNext); if (props_13) { props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; @@ -3964,18 +1824,19 @@ props_13->uniformTexelBufferOffsetAlignmentBytes = 16; } - auto *protected_memory_props = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryProperties>(pProperties->pNext); + auto* protected_memory_props = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryProperties>(pProperties->pNext); if (protected_memory_props) { protected_memory_props->protectedNoFault = VK_FALSE; } - auto *float_controls_props = lvl_find_mod_in_chain<VkPhysicalDeviceFloatControlsProperties>(pProperties->pNext); + auto* float_controls_props = lvl_find_mod_in_chain<VkPhysicalDeviceFloatControlsProperties>(pProperties->pNext); if (float_controls_props) { float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; } - auto *conservative_raster_props = lvl_find_mod_in_chain<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(pProperties->pNext); + auto* conservative_raster_props = + lvl_find_mod_in_chain<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(pProperties->pNext); if (conservative_raster_props) { conservative_raster_props->primitiveOverestimationSize = 0.00195313f; conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE; @@ -3983,20 +1844,20 @@ conservative_raster_props->degenerateLinesRasterized = VK_TRUE; } - auto *rt_pipeline_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(pProperties->pNext); + auto* rt_pipeline_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(pProperties->pNext); if (rt_pipeline_props) { rt_pipeline_props->shaderGroupHandleSize = 32; rt_pipeline_props->shaderGroupBaseAlignment = 64; rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32; } - auto *rt_pipeline_nv_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPropertiesNV>(pProperties->pNext); + auto* rt_pipeline_nv_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPropertiesNV>(pProperties->pNext); if (rt_pipeline_nv_props) { rt_pipeline_nv_props->shaderGroupHandleSize = 32; rt_pipeline_nv_props->shaderGroupBaseAlignment = 64; } - auto *texel_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceTexelBufferAlignmentProperties>(pProperties->pNext); + auto* texel_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceTexelBufferAlignmentProperties>(pProperties->pNext); if (texel_buffer_props) { texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; @@ -4004,7 +1865,7 @@ texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16; } - auto *descriptor_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(pProperties->pNext); + auto* descriptor_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(pProperties->pNext); if (descriptor_buffer_props) { descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE; descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE; @@ -4012,7 +1873,7 @@ descriptor_buffer_props->descriptorBufferOffsetAlignment = 4; } - auto *mesh_shader_props = lvl_find_mod_in_chain<VkPhysicalDeviceMeshShaderPropertiesEXT>(pProperties->pNext); + auto* mesh_shader_props = lvl_find_mod_in_chain<VkPhysicalDeviceMeshShaderPropertiesEXT>(pProperties->pNext); if (mesh_shader_props) { mesh_shader_props->meshOutputPerVertexGranularity = 32; mesh_shader_props->meshOutputPerPrimitiveGranularity = 32; @@ -4022,7 +1883,7 @@ mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE; } - auto *fragment_density_map2_props = lvl_find_mod_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext); + auto* fragment_density_map2_props = lvl_find_mod_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext); if (fragment_density_map2_props) { fragment_density_map2_props->subsampledLoads = VK_FALSE; fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE; @@ -4030,34 +1891,40 @@ fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1; } + auto* maintenance3_props = lvl_find_mod_in_chain<VkPhysicalDeviceMaintenance3Properties>(pProperties->pNext); + if (maintenance3_props) { + maintenance3_props->maxMemoryAllocationSize = 1073741824; + maintenance3_props->maxPerSetDescriptors = 1024; + } + const uint32_t num_copy_layouts = 5; const VkImageLayout HostCopyLayouts[]{ - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_GENERAL, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, }; - auto *host_image_copy_props = lvl_find_mod_in_chain<VkPhysicalDeviceHostImageCopyPropertiesEXT>(pProperties->pNext); - if (host_image_copy_props){ - if (host_image_copy_props->pCopyDstLayouts == nullptr) host_image_copy_props->copyDstLayoutCount = num_copy_layouts; + auto* host_image_copy_props = lvl_find_mod_in_chain<VkPhysicalDeviceHostImageCopyPropertiesEXT>(pProperties->pNext); + if (host_image_copy_props) { + if (host_image_copy_props->pCopyDstLayouts == nullptr) + host_image_copy_props->copyDstLayoutCount = num_copy_layouts; else { uint32_t num_layouts = (std::min)(host_image_copy_props->copyDstLayoutCount, num_copy_layouts); for (uint32_t i = 0; i < num_layouts; i++) { host_image_copy_props->pCopyDstLayouts[i] = HostCopyLayouts[i]; } } - if (host_image_copy_props->pCopySrcLayouts == nullptr) host_image_copy_props->copySrcLayoutCount = num_copy_layouts; + if (host_image_copy_props->pCopySrcLayouts == nullptr) + host_image_copy_props->copySrcLayoutCount = num_copy_layouts; else { uint32_t num_layouts = (std::min)(host_image_copy_props->copySrcLayoutCount, num_copy_layouts); - for (uint32_t i = 0; i < num_layouts; i++) { + for (uint32_t i = 0; i < num_layouts; i++) { host_image_copy_props->pCopySrcLayouts[i] = HostCopyLayouts[i]; } } } - auto *driver_properties = lvl_find_mod_in_chain<VkPhysicalDeviceDriverProperties>(pProperties->pNext); + auto* driver_properties = lvl_find_mod_in_chain<VkPhysicalDeviceDriverProperties>(pProperties->pNext); if (driver_properties) { std::strncpy(driver_properties->driverName, "Vulkan Mock Device", VK_MAX_DRIVER_NAME_SIZE); #if defined(GIT_BRANCH_NAME) && defined(GIT_TAG_INFO) @@ -4066,15 +1933,22 @@ std::strncpy(driver_properties->driverInfo, "Branch: --unknown-- Tag Info: --unknown--", VK_MAX_DRIVER_INFO_SIZE); #endif } -} -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties) -{ + auto* layered_properties = lvl_find_mod_in_chain<VkPhysicalDeviceLayeredApiPropertiesListKHR>(pProperties->pNext); + if (layered_properties) { + layered_properties->layeredApiCount = 1; + if (layered_properties->pLayeredApis) { + layered_properties->pLayeredApis[0] = + VkPhysicalDeviceLayeredApiPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR, nullptr, + 0xba5eba11, 0xf005ba11, VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR}; + std::strncpy(layered_properties->pLayeredApis[0].deviceName, "Fake Driver", VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + } + } +} +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2* pFormatProperties) { GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties); - VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext); + VkFormatProperties3KHR* props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext); if (props_3) { props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures; props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures; @@ -4082,53 +1956,51 @@ props_3->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT; } } - static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties) -{ - auto *external_image_prop = lvl_find_mod_in_chain<VkExternalImageFormatProperties>(pImageFormatProperties->pNext); - auto *external_image_format = lvl_find_in_chain<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo->pNext); + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) { + auto* external_image_prop = lvl_find_mod_in_chain<VkExternalImageFormatProperties>(pImageFormatProperties->pNext); + auto* external_image_format = lvl_find_in_chain<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo->pNext); if (external_image_prop && external_image_format) { - external_image_prop->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; + external_image_prop->externalMemoryProperties.externalMemoryFeatures = + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; external_image_prop->externalMemoryProperties.compatibleHandleTypes = external_image_format->handleType; } - GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties); + GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, + pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, + &pImageFormatProperties->imageFormatProperties); return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) { if (pQueueFamilyProperties) { if (*pQueueFamilyPropertyCount >= 1) { auto props = &pQueueFamilyProperties[0].queueFamilyProperties; - props->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT - | VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_PROTECTED_BIT; + props->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT | + VK_QUEUE_PROTECTED_BIT; props->queueCount = 1; props->timestampValidBits = 16; - props->minImageTransferGranularity = {1,1,1}; + props->minImageTransferGranularity = {1, 1, 1}; } if (*pQueueFamilyPropertyCount >= 2) { auto props = &pQueueFamilyProperties[1].queueFamilyProperties; props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_DECODE_BIT_KHR; props->queueCount = 1; props->timestampValidBits = 16; - props->minImageTransferGranularity = {1,1,1}; + props->minImageTransferGranularity = {1, 1, 1}; - auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[1].pNext); + auto status_query_props = + lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[1].pNext); if (status_query_props) { status_query_props->queryResultStatusSupport = VK_TRUE; } auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[1].pNext); if (video_props) { - video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR; + video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR | + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR | + VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR; } } if (*pQueueFamilyPropertyCount >= 3) { @@ -4136,17 +2008,18 @@ props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_ENCODE_BIT_KHR; props->queueCount = 1; props->timestampValidBits = 16; - props->minImageTransferGranularity = {1,1,1}; + props->minImageTransferGranularity = {1, 1, 1}; - auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[2].pNext); + auto status_query_props = + lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[2].pNext); if (status_query_props) { status_query_props->queryResultStatusSupport = VK_TRUE; } auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[2].pNext); if (video_props) { - video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR; + video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR | + VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR | + VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR; } } if (*pQueueFamilyPropertyCount > 3) { @@ -4156,73 +2029,40 @@ *pQueueFamilyPropertyCount = 3; } } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties) -{ +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties); } - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) { if (pPropertyCount && pProperties) { - GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, &pProperties->properties); + GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, + pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, + &pProperties->properties); } else { - GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr); + GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, + pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr); } } - - -static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, + uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( - VkCommandBuffer commandBuffer, - uint32_t deviceMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, + uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { + // Not a CREATE or DESTROY function } - - static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) -{ + VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { if (!pPhysicalDeviceGroupProperties) { *pPhysicalDeviceGroupCount = 1; } else { @@ -4233,269 +2073,144 @@ } return VK_SUCCESS; } - - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) { GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } - - #ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( - VkDevice device, - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) -{ +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { pMemoryWin32HandleProperties->memoryTypeBits = 0xFFFF; return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( - VkDevice device, - const VkMemoryGetFdInfoKHR* pGetFdInfo, - int* pFd) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { *pFd = 1; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - int fd, - VkMemoryFdPropertiesKHR* pMemoryFdProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, + int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -#ifdef VK_USE_PLATFORM_WIN32_KHR -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } - - #ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( - VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( - VkDevice device, - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( - VkDevice device, - const VkSemaphoreGetFdInfoKHR* pGetFdInfo, - int* pFd) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, uint32_t set, const void* pData) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { unique_lock_t lock(global_lock); *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { unique_lock_t lock(global_lock); *pRenderPass = (VkRenderPass)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties) -{ + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) { GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } - - #ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( - VkDevice device, - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +ImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( - VkDevice device, - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) { *pHandle = (HANDLE)0x12345678; return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( - VkDevice device, - const VkImportFenceFdInfoKHR* pImportFenceFdInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( - VkDevice device, - const VkFenceGetFdInfoKHR* pGetFdInfo, - int* pFd) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { *pFd = 0x42; return VK_SUCCESS; } - - static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t* pCounterCount, - VkPerformanceCounterKHR* pCounters, - VkPerformanceCounterDescriptionKHR* pCounterDescriptions) -{ + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions) { if (!pCounters) { *pCounterCount = 3; } else { - if (*pCounterCount == 0){ + if (*pCounterCount == 0) { return VK_INCOMPLETE; } // arbitrary @@ -4503,14 +2218,14 @@ pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR; pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; pCounters[0].uuid[0] = 0x01; - if (*pCounterCount == 1){ + if (*pCounterCount == 1) { return VK_INCOMPLETE; } pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR; pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; pCounters[1].uuid[0] = 0x02; - if (*pCounterCount == 2){ + if (*pCounterCount == 2) { return VK_INCOMPLETE; } pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; @@ -4521,42 +2236,26 @@ } return VK_SUCCESS; } - static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - VkPhysicalDevice physicalDevice, - const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, - uint32_t* pNumPasses) -{ + VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) { if (pNumPasses) { // arbitrary *pNumPasses = 1; } } - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR( - VkDevice device, - const VkAcquireProfilingLockInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR( - VkDevice device) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(VkDevice device) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities); - auto *present_mode_compatibility = lvl_find_mod_in_chain<VkSurfacePresentModeCompatibilityEXT>(pSurfaceCapabilities->pNext); + auto* present_mode_compatibility = lvl_find_mod_in_chain<VkSurfacePresentModeCompatibilityEXT>(pSurfaceCapabilities->pNext); if (present_mode_compatibility) { if (!present_mode_compatibility->pPresentModes) { present_mode_compatibility->presentModeCount = 3; @@ -4569,13 +2268,10 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats) { // Currently always say that RGBA8 & BGRA8 are supported if (!pSurfaceFormats) { *pSurfaceFormatCount = 2; @@ -4593,201 +2289,101 @@ } return VK_SUCCESS; } - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayProperties2KHR* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlaneProperties2KHR* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModeProperties2KHR* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR* pCapabilities) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - - -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements); } - -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); } - static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ + VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) { - GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements); + GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, + &pSparseMemoryRequirements->memoryRequirements); } else { GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr); } } - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion) { unique_lock_t lock(global_lock); *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - - -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -#ifdef VK_ENABLE_BETA_EXTENSIONS -#endif /* VK_ENABLE_BETA_EXTENSIONS */ - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport) -{ +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport) { GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, uint32_t stride) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride) { + // Not a CREATE or DESTROY function } - - - - - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pFragmentShadingRateCount, - VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) -{ +static VKAPI_ATTR VkResult VKAPI_CALL +GetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) { if (!pFragmentShadingRates) { *pFragmentShadingRateCount = 1; } else { @@ -4797,424 +2393,326 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR( - VkCommandBuffer commandBuffer, - const VkExtent2D* pFragmentSize, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR( - VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo* pLocationInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo* pLocationInfo) { + // Not a CREATE or DESTROY function } - static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndicesKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { + // Not a CREATE or DESTROY function } - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t presentId, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, + uint64_t timeout) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { return GetBufferDeviceAddress(device, pInfo); } - -static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR( - VkDevice device, - const VkAllocationCallbacks* pAllocator, - VkDeferredOperationKHR* pDeferredOperation) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation) { unique_lock_t lock(global_lock); *pDeferredOperation = (VkDeferredOperationKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR( - VkDevice device, - VkDeferredOperationKHR operation, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR( - VkDevice device, - VkDeferredOperationKHR operation) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR( - VkDevice device, - VkDeferredOperationKHR operation) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR( - VkDevice device, - VkDeferredOperationKHR operation) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( - VkDevice device, - const VkPipelineInfoKHR* pPipelineInfo, - uint32_t* pExecutableCount, - VkPipelineExecutablePropertiesKHR* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pStatisticCount, - VkPipelineExecutableStatisticKHR* pStatistics) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pInternalRepresentationCount, - VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) -{ -//Not a CREATE or DESTROY function + VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR( - VkDevice device, - const VkMemoryMapInfo* pMemoryMapInfo, - void** ppData) -{ +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData); } - -static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR( - VkDevice device, - const VkMemoryUnmapInfo* pMemoryUnmapInfo) -{ +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { UnmapMemory(device, pMemoryUnmapInfo->memory); return VK_SUCCESS; } - - - - - - static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, - VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) -{ -//Not a CREATE or DESTROY function + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetEncodedVideoSessionParametersKHR( - VkDevice device, - const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, - VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +GetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoEncodeInfoKHR* pEncodeInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, + const VkDependencyInfo* pDependencyInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, + VkQueryPool queryPool, uint32_t query) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, + VkFence fence) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer3KHR(VkCommandBuffer commandBuffer, const VkBindIndexBuffer3InfoKHR* pInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers3KHR(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, const VkBindVertexBuffer3InfoKHR* pBindingInfos) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect2KHR(VkCommandBuffer commandBuffer, const VkDispatchIndirect2InfoKHR* pInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryKHR(VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectDeviceAddress) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageKHR(VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToMemoryKHR(VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdUpdateMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, VkDeviceSize dataSize, const void* pData) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdFillMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, uint32_t data) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResultsToMemoryKHR(VkCommandBuffer commandBuffer, VkQueryPool queryPool, + uint32_t firstQuery, uint32_t queryCount, + const VkStridedDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkQueryResultFlags queryResultFlags) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount2KHR(VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount2KHR(VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRendering2EXT( + VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCount2EXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, + uint32_t firstInstance, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo, + uint32_t counterOffset, uint32_t vertexStride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirect2EXT(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCount2EXT(VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdWriteMarkerToMemoryAMD(VkCommandBuffer commandBuffer, const VkMemoryMarkerInfoAMD* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructure2KHR(VkDevice device, + const VkAccelerationStructureCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure) { + unique_lock_t lock(global_lock); + *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); } - static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ -//Not a CREATE or DESTROY function + VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + // Not a CREATE or DESTROY function } - - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkDeviceSize size, - VkIndexType indexType) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkDeviceSize size, VkIndexType indexType) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR( - VkDevice device, - const VkRenderingAreaInfo* pRenderingAreaInfo, - VkExtent2D* pGranularity) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, + VkExtent2D* pGranularity) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR( - VkDevice device, - const VkDeviceImageSubresourceInfo* pInfo, - VkSubresourceLayout2* pLayout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, + VkSubresourceLayout2* pLayout) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR(VkDevice device, VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR( - VkDevice device, - const VkPipelineBinaryCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineBinaryHandlesInfoKHR* pBinaries) -{ +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, + const VkPresentWait2InfoKHR* pPresentWait2Info) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineBinaryHandlesInfoKHR* pBinaries) { unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) { - pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++; + if (pBinaries->pPipelineBinaries != nullptr) { + for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) { + pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++; + } + } else { + // In this case, we need to return a return count, let's set it to 3 + pBinaries->pipelineBinaryCount = 3; } return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR( - VkDevice device, - VkPipelineBinaryKHR pipelineBinary, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR( - VkDevice device, - const VkPipelineCreateInfoKHR* pPipelineCreateInfo, - VkPipelineBinaryKeyKHR* pPipelineKey) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, + VkPipelineBinaryKeyKHR* pPipelineKey) { + if (pPipelineKey != nullptr) { + pPipelineKey->keySize = 16; + std::memset(pPipelineKey->key, 0x12, pPipelineKey->keySize); + } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR( - VkDevice device, - const VkPipelineBinaryDataInfoKHR* pInfo, - VkPipelineBinaryKeyKHR* pPipelineBinaryKey, - size_t* pPipelineBinaryDataSize, - void* pPipelineBinaryData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, + VkPipelineBinaryKeyKHR* pPipelineBinaryKey, + size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) { + static uint32_t fake_size = 64; + if (pPipelineBinaryDataSize != nullptr) { + if (pPipelineBinaryData == nullptr) { + *pPipelineBinaryDataSize = fake_size; + } else { + std::memset(pPipelineBinaryData, 0xABCD, fake_size); + } + } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR( - VkDevice device, - const VkReleaseCapturedPipelineDataInfoKHR* pInfo, - const VkAllocationCallbacks* pAllocator) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR(VkDevice device, + const VkReleaseCapturedPipelineDataInfoKHR* pInfo, + const VkAllocationCallbacks* pAllocator) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesKHR(VkDevice device, + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesKHR* pProperties) -{ + VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) { if (!pProperties) { *pPropertyCount = 2; } else { @@ -5234,30 +2732,13 @@ } return VK_SUCCESS; } - - - - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, + uint16_t lineStipplePattern) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainKHR* pTimeDomains) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains) { if (!pTimeDomains) { *pTimeDomainCount = 1; } else { @@ -5266,567 +2747,296 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, uint64_t* pMaxDeviation) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR( - VkCommandBuffer commandBuffer, - const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR( - VkCommandBuffer commandBuffer, - const VkPushConstantsInfo* pPushConstantsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfo* pPushConstantsInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { + // Not a CREATE or DESTROY function } - static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { + // Not a CREATE or DESTROY function } - static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( - VkCommandBuffer commandBuffer, - const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) { + // Not a CREATE or DESTROY function } - static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( - VkCommandBuffer commandBuffer, - const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( - VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugReportCallbackEXT* pCallback) -{ +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, + const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectKHR( + VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultReportsKHR(VkDevice device, uint64_t timeout, uint32_t* pFaultCounts, + VkDeviceFaultInfoKHR* pFaultInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultDebugInfoKHR(VkDevice device, VkDeviceFaultDebugInfoKHR* pDebugInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2KHR(VkCommandBuffer commandBuffer, + const VkRenderingEndInfoKHR* pRenderingEndInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback) { unique_lock_t lock(global_lock); *pCallback = (VkDebugReportCallbackEXT)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( - VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( - VkInstance instance, - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, + int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { + // Not a CREATE or DESTROY function } - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( - VkDevice device, - const VkDebugMarkerObjectTagInfoEXT* pTagInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( - VkDevice device, - const VkDebugMarkerObjectNameInfoEXT* pNameInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + // Not a CREATE or DESTROY function } - - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, + uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, + uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags, - uint32_t index) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, + VkQueryControlFlags flags, uint32_t index) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - uint32_t index) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, + uint32_t index) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT( - VkCommandBuffer commandBuffer, - uint32_t instanceCount, - uint32_t firstInstance, - VkBuffer counterBuffer, - VkDeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, + uint32_t firstInstance, VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, uint32_t counterOffset, + uint32_t vertexStride) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX( - VkDevice device, - const VkCuModuleCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuModuleNVX* pModule) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) { unique_lock_t lock(global_lock); *pModule = (VkCuModuleNVX)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX( - VkDevice device, - const VkCuFunctionCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuFunctionNVX* pFunction) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) { unique_lock_t lock(global_lock); *pFunction = (VkCuFunctionNVX)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX( - VkDevice device, - VkCuModuleNVX module, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX( - VkDevice device, - VkCuFunctionNVX function, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX( - VkCommandBuffer commandBuffer, - const VkCuLaunchInfoNVX* pLaunchInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR uint64_t VKAPI_CALL GetImageViewHandle64NVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint64_t VKAPI_CALL GetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( - VkDevice device, - VkImageView imageView, - VkImageViewAddressPropertiesNVX* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(VkDevice device, VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( - VkDevice device, - VkPipeline pipeline, - VkShaderStageFlagBits shaderStage, - VkShaderInfoTypeAMD infoType, - size_t* pInfoSize, - void* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, + uint64_t samplerIndex) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + VkBuffer countBuffer, VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} #ifdef VK_USE_PLATFORM_GGP - -static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( - VkInstance instance, - const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_GGP */ - - - - static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) -{ -//Not a CREATE or DESTROY function + VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, + VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - #ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - HANDLE* pHandle) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WIN32_KHR */ -#ifdef VK_USE_PLATFORM_WIN32_KHR -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - #ifdef VK_USE_PLATFORM_VI_NN - -static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( - VkInstance instance, - const VkViSurfaceCreateInfoNN* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_VI_NN */ - - - - - - - static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( - VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportWScalingNV* pViewportWScalings) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, + uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - RROutput rrOutput, - VkDisplayKHR* pDisplay) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, + VkDisplayKHR* pDisplay) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayPowerInfoEXT* pDisplayPowerInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( - VkDevice device, - const VkDeviceEventInfoEXT* pDeviceEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT* pDisplayEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) -{ +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, VkFence* pFence) { unique_lock_t lock(global_lock); *pFence = (VkFence)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - uint64_t* pCounterValue) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( - VkCommandBuffer commandBuffer, - uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const VkRect2D* pDiscardRectangles) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 discardRectangleEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT( - VkCommandBuffer commandBuffer, - VkDiscardRectangleModeEXT discardRectangleMode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainKHR* pSwapchains, - const VkHdrMetadataEXT* pMetadata) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata) { + // Not a CREATE or DESTROY function } - - #ifdef VK_USE_PLATFORM_IOS_MVK - -static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( - VkInstance instance, - const VkIOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; @@ -5834,518 +3044,320 @@ #endif /* VK_USE_PLATFORM_IOS_MVK */ #ifdef VK_USE_PLATFORM_MACOS_MVK - -static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( - VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_MACOS_MVK */ - - - - -static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( - VkDevice device, - const VkDebugUtilsObjectNameInfoEXT* pNameInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( - VkDevice device, - const VkDebugUtilsObjectTagInfoEXT* pTagInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( - VkQueue queue) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(VkQueue queue) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( - VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pMessenger) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger) { unique_lock_t lock(global_lock); *pMessenger = (VkDebugUtilsMessengerEXT)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( - VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( - VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { + // Not a CREATE or DESTROY function } - #ifdef VK_USE_PLATFORM_ANDROID_KHR - static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( - VkDevice device, - const struct AHardwareBuffer* buffer, - VkAndroidHardwareBufferPropertiesANDROID* pProperties) -{ + VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { pProperties->allocationSize = 65536; - pProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type + pProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type - auto *format_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties->pNext); + auto* format_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties->pNext); if (format_prop) { // Likley using this format format_prop->format = VK_FORMAT_R8G8B8A8_UNORM; format_prop->externalFormat = 37; } - auto *format_resolve_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(pProperties->pNext); + auto* format_resolve_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(pProperties->pNext); if (format_resolve_prop) { format_resolve_prop->colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM; } return VK_SUCCESS; } - static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( - VkDevice device, - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, - struct AHardwareBuffer** pBuffer) -{ -//Not a CREATE or DESTROY function + VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_ANDROID_KHR */ - - #ifdef VK_ENABLE_BETA_EXTENSIONS - -static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) { unique_lock_t lock(global_lock); for (uint32_t i = 0; i < createInfoCount; ++i) { pPipelines[i] = (VkPipeline)global_unique_handle++; } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX( - VkDevice device, - VkPipeline executionGraph, - VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph, + VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineNodeIndexAMDX( - VkDevice device, - VkPipeline executionGraph, - const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, - uint32_t* pNodeIndex) -{ -//Not a CREATE or DESTROY function + VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX( - VkCommandBuffer commandBuffer, - VkPipeline executionGraph, - VkDeviceAddress scratch, - VkDeviceSize scratchSize) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph, + VkDeviceAddress scratch, VkDeviceSize scratchSize) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX* pCountInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, + VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX* pCountInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, + VkDeviceSize scratchSize, + const VkDispatchGraphCountInfoAMDX* pCountInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - VkDeviceAddress countInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, + VkDeviceSize scratchSize, VkDeviceAddress countInfo) { + // Not a CREATE or DESTROY function } #endif /* VK_ENABLE_BETA_EXTENSIONS */ - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( - VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT* pSampleLocationsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL WriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount, + const VkSamplerCreateInfo* pSamplers, + const VkHostAddressRangeEXT* pDescriptors) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( - VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT* pMultisampleProperties) -{ +static VKAPI_ATTR VkResult VKAPI_CALL WriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount, + const VkResourceDescriptorInfoEXT* pResources, + const VkHostAddressRangeEXT* pDescriptors) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages, + VkHostAddressRangeEXT* pDatas) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, + VkDescriptorType descriptorType) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL RegisterCustomBorderColorEXT(VkDevice device, + const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, + VkBool32 requestIndex, uint32_t* pIndex) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL UnregisterCustomBorderColorEXT(VkDevice device, uint32_t index) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, + const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties) { if (pMultisampleProperties) { // arbitrary pMultisampleProperties->maxSampleLocationGridSize = {32, 32}; } } - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( - VkDevice device, - VkImage image, - VkImageDrmFormatModifierPropertiesEXT* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( - VkDevice device, - const VkValidationCacheCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkValidationCacheEXT* pValidationCache) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache) { unique_lock_t lock(global_lock); *pValidationCache = (VkValidationCacheEXT)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( - VkDevice device, - VkValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const VkValidationCacheEXT* pSrcCaches) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, + size_t* pDataSize, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, + VkImageLayout imageLayout) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkShadingRatePaletteNV* pShadingRatePalettes) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( - VkCommandBuffer commandBuffer, - VkCoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( - VkDevice device, - const VkAccelerationStructureCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureNV* pAccelerationStructure) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure) { unique_lock_t lock(global_lock); *pAccelerationStructure = (VkAccelerationStructureNV)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( - VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements) -{ + VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) { // arbitrary pMemoryRequirements->memoryRequirements.size = 4096; pMemoryRequirements->memoryRequirements.alignment = 1; pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; } - -static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( - VkDevice device, - uint32_t bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV( - VkCommandBuffer commandBuffer, - const VkAccelerationStructureInfoNV* pInfo, - VkBuffer instanceData, - VkDeviceSize instanceOffset, - VkBool32 update, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkBuffer scratch, - VkDeviceSize scratchOffset) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, + VkDeviceSize instanceOffset, VkBool32 update, + VkAccelerationStructureNV dst, VkAccelerationStructureNV src, + VkBuffer scratch, VkDeviceSize scratchOffset) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( - VkCommandBuffer commandBuffer, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkCopyAccelerationStructureModeKHR mode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV( - VkCommandBuffer commandBuffer, - VkBuffer raygenShaderBindingTableBuffer, - VkDeviceSize raygenShaderBindingOffset, - VkBuffer missShaderBindingTableBuffer, - VkDeviceSize missShaderBindingOffset, - VkDeviceSize missShaderBindingStride, - VkBuffer hitShaderBindingTableBuffer, - VkDeviceSize hitShaderBindingOffset, - VkDeviceSize hitShaderBindingStride, - VkBuffer callableShaderBindingTableBuffer, - VkDeviceSize callableShaderBindingOffset, - VkDeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, + uint32_t width, uint32_t height, uint32_t depth) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoNV* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { unique_lock_t lock(global_lock); for (uint32_t i = 0; i < createInfoCount; ++i) { pPipelines[i] = (VkPipeline)global_unique_handle++; } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, + uint32_t groupCount, size_t dataSize, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, + uint32_t groupCount, size_t dataSize, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureNV* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( - VkDevice device, - VkPipeline pipeline, - uint32_t shader) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHostPointer, - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) -{ - pMemoryHostPointerProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { + pMemoryHostPointerProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type return VK_SUCCESS; } - - -static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainKHR* pTimeDomains) -{ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains) { if (!pTimeDomains) { *pTimeDomainCount = 1; } else { @@ -6354,195 +3366,120 @@ } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, uint64_t* pMaxDeviation) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - -#ifdef VK_USE_PLATFORM_GGP -#endif /* VK_USE_PLATFORM_GGP */ - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV( - VkCommandBuffer commandBuffer, - uint32_t taskCount, - uint32_t firstTask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride) { + // Not a CREATE or DESTROY function } - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkBool32* pExclusiveScissorEnables) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkRect2D* pExclusiveScissors) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( - VkCommandBuffer commandBuffer, - const void* pCheckpointMarker) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointDataNV* pCheckpointData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointData2NV* pCheckpointData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( - VkDevice device, - const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, + uint32_t size) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( - VkDevice device) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceMarkerInfoINTEL* pMarkerInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, + VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, + uint64_t* pSwapchainTimingPropertiesCounter) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimeDomainPropertiesEXT( + VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, + uint64_t* pTimeDomainsCounter) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceOverrideInfoINTEL* pOverrideInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +GetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, + VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( - VkDevice device, - const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, - VkPerformanceConfigurationINTEL* pConfiguration) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( - VkDevice device, - VkPerformanceConfigurationINTEL configuration) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(VkDevice device) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( - VkQueue queue, - VkPerformanceConfigurationINTEL configuration) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( - VkDevice device, - VkPerformanceParameterTypeINTEL parameter, - VkPerformanceValueINTEL* pValue) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - -static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( - VkDevice device, - VkSwapchainKHR swapChain, - VkBool32 localDimmingEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +AcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - +static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(VkDevice device, + VkPerformanceConfigurationINTEL configuration) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(VkQueue queue, + VkPerformanceConfigurationINTEL configuration) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { + // Not a CREATE or DESTROY function +} #ifdef VK_USE_PLATFORM_FUCHSIA - -static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( - VkInstance instance, - const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; @@ -6550,1998 +3487,1306 @@ #endif /* VK_USE_PLATFORM_FUCHSIA */ #ifdef VK_USE_PLATFORM_METAL_EXT - -static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( - VkInstance instance, - const VkMetalSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_METAL_EXT */ - - - - - - - - - - - - - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { return GetBufferDeviceAddress(device, pInfo); } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesNV* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - VkPhysicalDevice physicalDevice, - uint32_t* pCombinationCount, - VkFramebufferMixedSamplesCombinationNV* pCombinations) -{ -//Not a CREATE or DESTROY function + VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - #ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( - VkDevice device, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkDeviceGroupPresentModeFlagsKHR* pModes) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( - VkInstance instance, - const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, + uint16_t lineStipplePattern) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, + uint32_t queryCount) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, + const VkViewport* pViewports) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, + const VkRect2D* pScissors) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, + uint32_t bindingCount, const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, + VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT( - VkDevice device, - const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT( - VkDevice device, - const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT( - VkDevice device, - const VkCopyImageToImageInfo* pCopyImageToImageInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT( - VkDevice device, - uint32_t transitionCount, - const VkHostImageLayoutTransitionInfo* pTransitions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, + const VkHostImageLayoutTransitionInfo* pTransitions) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT(VkDevice device, VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( - VkDevice device, - const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT(VkDevice device, + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - -static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline, - uint32_t groupIndex) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, uint32_t groupIndex) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) { unique_lock_t lock(global_lock); *pIndirectCommandsLayout = (VkIndirectCommandsLayoutNV)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV( - VkDevice device, - VkIndirectCommandsLayoutNV indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT( - VkCommandBuffer commandBuffer, - const VkDepthBiasInfoEXT* pDepthBiasInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - uint32_t connectorId, - VkDisplayKHR* display) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, + VkDisplayKHR* display) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot) { unique_lock_t lock(global_lock); *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t data) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV( - VkDevice device, - const VkCudaModuleCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCudaModuleNV* pModule) -{ +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerfHintQCOM(VkQueue queue, const VkPerfHintInfoQCOM* pPerfHintInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#ifdef VK_ENABLE_BETA_EXTENSIONS +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) { unique_lock_t lock(global_lock); *pModule = (VkCudaModuleNV)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV( - VkDevice device, - VkCudaModuleNV module, - size_t* pCacheSize, - void* pCacheData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, + void* pCacheData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV( - VkDevice device, - const VkCudaFunctionCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCudaFunctionNV* pFunction) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) { unique_lock_t lock(global_lock); *pFunction = (VkCudaFunctionNV)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV( - VkDevice device, - VkCudaModuleNV module, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV( - VkDevice device, - VkCudaFunctionNV function, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV( - VkCommandBuffer commandBuffer, - const VkCudaLaunchInfoNV* pLaunchInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) { + // Not a CREATE or DESTROY function } - - +#endif /* VK_ENABLE_BETA_EXTENSIONS */ +static VKAPI_ATTR void VKAPI_CALL CmdDispatchTileQCOM(VkCommandBuffer commandBuffer, + const VkDispatchTileInfoQCOM* pDispatchTileInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, + const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, + const VkPerTileEndInfoQCOM* pPerTileEndInfo) { + // Not a CREATE or DESTROY function +} #ifdef VK_USE_PLATFORM_METAL_EXT - -static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT( - VkDevice device, - VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) { + // Not a CREATE or DESTROY function } #endif /* VK_USE_PLATFORM_METAL_EXT */ - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT( - VkDevice device, - VkDescriptorSetLayout layout, - VkDeviceSize* pLayoutSizeInBytes) -{ +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes) { // Need to give something non-zero *pLayoutSizeInBytes = 4; } - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT( - VkDevice device, - VkDescriptorSetLayout layout, - uint32_t binding, - VkDeviceSize* pOffset) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, + uint32_t binding, VkDeviceSize* pOffset) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT( - VkDevice device, - const VkDescriptorGetInfoEXT* pDescriptorInfo, - size_t dataSize, - void* pDescriptor) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, + void* pDescriptor) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t bufferCount, - const VkDescriptorBufferBindingInfoEXT* pBindingInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const uint32_t* pBufferIndices, - const VkDeviceSize* pOffsets) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, + uint32_t firstSet, uint32_t setCount, + const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkBufferCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +GetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function + VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV( - VkCommandBuffer commandBuffer, - VkFragmentShadingRateNV shadingRate, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + // Not a CREATE or DESTROY function } - - - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( - VkDevice device, - VkDeviceFaultCountsEXT* pFaultCounts, - VkDeviceFaultInfoEXT* pFaultInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - #ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - uint32_t deviceRelativeId, - VkDisplayKHR* pDisplay) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_WIN32_KHR */ #ifdef VK_USE_PLATFORM_DIRECTFB_EXT - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT( - VkInstance instance, - const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - IDirectFB* dfb) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, IDirectFB* dfb) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_DIRECTFB_EXT */ - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT( - VkCommandBuffer commandBuffer, - uint32_t vertexBindingDescriptionCount, - const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) { + // Not a CREATE or DESTROY function } - - - - - - #ifdef VK_USE_PLATFORM_FUCHSIA - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( - VkDevice device, - const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - zx_handle_t zirconHandle, - VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } -#endif /* VK_USE_PLATFORM_FUCHSIA */ - -#ifdef VK_USE_PLATFORM_FUCHSIA - static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) -{ -//Not a CREATE or DESTROY function + VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle) -{ -//Not a CREATE or DESTROY function + VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } -#endif /* VK_USE_PLATFORM_FUCHSIA */ - -#ifdef VK_USE_PLATFORM_FUCHSIA - -static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA( - VkDevice device, - const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferCollectionFUCHSIA* pCollection) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection) { unique_lock_t lock(global_lock); *pCollection = (VkBufferCollectionFUCHSIA)global_unique_handle++; return VK_SUCCESS; } - static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) -{ -//Not a CREATE or DESTROY function + VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) -{ -//Not a CREATE or DESTROY function + VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - VkBufferCollectionPropertiesFUCHSIA* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_FUCHSIA */ - - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - VkDevice device, - VkRenderPass renderpass, - VkExtent2D* pMaxWorkgroupSize) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, + VkImageLayout imageLayout) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV( - VkDevice device, - const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, - VkRemoteAddressNV* pAddress) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT( - VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, - VkBaseOutStructure* pPipelineProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT( - VkCommandBuffer commandBuffer, - uint32_t patchControlPoints) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT( - VkCommandBuffer commandBuffer, - VkLogicOp logicOp) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + // Not a CREATE or DESTROY function } - #ifdef VK_USE_PLATFORM_SCREEN_QNX - -static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX( - VkInstance instance, - const VkScreenSurfaceCreateInfoQNX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { unique_lock_t lock(global_lock); *pSurface = (VkSurfaceKHR)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct _screen_window* window) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } #endif /* VK_USE_PLATFORM_SCREEN_QNX */ - - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkBool32* pColorWriteEnables) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, + const VkBool32* pColorWriteEnables) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawInfoEXT* pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, + uint32_t firstInstance, uint32_t stride) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawIndexedInfoEXT* pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t* pVertexOffset) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, + uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) { + // Not a CREATE or DESTROY function } - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( - VkDevice device, - const VkMicromapCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkMicromapEXT* pMicromap) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) { unique_lock_t lock(global_lock); *pMicromap = (VkMicromapEXT)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( - VkDevice device, - VkMicromapEXT micromap, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapToMemoryInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( - VkDevice device, - uint32_t micromapCount, - const VkMicromapEXT* pMicromaps, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, VkQueryType queryType, + size_t dataSize, void* pData, size_t stride) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapToMemoryInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( - VkCommandBuffer commandBuffer, - uint32_t micromapCount, - const VkMicromapEXT* pMicromaps, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, VkQueryType queryType, + VkQueryPool queryPool, uint32_t firstQuery) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( - VkDevice device, - const VkMicromapVersionInfoEXT* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkMicromapBuildInfoEXT* pBuildInfo, - VkMicromapBuildSizesInfoEXT* pSizeInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo) { + // Not a CREATE or DESTROY function } - -#ifdef VK_ENABLE_BETA_EXTENSIONS -#endif /* VK_ENABLE_BETA_EXTENSIONS */ - - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset) { + // Not a CREATE or DESTROY function } - - - -static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( - VkDevice device, - VkDeviceMemory memory, - float priority) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) { + // Not a CREATE or DESTROY function } - - - - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( - VkDevice device, - const VkDescriptorSetBindingReferenceVALVE* pBindingReference, - VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDispatchParametersARM(VkCommandBuffer commandBuffer, + const VkDispatchParametersARM* pDispatchParameters) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( - VkDevice device, - VkDescriptorSet descriptorSet, - void** ppData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL +GetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { + // Not a CREATE or DESTROY function } - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - VkImage dstImage, - VkImageLayout dstImageLayout, - const VkImageSubresourceLayers* pImageSubresources) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, + uint32_t copyCount, uint32_t stride) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV( - VkCommandBuffer commandBuffer, - uint32_t decompressRegionCount, - const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, + uint32_t copyCount, uint32_t stride, VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectCommandsAddress, - VkDeviceAddress indirectCommandsCountAddress, - uint32_t stride) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV( - VkDevice device, - const VkComputePipelineCreateInfo* pCreateInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV(VkDevice device, + const VkComputePipelineCreateInfo* pCreateInfo, + VkMemoryRequirements2* pMemoryRequirements) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetPipelineIndirectDeviceAddressNV( - VkDevice device, - const VkPipelineIndirectDeviceAddressInfoNV* pInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL +GetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClampEnable) -{ -//Not a CREATE or DESTROY function +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( - VkCommandBuffer commandBuffer, - VkPolygonMode polygonMode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits rasterizationSamples) -{ -//Not a CREATE or DESTROY function +#endif /* VK_USE_PLATFORM_OHOS */ +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits samples, - const VkSampleMask* pSampleMask) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToCoverageEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToOneEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 logicOpEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkBool32* pColorBlendEnables) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendEquationEXT* pColorBlendEquations) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorComponentFlags* pColorWriteMasks) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, const VkBool32* pColorBlendEnables) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( - VkCommandBuffer commandBuffer, - VkTessellationDomainOrigin domainOrigin) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( - VkCommandBuffer commandBuffer, - uint32_t rasterizationStream) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) { + // Not a CREATE or DESTROY function } - +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) { + // Not a CREATE or DESTROY function +} static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkConservativeRasterizationModeEXT conservativeRasterizationMode) -{ -//Not a CREATE or DESTROY function + VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( - VkCommandBuffer commandBuffer, - float extraPrimitiveOverestimationSize) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClipEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 sampleLocationsEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendAdvancedEXT* pColorBlendAdvanced) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( - VkCommandBuffer commandBuffer, - VkProvokingVertexModeEXT provokingVertexMode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkLineRasterizationModeEXT lineRasterizationMode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stippledLineEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( - VkCommandBuffer commandBuffer, - VkBool32 negativeOneToOne) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 viewportWScalingEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportSwizzleNV* pViewportSwizzles) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, + uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageToColorEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( - VkCommandBuffer commandBuffer, - uint32_t coverageToColorLocation) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( - VkCommandBuffer commandBuffer, - VkCoverageModulationModeNV coverageModulationMode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageModulationTableEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( - VkCommandBuffer commandBuffer, - uint32_t coverageModulationTableCount, - const float* pCoverageModulationTable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 shadingRateImageEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 representativeFragmentTestEnable) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( - VkCommandBuffer commandBuffer, - VkCoverageReductionModeNV coverageReductionMode) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode) { + // Not a CREATE or DESTROY function } - - - - -static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( - VkDevice device, - VkShaderModule shaderModule, - VkShaderModuleIdentifierEXT* pIdentifier) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) { + unique_lock_t lock(global_lock); + *pTensor = (VkTensorARM)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) { + unique_lock_t lock(global_lock); + *pView = (VkTensorViewARM)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL GetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL BindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, + const VkBindTensorMemoryInfoARM* pBindInfos) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL GetDeviceTensorMemoryRequirementsARM(VkDevice device, + const VkDeviceTensorMemoryRequirementsARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalTensorPropertiesARM( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, + VkExternalTensorPropertiesARM* pExternalTensorProperties) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, + const VkTensorCaptureDescriptorDataInfoARM* pInfo, + void* pData) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL +GetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier) { if (pIdentifier) { // arbitrary pIdentifier->identifierSize = 1; pIdentifier->identifier[0] = 0x01; } } - -static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModuleIdentifierEXT* pIdentifier) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT(VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier) { + // Not a CREATE or DESTROY function } - - - static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( - VkPhysicalDevice physicalDevice, - const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, - uint32_t* pFormatCount, - VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) -{ -//Not a CREATE or DESTROY function + VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( - VkDevice device, - const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkOpticalFlowSessionNV* pSession) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV(VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession) { unique_lock_t lock(global_lock); *pSession = (VkOpticalFlowSessionNV)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( - VkDevice device, - VkOpticalFlowSessionNV session, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( - VkDevice device, - VkOpticalFlowSessionNV session, - VkOpticalFlowSessionBindingPointNV bindingPoint, - VkImageView view, - VkImageLayout layout) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, VkImageLayout layout) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( - VkCommandBuffer commandBuffer, - VkOpticalFlowSessionNV session, - const VkOpticalFlowExecuteInfoNV* pExecuteInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { + // Not a CREATE or DESTROY function } - - - -#ifdef VK_USE_PLATFORM_ANDROID_KHR -#endif /* VK_USE_PLATFORM_ANDROID_KHR */ - - -static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD( - VkDevice device, - const VkAntiLagDataAMD* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT( - VkDevice device, - uint32_t createInfoCount, - const VkShaderCreateInfoEXT* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkShaderEXT* pShaders) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT(VkDevice device, uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) { unique_lock_t lock(global_lock); for (uint32_t i = 0; i < createInfoCount; ++i) { pShaders[i] = (VkShaderEXT)global_unique_handle++; } return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT( - VkDevice device, - VkShaderEXT shader, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) { + // Destroy object } - -static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT( - VkDevice device, - VkShaderEXT shader, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( - VkCommandBuffer commandBuffer, - uint32_t stageCount, - const VkShaderStageFlagBits* pStages, - const VkShaderEXT* pShaders) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, + const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT( - VkCommandBuffer commandBuffer, - VkDepthClampModeEXT depthClampMode, - const VkDepthClampRangeEXT* pDepthClampRange) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( - VkDevice device, - VkFramebuffer framebuffer, - uint32_t* pPropertiesCount, - VkTilePropertiesQCOM* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( - VkDevice device, - const VkRenderingInfo* pRenderingInfo, - VkTilePropertiesQCOM* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - - - - - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkLatencySleepModeInfoNV* pSleepModeInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeVectorPropertiesNV* pProperties) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkLatencySleepInfoNV* pSleepInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL ConvertCooperativeVectorMatrixNV(VkDevice device, + const VkConvertCooperativeVectorMatrixInfoNV* pInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL CmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount, + const VkConvertCooperativeVectorMatrixInfoNV* pInfos) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV( - VkDevice device, - VkSwapchainKHR swapchain, - VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV( - VkQueue queue, - const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) -{ -//Not a CREATE or DESTROY function -} - - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( - VkCommandBuffer commandBuffer, - VkImageAspectFlags aspectMask) -{ -//Not a CREATE or DESTROY function -} - -#ifdef VK_USE_PLATFORM_SCREEN_QNX - -static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX( - VkDevice device, - const struct _screen_buffer* buffer, - VkScreenBufferPropertiesQNX* pProperties) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, + const VkLatencySleepModeInfoNV* pSleepModeInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } -#endif /* VK_USE_PLATFORM_SCREEN_QNX */ - - - - - - - - - - -static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, - VkCommandBuffer stateCommandBuffer) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) -{ - unique_lock_t lock(global_lock); - *pIndirectCommandsLayout = (VkIndirectCommandsLayoutEXT)global_unique_handle++; +static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, + const VkLatencySleepInfoNV* pSleepInfo) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT( - VkDevice device, - VkIndirectCommandsLayoutEXT indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, + const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT( - VkDevice device, - const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectExecutionSetEXT* pIndirectExecutionSet) -{ - unique_lock_t lock(global_lock); - *pIndirectExecutionSet = (VkIndirectExecutionSetEXT)global_unique_handle++; - return VK_SUCCESS; +static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, + VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object +static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) { + // Not a CREATE or DESTROY function } - -static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) -{ -//Not a CREATE or DESTROY function -} - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( - VkDevice device, - const VkAccelerationStructureCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureKHR* pAccelerationStructure) -{ - unique_lock_t lock(global_lock); - *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( - VkDevice device, - VkAccelerationStructureKHR accelerationStructure, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkDeviceAddress* pIndirectDeviceAddresses, - const uint32_t* pIndirectStrides, - const uint32_t* const* ppMaxPrimitiveCounts) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( - VkDevice device, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( - VkDevice device, - const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) -{ - // arbitrary - need to be aligned to 256 bytes - return 0x262144; -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( - VkDevice device, - const VkAccelerationStructureVersionInfoKHR* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, - const uint32_t* pMaxPrimitiveCounts, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) -{ - // arbitrary - pSizeInfo->accelerationStructureSize = 4; - pSizeInfo->updateScratchSize = 4; - pSizeInfo->buildScratchSize = 4; -} - - -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ +static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, uint32_t createInfoCount, + const VkDataGraphPipelineCreateInfoARM* pCreateInfos, + const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { unique_lock_t lock(global_lock); for (uint32_t i = 0; i < createInfoCount; ++i) { pPipelines[i] = (VkPipeline)global_unique_handle++; } return VK_SUCCESS; } - -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelineSessionARM(VkDevice device, + const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDataGraphPipelineSessionARM* pSession) { + unique_lock_t lock(global_lock); + *pSession = (VkDataGraphPipelineSessionARM)global_unique_handle++; return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - VkDeviceAddress indirectDeviceAddress) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t group, - VkShaderGroupShaderKHR groupShader) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineSessionBindPointRequirementsARM( + VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, + VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) { + // Not a CREATE or DESTROY function return VK_SUCCESS; } - -static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR( - VkCommandBuffer commandBuffer, - uint32_t pipelineStackSize) -{ -//Not a CREATE or DESTROY function +static VKAPI_ATTR void VKAPI_CALL GetDataGraphPipelineSessionMemoryRequirementsARM( + VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL BindDataGraphPipelineSessionMemoryARM( + VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL CmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, + const VkDataGraphPipelineDispatchInfoARM* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineAvailablePropertiesARM(VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t* pPropertiesCount, + VkDataGraphPipelinePropertyARM* pProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelinePropertiesARM(VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t propertiesCount, + VkDataGraphPipelinePropertyQueryResultARM* pProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, + VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, + VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, VkBaseOutStructure* pProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask) { + // Not a CREATE or DESTROY function +} +#ifdef VK_USE_PLATFORM_SCREEN_QNX +static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ +static VKAPI_ATTR void VKAPI_CALL CmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer, + const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryEXT(VkCommandBuffer commandBuffer, + const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer, + VkMemoryDecompressionMethodFlagsEXT decompressionMethod, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateExternalComputeQueueNV(VkDevice device, + const VkExternalComputeQueueCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkExternalComputeQueueNV* pExternalQueue) { + unique_lock_t lock(global_lock); + *pExternalQueue = (VkExternalComputeQueueNV)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL GetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue, + VkExternalComputeQueueDataParamsNV* params, void* pData) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL GetClusterAccelerationStructureBuildSizesNV( + VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBuildClusterAccelerationStructureIndirectNV( + VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL +GetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBuildPartitionedAccelerationStructuresNV( + VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT( + VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT(VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) { + unique_lock_t lock(global_lock); + *pIndirectCommandsLayout = (VkIndirectCommandsLayoutEXT)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT(VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT(VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet) { + unique_lock_t lock(global_lock); + *pIndirectExecutionSet = (VkIndirectExecutionSetEXT)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT( + VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT( + VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) { + // Not a CREATE or DESTROY function +} +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_OHOS */ +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#ifdef VK_USE_PLATFORM_METAL_EXT +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryMetalHandleEXT(VkDevice device, + const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, + void** pHandle) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL +GetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, + VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_METAL_EXT */ +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, + VkPerformanceCounterDescriptionARM* pCounterDescriptions) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceShaderInstrumentationMetricsARM( + VkPhysicalDevice physicalDevice, uint32_t* pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM* pDescriptions) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderInstrumentationARM(VkDevice device, + const VkShaderInstrumentationCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderInstrumentationARM* pInstrumentation) { + unique_lock_t lock(global_lock); + *pInstrumentation = (VkShaderInstrumentationARM)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyShaderInstrumentationARM(VkDevice device, VkShaderInstrumentationARM instrumentation, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL CmdBeginShaderInstrumentationARM(VkCommandBuffer commandBuffer, + VkShaderInstrumentationARM instrumentation) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdEndShaderInstrumentationARM(VkCommandBuffer commandBuffer) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInstrumentationValuesARM(VkDevice device, VkShaderInstrumentationARM instrumentation, + uint32_t* pMetricBlockCount, void* pMetricValues, + VkShaderInstrumentationValuesFlagsARM flags) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL ClearShaderInstrumentationMetricsARM(VkDevice device, + VkShaderInstrumentationARM instrumentation) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2EXT(VkCommandBuffer commandBuffer, + const VkRenderingEndInfoKHR* pRenderingEndInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, + const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer, + const VkComputeOccupancyPriorityParametersNV* pParameters) { + // Not a CREATE or DESTROY function +} +#ifdef VK_USE_PLATFORM_UBM_SEC +static VKAPI_ATTR VkResult VKAPI_CALL CreateUbmSurfaceSEC(VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceUbmPresentationSupportSEC(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct ubm_device* device) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_UBM_SEC */ +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartIndexEXT(VkCommandBuffer commandBuffer, uint32_t primitiveRestartIndex) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure) { + unique_lock_t lock(global_lock); + *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++; + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator) { + // Destroy object +} +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( + VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL +BuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( + VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( + VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( + VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL +GetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { + // arbitrary - need to be aligned to 256 bytes + return 0x262144; +} +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL +GetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( + VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + // arbitrary + pSizeInfo->accelerationStructureSize = 4; + pSizeInfo->updateScratchSize = 4; + pSizeInfo->buildScratchSize = 4; +} +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, uint32_t height, uint32_t depth) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) { + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, + uint32_t firstGroup, uint32_t groupCount, + size_t dataSize, void* pData) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, + VkShaderGroupShaderKHR groupShader) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} +static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, + uint32_t drawCount, uint32_t stride) { + // Not a CREATE or DESTROY function +} +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, + VkDeviceSize offset, VkBuffer countBuffer, + VkDeviceSize countBufferOffset, uint32_t maxDrawCount, + uint32_t stride) { + // Not a CREATE or DESTROY function } - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -} // namespace vkmock - +} // namespace vkmock
diff --git a/icd/generated/vk_typemap_helper.h b/icd/generated/vk_typemap_helper.h index 1286375..5eeb73e 100644 --- a/icd/generated/vk_typemap_helper.h +++ b/icd/generated/vk_typemap_helper.h
@@ -1,7 +1,6 @@ // *** THIS FILE IS GENERATED - DO NOT EDIT *** // See vulkan_tools_helper_file_generator.py for modifications - /*************************************************************************** * * Copyright (c) 2015-2017 The Khronos Group Inc. @@ -36,8903 +35,13839 @@ // members and for each sType -- providing a two way map between structure // types and sTypes -template <VkStructureType id> struct LvlSTypeMap {}; -template <typename T> struct LvlTypeMap {}; - -// Map type VkBufferMemoryBarrier to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER -template <> struct LvlTypeMap<VkBufferMemoryBarrier> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER> { - typedef VkBufferMemoryBarrier Type; -}; - -// Map type VkImageMemoryBarrier to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER -template <> struct LvlTypeMap<VkImageMemoryBarrier> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER> { - typedef VkImageMemoryBarrier Type; -}; - -// Map type VkMemoryBarrier to id VK_STRUCTURE_TYPE_MEMORY_BARRIER -template <> struct LvlTypeMap<VkMemoryBarrier> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER> { - typedef VkMemoryBarrier Type; -}; +template <VkStructureType id> +struct LvlSTypeMap {}; +template <typename T> +struct LvlTypeMap {}; // Map type VkApplicationInfo to id VK_STRUCTURE_TYPE_APPLICATION_INFO -template <> struct LvlTypeMap<VkApplicationInfo> { +template <> +struct LvlTypeMap<VkApplicationInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_APPLICATION_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_APPLICATION_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_APPLICATION_INFO> { typedef VkApplicationInfo Type; }; // Map type VkInstanceCreateInfo to id VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO -template <> struct LvlTypeMap<VkInstanceCreateInfo> { +template <> +struct LvlTypeMap<VkInstanceCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO> { typedef VkInstanceCreateInfo Type; }; // Map type VkDeviceQueueCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO -template <> struct LvlTypeMap<VkDeviceQueueCreateInfo> { +template <> +struct LvlTypeMap<VkDeviceQueueCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO> { typedef VkDeviceQueueCreateInfo Type; }; // Map type VkDeviceCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO -template <> struct LvlTypeMap<VkDeviceCreateInfo> { +template <> +struct LvlTypeMap<VkDeviceCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO> { typedef VkDeviceCreateInfo Type; }; // Map type VkSubmitInfo to id VK_STRUCTURE_TYPE_SUBMIT_INFO -template <> struct LvlTypeMap<VkSubmitInfo> { +template <> +struct LvlTypeMap<VkSubmitInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBMIT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBMIT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBMIT_INFO> { typedef VkSubmitInfo Type; }; // Map type VkMappedMemoryRange to id VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE -template <> struct LvlTypeMap<VkMappedMemoryRange> { +template <> +struct LvlTypeMap<VkMappedMemoryRange> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE> { typedef VkMappedMemoryRange Type; }; // Map type VkMemoryAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO -template <> struct LvlTypeMap<VkMemoryAllocateInfo> { +template <> +struct LvlTypeMap<VkMemoryAllocateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO> { typedef VkMemoryAllocateInfo Type; }; // Map type VkBindSparseInfo to id VK_STRUCTURE_TYPE_BIND_SPARSE_INFO -template <> struct LvlTypeMap<VkBindSparseInfo> { +template <> +struct LvlTypeMap<VkBindSparseInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_SPARSE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_SPARSE_INFO> { typedef VkBindSparseInfo Type; }; // Map type VkFenceCreateInfo to id VK_STRUCTURE_TYPE_FENCE_CREATE_INFO -template <> struct LvlTypeMap<VkFenceCreateInfo> { +template <> +struct LvlTypeMap<VkFenceCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_CREATE_INFO> { typedef VkFenceCreateInfo Type; }; // Map type VkSemaphoreCreateInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO -template <> struct LvlTypeMap<VkSemaphoreCreateInfo> { +template <> +struct LvlTypeMap<VkSemaphoreCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO> { typedef VkSemaphoreCreateInfo Type; }; -// Map type VkEventCreateInfo to id VK_STRUCTURE_TYPE_EVENT_CREATE_INFO -template <> struct LvlTypeMap<VkEventCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EVENT_CREATE_INFO> { - typedef VkEventCreateInfo Type; -}; - // Map type VkQueryPoolCreateInfo to id VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO -template <> struct LvlTypeMap<VkQueryPoolCreateInfo> { +template <> +struct LvlTypeMap<VkQueryPoolCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO> { typedef VkQueryPoolCreateInfo Type; }; // Map type VkBufferCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO -template <> struct LvlTypeMap<VkBufferCreateInfo> { +template <> +struct LvlTypeMap<VkBufferCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO> { typedef VkBufferCreateInfo Type; }; -// Map type VkBufferViewCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO -template <> struct LvlTypeMap<VkBufferViewCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO> { - typedef VkBufferViewCreateInfo Type; -}; - // Map type VkImageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO -template <> struct LvlTypeMap<VkImageCreateInfo> { +template <> +struct LvlTypeMap<VkImageCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO> { typedef VkImageCreateInfo Type; }; // Map type VkImageViewCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO -template <> struct LvlTypeMap<VkImageViewCreateInfo> { +template <> +struct LvlTypeMap<VkImageViewCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO> { typedef VkImageViewCreateInfo Type; }; -// Map type VkShaderModuleCreateInfo to id VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO -template <> struct LvlTypeMap<VkShaderModuleCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO> { - typedef VkShaderModuleCreateInfo Type; -}; - -// Map type VkPipelineCacheCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineCacheCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO> { - typedef VkPipelineCacheCreateInfo Type; -}; - -// Map type VkPipelineShaderStageCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineShaderStageCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO> { - typedef VkPipelineShaderStageCreateInfo Type; -}; - -// Map type VkComputePipelineCreateInfo to id VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO -template <> struct LvlTypeMap<VkComputePipelineCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO> { - typedef VkComputePipelineCreateInfo Type; -}; - -// Map type VkPipelineVertexInputStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineVertexInputStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO> { - typedef VkPipelineVertexInputStateCreateInfo Type; -}; - -// Map type VkPipelineInputAssemblyStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineInputAssemblyStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO> { - typedef VkPipelineInputAssemblyStateCreateInfo Type; -}; - -// Map type VkPipelineTessellationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineTessellationStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO> { - typedef VkPipelineTessellationStateCreateInfo Type; -}; - -// Map type VkPipelineViewportStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineViewportStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO> { - typedef VkPipelineViewportStateCreateInfo Type; -}; - -// Map type VkPipelineRasterizationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineRasterizationStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO> { - typedef VkPipelineRasterizationStateCreateInfo Type; -}; - -// Map type VkPipelineMultisampleStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineMultisampleStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO> { - typedef VkPipelineMultisampleStateCreateInfo Type; -}; - -// Map type VkPipelineDepthStencilStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineDepthStencilStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO> { - typedef VkPipelineDepthStencilStateCreateInfo Type; -}; - -// Map type VkPipelineColorBlendStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineColorBlendStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO> { - typedef VkPipelineColorBlendStateCreateInfo Type; -}; - -// Map type VkPipelineDynamicStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineDynamicStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO> { - typedef VkPipelineDynamicStateCreateInfo Type; -}; - -// Map type VkGraphicsPipelineCreateInfo to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO -template <> struct LvlTypeMap<VkGraphicsPipelineCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO> { - typedef VkGraphicsPipelineCreateInfo Type; -}; - -// Map type VkPipelineLayoutCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineLayoutCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO> { - typedef VkPipelineLayoutCreateInfo Type; -}; - -// Map type VkSamplerCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO -template <> struct LvlTypeMap<VkSamplerCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO> { - typedef VkSamplerCreateInfo Type; -}; - -// Map type VkCopyDescriptorSet to id VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET -template <> struct LvlTypeMap<VkCopyDescriptorSet> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET> { - typedef VkCopyDescriptorSet Type; -}; - -// Map type VkDescriptorPoolCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO -template <> struct LvlTypeMap<VkDescriptorPoolCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO> { - typedef VkDescriptorPoolCreateInfo Type; -}; - -// Map type VkDescriptorSetAllocateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO -template <> struct LvlTypeMap<VkDescriptorSetAllocateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO> { - typedef VkDescriptorSetAllocateInfo Type; -}; - -// Map type VkDescriptorSetLayoutCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO -template <> struct LvlTypeMap<VkDescriptorSetLayoutCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO> { - typedef VkDescriptorSetLayoutCreateInfo Type; -}; - -// Map type VkWriteDescriptorSet to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET -template <> struct LvlTypeMap<VkWriteDescriptorSet> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET> { - typedef VkWriteDescriptorSet Type; -}; - -// Map type VkFramebufferCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO -template <> struct LvlTypeMap<VkFramebufferCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO> { - typedef VkFramebufferCreateInfo Type; -}; - -// Map type VkRenderPassCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO -template <> struct LvlTypeMap<VkRenderPassCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO> { - typedef VkRenderPassCreateInfo Type; -}; - // Map type VkCommandPoolCreateInfo to id VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO -template <> struct LvlTypeMap<VkCommandPoolCreateInfo> { +template <> +struct LvlTypeMap<VkCommandPoolCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO> { typedef VkCommandPoolCreateInfo Type; }; // Map type VkCommandBufferAllocateInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO -template <> struct LvlTypeMap<VkCommandBufferAllocateInfo> { +template <> +struct LvlTypeMap<VkCommandBufferAllocateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO> { typedef VkCommandBufferAllocateInfo Type; }; // Map type VkCommandBufferInheritanceInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO -template <> struct LvlTypeMap<VkCommandBufferInheritanceInfo> { +template <> +struct LvlTypeMap<VkCommandBufferInheritanceInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO> { typedef VkCommandBufferInheritanceInfo Type; }; // Map type VkCommandBufferBeginInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO -template <> struct LvlTypeMap<VkCommandBufferBeginInfo> { +template <> +struct LvlTypeMap<VkCommandBufferBeginInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO> { typedef VkCommandBufferBeginInfo Type; }; +// Map type VkBufferMemoryBarrier to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER +template <> +struct LvlTypeMap<VkBufferMemoryBarrier> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER> { + typedef VkBufferMemoryBarrier Type; +}; + +// Map type VkImageMemoryBarrier to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER +template <> +struct LvlTypeMap<VkImageMemoryBarrier> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER> { + typedef VkImageMemoryBarrier Type; +}; + +// Map type VkMemoryBarrier to id VK_STRUCTURE_TYPE_MEMORY_BARRIER +template <> +struct LvlTypeMap<VkMemoryBarrier> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER> { + typedef VkMemoryBarrier Type; +}; + +// Map type VkEventCreateInfo to id VK_STRUCTURE_TYPE_EVENT_CREATE_INFO +template <> +struct LvlTypeMap<VkEventCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EVENT_CREATE_INFO> { + typedef VkEventCreateInfo Type; +}; + +// Map type VkBufferViewCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO +template <> +struct LvlTypeMap<VkBufferViewCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO> { + typedef VkBufferViewCreateInfo Type; +}; + +// Map type VkShaderModuleCreateInfo to id VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO +template <> +struct LvlTypeMap<VkShaderModuleCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO> { + typedef VkShaderModuleCreateInfo Type; +}; + +// Map type VkPipelineCacheCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineCacheCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO> { + typedef VkPipelineCacheCreateInfo Type; +}; + +// Map type VkPipelineShaderStageCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineShaderStageCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO> { + typedef VkPipelineShaderStageCreateInfo Type; +}; + +// Map type VkComputePipelineCreateInfo to id VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO +template <> +struct LvlTypeMap<VkComputePipelineCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO> { + typedef VkComputePipelineCreateInfo Type; +}; + +// Map type VkPipelineLayoutCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineLayoutCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO> { + typedef VkPipelineLayoutCreateInfo Type; +}; + +// Map type VkSamplerCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO +template <> +struct LvlTypeMap<VkSamplerCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO> { + typedef VkSamplerCreateInfo Type; +}; + +// Map type VkCopyDescriptorSet to id VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET +template <> +struct LvlTypeMap<VkCopyDescriptorSet> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET> { + typedef VkCopyDescriptorSet Type; +}; + +// Map type VkDescriptorPoolCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO +template <> +struct LvlTypeMap<VkDescriptorPoolCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO> { + typedef VkDescriptorPoolCreateInfo Type; +}; + +// Map type VkDescriptorSetAllocateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO +template <> +struct LvlTypeMap<VkDescriptorSetAllocateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO> { + typedef VkDescriptorSetAllocateInfo Type; +}; + +// Map type VkDescriptorSetLayoutCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO +template <> +struct LvlTypeMap<VkDescriptorSetLayoutCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO> { + typedef VkDescriptorSetLayoutCreateInfo Type; +}; + +// Map type VkWriteDescriptorSet to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET +template <> +struct LvlTypeMap<VkWriteDescriptorSet> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET> { + typedef VkWriteDescriptorSet Type; +}; + +// Map type VkPipelineColorBlendStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineColorBlendStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO> { + typedef VkPipelineColorBlendStateCreateInfo Type; +}; + +// Map type VkPipelineDepthStencilStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineDepthStencilStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO> { + typedef VkPipelineDepthStencilStateCreateInfo Type; +}; + +// Map type VkPipelineDynamicStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineDynamicStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO> { + typedef VkPipelineDynamicStateCreateInfo Type; +}; + +// Map type VkPipelineInputAssemblyStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineInputAssemblyStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO> { + typedef VkPipelineInputAssemblyStateCreateInfo Type; +}; + +// Map type VkPipelineMultisampleStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineMultisampleStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO> { + typedef VkPipelineMultisampleStateCreateInfo Type; +}; + +// Map type VkPipelineRasterizationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineRasterizationStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO> { + typedef VkPipelineRasterizationStateCreateInfo Type; +}; + +// Map type VkPipelineTessellationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineTessellationStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO> { + typedef VkPipelineTessellationStateCreateInfo Type; +}; + +// Map type VkPipelineVertexInputStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineVertexInputStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO> { + typedef VkPipelineVertexInputStateCreateInfo Type; +}; + +// Map type VkPipelineViewportStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineViewportStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO> { + typedef VkPipelineViewportStateCreateInfo Type; +}; + +// Map type VkGraphicsPipelineCreateInfo to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO +template <> +struct LvlTypeMap<VkGraphicsPipelineCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO> { + typedef VkGraphicsPipelineCreateInfo Type; +}; + +// Map type VkFramebufferCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO +template <> +struct LvlTypeMap<VkFramebufferCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO> { + typedef VkFramebufferCreateInfo Type; +}; + +// Map type VkRenderPassCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO +template <> +struct LvlTypeMap<VkRenderPassCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO> { + typedef VkRenderPassCreateInfo Type; +}; + // Map type VkRenderPassBeginInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO -template <> struct LvlTypeMap<VkRenderPassBeginInfo> { +template <> +struct LvlTypeMap<VkRenderPassBeginInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO> { typedef VkRenderPassBeginInfo Type; }; -// Map type VkPhysicalDeviceSubgroupProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceSubgroupProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES> { - typedef VkPhysicalDeviceSubgroupProperties Type; -}; - // Map type VkBindBufferMemoryInfo to id VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO -template <> struct LvlTypeMap<VkBindBufferMemoryInfo> { +template <> +struct LvlTypeMap<VkBindBufferMemoryInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO> { typedef VkBindBufferMemoryInfo Type; }; // Map type VkBindImageMemoryInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO -template <> struct LvlTypeMap<VkBindImageMemoryInfo> { +template <> +struct LvlTypeMap<VkBindImageMemoryInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO> { typedef VkBindImageMemoryInfo Type; }; -// Map type VkPhysicalDevice16BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES -template <> struct LvlTypeMap<VkPhysicalDevice16BitStorageFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES> { - typedef VkPhysicalDevice16BitStorageFeatures Type; -}; - // Map type VkMemoryDedicatedRequirements to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS -template <> struct LvlTypeMap<VkMemoryDedicatedRequirements> { +template <> +struct LvlTypeMap<VkMemoryDedicatedRequirements> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS> { typedef VkMemoryDedicatedRequirements Type; }; // Map type VkMemoryDedicatedAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO -template <> struct LvlTypeMap<VkMemoryDedicatedAllocateInfo> { +template <> +struct LvlTypeMap<VkMemoryDedicatedAllocateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO> { typedef VkMemoryDedicatedAllocateInfo Type; }; // Map type VkMemoryAllocateFlagsInfo to id VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO -template <> struct LvlTypeMap<VkMemoryAllocateFlagsInfo> { +template <> +struct LvlTypeMap<VkMemoryAllocateFlagsInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO> { typedef VkMemoryAllocateFlagsInfo Type; }; -// Map type VkDeviceGroupRenderPassBeginInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO -template <> struct LvlTypeMap<VkDeviceGroupRenderPassBeginInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO> { - typedef VkDeviceGroupRenderPassBeginInfo Type; -}; - // Map type VkDeviceGroupCommandBufferBeginInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO -template <> struct LvlTypeMap<VkDeviceGroupCommandBufferBeginInfo> { +template <> +struct LvlTypeMap<VkDeviceGroupCommandBufferBeginInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO> { typedef VkDeviceGroupCommandBufferBeginInfo Type; }; // Map type VkDeviceGroupSubmitInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO -template <> struct LvlTypeMap<VkDeviceGroupSubmitInfo> { +template <> +struct LvlTypeMap<VkDeviceGroupSubmitInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO> { typedef VkDeviceGroupSubmitInfo Type; }; // Map type VkDeviceGroupBindSparseInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO -template <> struct LvlTypeMap<VkDeviceGroupBindSparseInfo> { +template <> +struct LvlTypeMap<VkDeviceGroupBindSparseInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO> { typedef VkDeviceGroupBindSparseInfo Type; }; // Map type VkBindBufferMemoryDeviceGroupInfo to id VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO -template <> struct LvlTypeMap<VkBindBufferMemoryDeviceGroupInfo> { +template <> +struct LvlTypeMap<VkBindBufferMemoryDeviceGroupInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO> { typedef VkBindBufferMemoryDeviceGroupInfo Type; }; // Map type VkBindImageMemoryDeviceGroupInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO -template <> struct LvlTypeMap<VkBindImageMemoryDeviceGroupInfo> { +template <> +struct LvlTypeMap<VkBindImageMemoryDeviceGroupInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO> { typedef VkBindImageMemoryDeviceGroupInfo Type; }; // Map type VkPhysicalDeviceGroupProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceGroupProperties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceGroupProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES> { typedef VkPhysicalDeviceGroupProperties Type; }; // Map type VkDeviceGroupDeviceCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO -template <> struct LvlTypeMap<VkDeviceGroupDeviceCreateInfo> { +template <> +struct LvlTypeMap<VkDeviceGroupDeviceCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO> { typedef VkDeviceGroupDeviceCreateInfo Type; }; // Map type VkBufferMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 -template <> struct LvlTypeMap<VkBufferMemoryRequirementsInfo2> { +template <> +struct LvlTypeMap<VkBufferMemoryRequirementsInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2> { typedef VkBufferMemoryRequirementsInfo2 Type; }; // Map type VkImageMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 -template <> struct LvlTypeMap<VkImageMemoryRequirementsInfo2> { +template <> +struct LvlTypeMap<VkImageMemoryRequirementsInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2> { typedef VkImageMemoryRequirementsInfo2 Type; }; // Map type VkImageSparseMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 -template <> struct LvlTypeMap<VkImageSparseMemoryRequirementsInfo2> { +template <> +struct LvlTypeMap<VkImageSparseMemoryRequirementsInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2> { typedef VkImageSparseMemoryRequirementsInfo2 Type; }; // Map type VkMemoryRequirements2 to id VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 -template <> struct LvlTypeMap<VkMemoryRequirements2> { +template <> +struct LvlTypeMap<VkMemoryRequirements2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2> { typedef VkMemoryRequirements2 Type; }; // Map type VkSparseImageMemoryRequirements2 to id VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 -template <> struct LvlTypeMap<VkSparseImageMemoryRequirements2> { +template <> +struct LvlTypeMap<VkSparseImageMemoryRequirements2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2> { typedef VkSparseImageMemoryRequirements2 Type; }; // Map type VkPhysicalDeviceFeatures2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 -template <> struct LvlTypeMap<VkPhysicalDeviceFeatures2> { +template <> +struct LvlTypeMap<VkPhysicalDeviceFeatures2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2> { typedef VkPhysicalDeviceFeatures2 Type; }; // Map type VkPhysicalDeviceProperties2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 -template <> struct LvlTypeMap<VkPhysicalDeviceProperties2> { +template <> +struct LvlTypeMap<VkPhysicalDeviceProperties2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2> { typedef VkPhysicalDeviceProperties2 Type; }; // Map type VkFormatProperties2 to id VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 -template <> struct LvlTypeMap<VkFormatProperties2> { +template <> +struct LvlTypeMap<VkFormatProperties2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2> { typedef VkFormatProperties2 Type; }; // Map type VkImageFormatProperties2 to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 -template <> struct LvlTypeMap<VkImageFormatProperties2> { +template <> +struct LvlTypeMap<VkImageFormatProperties2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2> { typedef VkImageFormatProperties2 Type; }; // Map type VkPhysicalDeviceImageFormatInfo2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 -template <> struct LvlTypeMap<VkPhysicalDeviceImageFormatInfo2> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImageFormatInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2> { typedef VkPhysicalDeviceImageFormatInfo2 Type; }; // Map type VkQueueFamilyProperties2 to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 -template <> struct LvlTypeMap<VkQueueFamilyProperties2> { +template <> +struct LvlTypeMap<VkQueueFamilyProperties2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2> { typedef VkQueueFamilyProperties2 Type; }; // Map type VkPhysicalDeviceMemoryProperties2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 -template <> struct LvlTypeMap<VkPhysicalDeviceMemoryProperties2> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMemoryProperties2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2> { typedef VkPhysicalDeviceMemoryProperties2 Type; }; // Map type VkSparseImageFormatProperties2 to id VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 -template <> struct LvlTypeMap<VkSparseImageFormatProperties2> { +template <> +struct LvlTypeMap<VkSparseImageFormatProperties2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2> { typedef VkSparseImageFormatProperties2 Type; }; // Map type VkPhysicalDeviceSparseImageFormatInfo2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 -template <> struct LvlTypeMap<VkPhysicalDeviceSparseImageFormatInfo2> { +template <> +struct LvlTypeMap<VkPhysicalDeviceSparseImageFormatInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2> { typedef VkPhysicalDeviceSparseImageFormatInfo2 Type; }; -// Map type VkPhysicalDevicePointClippingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDevicePointClippingProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES> { - typedef VkPhysicalDevicePointClippingProperties Type; -}; - -// Map type VkRenderPassInputAttachmentAspectCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO -template <> struct LvlTypeMap<VkRenderPassInputAttachmentAspectCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO> { - typedef VkRenderPassInputAttachmentAspectCreateInfo Type; -}; - // Map type VkImageViewUsageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO -template <> struct LvlTypeMap<VkImageViewUsageCreateInfo> { +template <> +struct LvlTypeMap<VkImageViewUsageCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO> { typedef VkImageViewUsageCreateInfo Type; }; -// Map type VkPipelineTessellationDomainOriginStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineTessellationDomainOriginStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO> { - typedef VkPipelineTessellationDomainOriginStateCreateInfo Type; -}; - -// Map type VkRenderPassMultiviewCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO -template <> struct LvlTypeMap<VkRenderPassMultiviewCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO> { - typedef VkRenderPassMultiviewCreateInfo Type; -}; - -// Map type VkPhysicalDeviceMultiviewFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceMultiviewFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES> { - typedef VkPhysicalDeviceMultiviewFeatures Type; -}; - -// Map type VkPhysicalDeviceMultiviewProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceMultiviewProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES> { - typedef VkPhysicalDeviceMultiviewProperties Type; -}; - -// Map type VkPhysicalDeviceVariablePointersFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceVariablePointersFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES> { - typedef VkPhysicalDeviceVariablePointersFeatures Type; -}; - // Map type VkPhysicalDeviceProtectedMemoryFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceProtectedMemoryFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceProtectedMemoryFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES> { typedef VkPhysicalDeviceProtectedMemoryFeatures Type; }; // Map type VkPhysicalDeviceProtectedMemoryProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceProtectedMemoryProperties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceProtectedMemoryProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES> { typedef VkPhysicalDeviceProtectedMemoryProperties Type; }; // Map type VkDeviceQueueInfo2 to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 -template <> struct LvlTypeMap<VkDeviceQueueInfo2> { +template <> +struct LvlTypeMap<VkDeviceQueueInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2> { typedef VkDeviceQueueInfo2 Type; }; // Map type VkProtectedSubmitInfo to id VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO -template <> struct LvlTypeMap<VkProtectedSubmitInfo> { +template <> +struct LvlTypeMap<VkProtectedSubmitInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO> { typedef VkProtectedSubmitInfo Type; }; -// Map type VkSamplerYcbcrConversionCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO -template <> struct LvlTypeMap<VkSamplerYcbcrConversionCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO> { - typedef VkSamplerYcbcrConversionCreateInfo Type; -}; - -// Map type VkSamplerYcbcrConversionInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO -template <> struct LvlTypeMap<VkSamplerYcbcrConversionInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO> { - typedef VkSamplerYcbcrConversionInfo Type; -}; - // Map type VkBindImagePlaneMemoryInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO -template <> struct LvlTypeMap<VkBindImagePlaneMemoryInfo> { +template <> +struct LvlTypeMap<VkBindImagePlaneMemoryInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO> { typedef VkBindImagePlaneMemoryInfo Type; }; // Map type VkImagePlaneMemoryRequirementsInfo to id VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO -template <> struct LvlTypeMap<VkImagePlaneMemoryRequirementsInfo> { +template <> +struct LvlTypeMap<VkImagePlaneMemoryRequirementsInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO> { typedef VkImagePlaneMemoryRequirementsInfo Type; }; -// Map type VkPhysicalDeviceSamplerYcbcrConversionFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceSamplerYcbcrConversionFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES> { - typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures Type; -}; - -// Map type VkSamplerYcbcrConversionImageFormatProperties to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES -template <> struct LvlTypeMap<VkSamplerYcbcrConversionImageFormatProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES> { - typedef VkSamplerYcbcrConversionImageFormatProperties Type; -}; - -// Map type VkDescriptorUpdateTemplateCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO -template <> struct LvlTypeMap<VkDescriptorUpdateTemplateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO> { - typedef VkDescriptorUpdateTemplateCreateInfo Type; -}; - // Map type VkPhysicalDeviceExternalImageFormatInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO -template <> struct LvlTypeMap<VkPhysicalDeviceExternalImageFormatInfo> { +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalImageFormatInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO> { typedef VkPhysicalDeviceExternalImageFormatInfo Type; }; // Map type VkExternalImageFormatProperties to id VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES -template <> struct LvlTypeMap<VkExternalImageFormatProperties> { +template <> +struct LvlTypeMap<VkExternalImageFormatProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES> { typedef VkExternalImageFormatProperties Type; }; // Map type VkPhysicalDeviceExternalBufferInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO -template <> struct LvlTypeMap<VkPhysicalDeviceExternalBufferInfo> { +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalBufferInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO> { typedef VkPhysicalDeviceExternalBufferInfo Type; }; // Map type VkExternalBufferProperties to id VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES -template <> struct LvlTypeMap<VkExternalBufferProperties> { +template <> +struct LvlTypeMap<VkExternalBufferProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES> { typedef VkExternalBufferProperties Type; }; // Map type VkPhysicalDeviceIDProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceIDProperties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceIDProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES> { typedef VkPhysicalDeviceIDProperties Type; }; // Map type VkExternalMemoryImageCreateInfo to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO -template <> struct LvlTypeMap<VkExternalMemoryImageCreateInfo> { +template <> +struct LvlTypeMap<VkExternalMemoryImageCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO> { typedef VkExternalMemoryImageCreateInfo Type; }; // Map type VkExternalMemoryBufferCreateInfo to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO -template <> struct LvlTypeMap<VkExternalMemoryBufferCreateInfo> { +template <> +struct LvlTypeMap<VkExternalMemoryBufferCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO> { typedef VkExternalMemoryBufferCreateInfo Type; }; // Map type VkExportMemoryAllocateInfo to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO -template <> struct LvlTypeMap<VkExportMemoryAllocateInfo> { +template <> +struct LvlTypeMap<VkExportMemoryAllocateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO> { typedef VkExportMemoryAllocateInfo Type; }; // Map type VkPhysicalDeviceExternalFenceInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO -template <> struct LvlTypeMap<VkPhysicalDeviceExternalFenceInfo> { +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalFenceInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO> { typedef VkPhysicalDeviceExternalFenceInfo Type; }; // Map type VkExternalFenceProperties to id VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES -template <> struct LvlTypeMap<VkExternalFenceProperties> { +template <> +struct LvlTypeMap<VkExternalFenceProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES> { typedef VkExternalFenceProperties Type; }; // Map type VkExportFenceCreateInfo to id VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO -template <> struct LvlTypeMap<VkExportFenceCreateInfo> { +template <> +struct LvlTypeMap<VkExportFenceCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO> { typedef VkExportFenceCreateInfo Type; }; // Map type VkExportSemaphoreCreateInfo to id VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO -template <> struct LvlTypeMap<VkExportSemaphoreCreateInfo> { +template <> +struct LvlTypeMap<VkExportSemaphoreCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO> { typedef VkExportSemaphoreCreateInfo Type; }; // Map type VkPhysicalDeviceExternalSemaphoreInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO -template <> struct LvlTypeMap<VkPhysicalDeviceExternalSemaphoreInfo> { +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalSemaphoreInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO> { typedef VkPhysicalDeviceExternalSemaphoreInfo Type; }; // Map type VkExternalSemaphoreProperties to id VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES -template <> struct LvlTypeMap<VkExternalSemaphoreProperties> { +template <> +struct LvlTypeMap<VkExternalSemaphoreProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES> { typedef VkExternalSemaphoreProperties Type; }; +// Map type VkPhysicalDeviceSubgroupProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceSubgroupProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES> { + typedef VkPhysicalDeviceSubgroupProperties Type; +}; + +// Map type VkPhysicalDevice16BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDevice16BitStorageFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES> { + typedef VkPhysicalDevice16BitStorageFeatures Type; +}; + +// Map type VkPhysicalDeviceVariablePointersFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceVariablePointersFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES> { + typedef VkPhysicalDeviceVariablePointersFeatures Type; +}; + +// Map type VkDescriptorUpdateTemplateCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO +template <> +struct LvlTypeMap<VkDescriptorUpdateTemplateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO> { + typedef VkDescriptorUpdateTemplateCreateInfo Type; +}; + // Map type VkPhysicalDeviceMaintenance3Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance3Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance3Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES> { typedef VkPhysicalDeviceMaintenance3Properties Type; }; // Map type VkDescriptorSetLayoutSupport to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT -template <> struct LvlTypeMap<VkDescriptorSetLayoutSupport> { +template <> +struct LvlTypeMap<VkDescriptorSetLayoutSupport> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT> { typedef VkDescriptorSetLayoutSupport Type; }; +// Map type VkSamplerYcbcrConversionCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO +template <> +struct LvlTypeMap<VkSamplerYcbcrConversionCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO> { + typedef VkSamplerYcbcrConversionCreateInfo Type; +}; + +// Map type VkSamplerYcbcrConversionInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO +template <> +struct LvlTypeMap<VkSamplerYcbcrConversionInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO> { + typedef VkSamplerYcbcrConversionInfo Type; +}; + +// Map type VkPhysicalDeviceSamplerYcbcrConversionFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceSamplerYcbcrConversionFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES> { + typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures Type; +}; + +// Map type VkSamplerYcbcrConversionImageFormatProperties to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES +template <> +struct LvlTypeMap<VkSamplerYcbcrConversionImageFormatProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES> { + typedef VkSamplerYcbcrConversionImageFormatProperties Type; +}; + +// Map type VkDeviceGroupRenderPassBeginInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO +template <> +struct LvlTypeMap<VkDeviceGroupRenderPassBeginInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO> { + typedef VkDeviceGroupRenderPassBeginInfo Type; +}; + +// Map type VkPhysicalDevicePointClippingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDevicePointClippingProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES> { + typedef VkPhysicalDevicePointClippingProperties Type; +}; + +// Map type VkRenderPassInputAttachmentAspectCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO +template <> +struct LvlTypeMap<VkRenderPassInputAttachmentAspectCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO> { + typedef VkRenderPassInputAttachmentAspectCreateInfo Type; +}; + +// Map type VkPipelineTessellationDomainOriginStateCreateInfo to id +// VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineTessellationDomainOriginStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO> { + typedef VkPipelineTessellationDomainOriginStateCreateInfo Type; +}; + +// Map type VkRenderPassMultiviewCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO +template <> +struct LvlTypeMap<VkRenderPassMultiviewCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO> { + typedef VkRenderPassMultiviewCreateInfo Type; +}; + +// Map type VkPhysicalDeviceMultiviewFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceMultiviewFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES> { + typedef VkPhysicalDeviceMultiviewFeatures Type; +}; + +// Map type VkPhysicalDeviceMultiviewProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceMultiviewProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES> { + typedef VkPhysicalDeviceMultiviewProperties Type; +}; + // Map type VkPhysicalDeviceShaderDrawParametersFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderDrawParametersFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderDrawParametersFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES> { typedef VkPhysicalDeviceShaderDrawParametersFeatures Type; }; +// Map type VkPhysicalDeviceDriverProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceDriverProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES> { + typedef VkPhysicalDeviceDriverProperties Type; +}; + // Map type VkPhysicalDeviceVulkan11Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan11Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan11Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES> { typedef VkPhysicalDeviceVulkan11Features Type; }; // Map type VkPhysicalDeviceVulkan11Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan11Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan11Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES> { typedef VkPhysicalDeviceVulkan11Properties Type; }; // Map type VkPhysicalDeviceVulkan12Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan12Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan12Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES> { typedef VkPhysicalDeviceVulkan12Features Type; }; // Map type VkPhysicalDeviceVulkan12Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan12Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan12Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES> { typedef VkPhysicalDeviceVulkan12Properties Type; }; // Map type VkImageFormatListCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO -template <> struct LvlTypeMap<VkImageFormatListCreateInfo> { +template <> +struct LvlTypeMap<VkImageFormatListCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO> { typedef VkImageFormatListCreateInfo Type; }; -// Map type VkAttachmentDescription2 to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 -template <> struct LvlTypeMap<VkAttachmentDescription2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2> { - typedef VkAttachmentDescription2 Type; -}; - -// Map type VkAttachmentReference2 to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 -template <> struct LvlTypeMap<VkAttachmentReference2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2> { - typedef VkAttachmentReference2 Type; -}; - -// Map type VkSubpassDescription2 to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 -template <> struct LvlTypeMap<VkSubpassDescription2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2> { - typedef VkSubpassDescription2 Type; -}; - -// Map type VkSubpassDependency2 to id VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 -template <> struct LvlTypeMap<VkSubpassDependency2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2> { - typedef VkSubpassDependency2 Type; -}; - -// Map type VkRenderPassCreateInfo2 to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 -template <> struct LvlTypeMap<VkRenderPassCreateInfo2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2> { - typedef VkRenderPassCreateInfo2 Type; -}; - -// Map type VkSubpassBeginInfo to id VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO -template <> struct LvlTypeMap<VkSubpassBeginInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO> { - typedef VkSubpassBeginInfo Type; -}; - -// Map type VkSubpassEndInfo to id VK_STRUCTURE_TYPE_SUBPASS_END_INFO -template <> struct LvlTypeMap<VkSubpassEndInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_END_INFO> { - typedef VkSubpassEndInfo Type; -}; - -// Map type VkPhysicalDevice8BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES -template <> struct LvlTypeMap<VkPhysicalDevice8BitStorageFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES> { - typedef VkPhysicalDevice8BitStorageFeatures Type; -}; - -// Map type VkPhysicalDeviceDriverProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceDriverProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES> { - typedef VkPhysicalDeviceDriverProperties Type; -}; - -// Map type VkPhysicalDeviceShaderAtomicInt64Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderAtomicInt64Features> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES> { - typedef VkPhysicalDeviceShaderAtomicInt64Features Type; -}; - -// Map type VkPhysicalDeviceShaderFloat16Int8Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderFloat16Int8Features> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES> { - typedef VkPhysicalDeviceShaderFloat16Int8Features Type; -}; - -// Map type VkPhysicalDeviceFloatControlsProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceFloatControlsProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES> { - typedef VkPhysicalDeviceFloatControlsProperties Type; -}; - -// Map type VkDescriptorSetLayoutBindingFlagsCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO -template <> struct LvlTypeMap<VkDescriptorSetLayoutBindingFlagsCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO> { - typedef VkDescriptorSetLayoutBindingFlagsCreateInfo Type; -}; - -// Map type VkPhysicalDeviceDescriptorIndexingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceDescriptorIndexingFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES> { - typedef VkPhysicalDeviceDescriptorIndexingFeatures Type; -}; - -// Map type VkPhysicalDeviceDescriptorIndexingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceDescriptorIndexingProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES> { - typedef VkPhysicalDeviceDescriptorIndexingProperties Type; -}; - -// Map type VkDescriptorSetVariableDescriptorCountAllocateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO -template <> struct LvlTypeMap<VkDescriptorSetVariableDescriptorCountAllocateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO> { - typedef VkDescriptorSetVariableDescriptorCountAllocateInfo Type; -}; - -// Map type VkDescriptorSetVariableDescriptorCountLayoutSupport to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT -template <> struct LvlTypeMap<VkDescriptorSetVariableDescriptorCountLayoutSupport> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT> { - typedef VkDescriptorSetVariableDescriptorCountLayoutSupport Type; -}; - -// Map type VkSubpassDescriptionDepthStencilResolve to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE -template <> struct LvlTypeMap<VkSubpassDescriptionDepthStencilResolve> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE> { - typedef VkSubpassDescriptionDepthStencilResolve Type; -}; - -// Map type VkPhysicalDeviceDepthStencilResolveProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceDepthStencilResolveProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES> { - typedef VkPhysicalDeviceDepthStencilResolveProperties Type; -}; - -// Map type VkPhysicalDeviceScalarBlockLayoutFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceScalarBlockLayoutFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES> { - typedef VkPhysicalDeviceScalarBlockLayoutFeatures Type; -}; - -// Map type VkImageStencilUsageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO -template <> struct LvlTypeMap<VkImageStencilUsageCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO> { - typedef VkImageStencilUsageCreateInfo Type; -}; - -// Map type VkSamplerReductionModeCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO -template <> struct LvlTypeMap<VkSamplerReductionModeCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO> { - typedef VkSamplerReductionModeCreateInfo Type; -}; - -// Map type VkPhysicalDeviceSamplerFilterMinmaxProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceSamplerFilterMinmaxProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES> { - typedef VkPhysicalDeviceSamplerFilterMinmaxProperties Type; -}; - // Map type VkPhysicalDeviceVulkanMemoryModelFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkanMemoryModelFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkanMemoryModelFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES> { typedef VkPhysicalDeviceVulkanMemoryModelFeatures Type; }; -// Map type VkPhysicalDeviceImagelessFramebufferFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceImagelessFramebufferFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES> { - typedef VkPhysicalDeviceImagelessFramebufferFeatures Type; -}; - -// Map type VkFramebufferAttachmentImageInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO -template <> struct LvlTypeMap<VkFramebufferAttachmentImageInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO> { - typedef VkFramebufferAttachmentImageInfo Type; -}; - -// Map type VkFramebufferAttachmentsCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO -template <> struct LvlTypeMap<VkFramebufferAttachmentsCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO> { - typedef VkFramebufferAttachmentsCreateInfo Type; -}; - -// Map type VkRenderPassAttachmentBeginInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO -template <> struct LvlTypeMap<VkRenderPassAttachmentBeginInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO> { - typedef VkRenderPassAttachmentBeginInfo Type; -}; - -// Map type VkPhysicalDeviceUniformBufferStandardLayoutFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceUniformBufferStandardLayoutFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES> { - typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures Type; -}; - -// Map type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES> { - typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures Type; -}; - -// Map type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES> { - typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures Type; -}; - -// Map type VkAttachmentReferenceStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT -template <> struct LvlTypeMap<VkAttachmentReferenceStencilLayout> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT> { - typedef VkAttachmentReferenceStencilLayout Type; -}; - -// Map type VkAttachmentDescriptionStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT -template <> struct LvlTypeMap<VkAttachmentDescriptionStencilLayout> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT> { - typedef VkAttachmentDescriptionStencilLayout Type; -}; - // Map type VkPhysicalDeviceHostQueryResetFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceHostQueryResetFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceHostQueryResetFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES> { typedef VkPhysicalDeviceHostQueryResetFeatures Type; }; // Map type VkPhysicalDeviceTimelineSemaphoreFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceTimelineSemaphoreFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceTimelineSemaphoreFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES> { typedef VkPhysicalDeviceTimelineSemaphoreFeatures Type; }; // Map type VkPhysicalDeviceTimelineSemaphoreProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceTimelineSemaphoreProperties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceTimelineSemaphoreProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES> { typedef VkPhysicalDeviceTimelineSemaphoreProperties Type; }; // Map type VkSemaphoreTypeCreateInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO -template <> struct LvlTypeMap<VkSemaphoreTypeCreateInfo> { +template <> +struct LvlTypeMap<VkSemaphoreTypeCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO> { typedef VkSemaphoreTypeCreateInfo Type; }; // Map type VkTimelineSemaphoreSubmitInfo to id VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO -template <> struct LvlTypeMap<VkTimelineSemaphoreSubmitInfo> { +template <> +struct LvlTypeMap<VkTimelineSemaphoreSubmitInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO> { typedef VkTimelineSemaphoreSubmitInfo Type; }; // Map type VkSemaphoreWaitInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO -template <> struct LvlTypeMap<VkSemaphoreWaitInfo> { +template <> +struct LvlTypeMap<VkSemaphoreWaitInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO> { typedef VkSemaphoreWaitInfo Type; }; // Map type VkSemaphoreSignalInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO -template <> struct LvlTypeMap<VkSemaphoreSignalInfo> { +template <> +struct LvlTypeMap<VkSemaphoreSignalInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO> { typedef VkSemaphoreSignalInfo Type; }; // Map type VkPhysicalDeviceBufferDeviceAddressFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES> { typedef VkPhysicalDeviceBufferDeviceAddressFeatures Type; }; // Map type VkBufferDeviceAddressInfo to id VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO -template <> struct LvlTypeMap<VkBufferDeviceAddressInfo> { +template <> +struct LvlTypeMap<VkBufferDeviceAddressInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO> { typedef VkBufferDeviceAddressInfo Type; }; // Map type VkBufferOpaqueCaptureAddressCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO -template <> struct LvlTypeMap<VkBufferOpaqueCaptureAddressCreateInfo> { +template <> +struct LvlTypeMap<VkBufferOpaqueCaptureAddressCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO> { typedef VkBufferOpaqueCaptureAddressCreateInfo Type; }; // Map type VkMemoryOpaqueCaptureAddressAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO -template <> struct LvlTypeMap<VkMemoryOpaqueCaptureAddressAllocateInfo> { +template <> +struct LvlTypeMap<VkMemoryOpaqueCaptureAddressAllocateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO> { typedef VkMemoryOpaqueCaptureAddressAllocateInfo Type; }; // Map type VkDeviceMemoryOpaqueCaptureAddressInfo to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO -template <> struct LvlTypeMap<VkDeviceMemoryOpaqueCaptureAddressInfo> { +template <> +struct LvlTypeMap<VkDeviceMemoryOpaqueCaptureAddressInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO> { typedef VkDeviceMemoryOpaqueCaptureAddressInfo Type; }; +// Map type VkPhysicalDevice8BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDevice8BitStorageFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES> { + typedef VkPhysicalDevice8BitStorageFeatures Type; +}; + +// Map type VkPhysicalDeviceShaderAtomicInt64Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderAtomicInt64Features> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES> { + typedef VkPhysicalDeviceShaderAtomicInt64Features Type; +}; + +// Map type VkPhysicalDeviceShaderFloat16Int8Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderFloat16Int8Features> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES> { + typedef VkPhysicalDeviceShaderFloat16Int8Features Type; +}; + +// Map type VkPhysicalDeviceFloatControlsProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceFloatControlsProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES> { + typedef VkPhysicalDeviceFloatControlsProperties Type; +}; + +// Map type VkDescriptorSetLayoutBindingFlagsCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO +template <> +struct LvlTypeMap<VkDescriptorSetLayoutBindingFlagsCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO> { + typedef VkDescriptorSetLayoutBindingFlagsCreateInfo Type; +}; + +// Map type VkPhysicalDeviceDescriptorIndexingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorIndexingFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES> { + typedef VkPhysicalDeviceDescriptorIndexingFeatures Type; +}; + +// Map type VkPhysicalDeviceDescriptorIndexingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorIndexingProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES> { + typedef VkPhysicalDeviceDescriptorIndexingProperties Type; +}; + +// Map type VkDescriptorSetVariableDescriptorCountAllocateInfo to id +// VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO +template <> +struct LvlTypeMap<VkDescriptorSetVariableDescriptorCountAllocateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO> { + typedef VkDescriptorSetVariableDescriptorCountAllocateInfo Type; +}; + +// Map type VkDescriptorSetVariableDescriptorCountLayoutSupport to id +// VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT +template <> +struct LvlTypeMap<VkDescriptorSetVariableDescriptorCountLayoutSupport> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT> { + typedef VkDescriptorSetVariableDescriptorCountLayoutSupport Type; +}; + +// Map type VkPhysicalDeviceScalarBlockLayoutFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceScalarBlockLayoutFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES> { + typedef VkPhysicalDeviceScalarBlockLayoutFeatures Type; +}; + +// Map type VkSamplerReductionModeCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO +template <> +struct LvlTypeMap<VkSamplerReductionModeCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO> { + typedef VkSamplerReductionModeCreateInfo Type; +}; + +// Map type VkPhysicalDeviceSamplerFilterMinmaxProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceSamplerFilterMinmaxProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES> { + typedef VkPhysicalDeviceSamplerFilterMinmaxProperties Type; +}; + +// Map type VkPhysicalDeviceUniformBufferStandardLayoutFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceUniformBufferStandardLayoutFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES> { + typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures Type; +}; + +// Map type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES> { + typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures Type; +}; + +// Map type VkAttachmentDescription2 to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 +template <> +struct LvlTypeMap<VkAttachmentDescription2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2> { + typedef VkAttachmentDescription2 Type; +}; + +// Map type VkAttachmentReference2 to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 +template <> +struct LvlTypeMap<VkAttachmentReference2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2> { + typedef VkAttachmentReference2 Type; +}; + +// Map type VkSubpassDescription2 to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 +template <> +struct LvlTypeMap<VkSubpassDescription2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2> { + typedef VkSubpassDescription2 Type; +}; + +// Map type VkSubpassDependency2 to id VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 +template <> +struct LvlTypeMap<VkSubpassDependency2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2> { + typedef VkSubpassDependency2 Type; +}; + +// Map type VkSubpassBeginInfo to id VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO +template <> +struct LvlTypeMap<VkSubpassBeginInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO> { + typedef VkSubpassBeginInfo Type; +}; + +// Map type VkSubpassEndInfo to id VK_STRUCTURE_TYPE_SUBPASS_END_INFO +template <> +struct LvlTypeMap<VkSubpassEndInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_END_INFO> { + typedef VkSubpassEndInfo Type; +}; + +// Map type VkRenderPassCreateInfo2 to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 +template <> +struct LvlTypeMap<VkRenderPassCreateInfo2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2> { + typedef VkRenderPassCreateInfo2 Type; +}; + +// Map type VkSubpassDescriptionDepthStencilResolve to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE +template <> +struct LvlTypeMap<VkSubpassDescriptionDepthStencilResolve> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE> { + typedef VkSubpassDescriptionDepthStencilResolve Type; +}; + +// Map type VkPhysicalDeviceDepthStencilResolveProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceDepthStencilResolveProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES> { + typedef VkPhysicalDeviceDepthStencilResolveProperties Type; +}; + +// Map type VkImageStencilUsageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO +template <> +struct LvlTypeMap<VkImageStencilUsageCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO> { + typedef VkImageStencilUsageCreateInfo Type; +}; + +// Map type VkPhysicalDeviceImagelessFramebufferFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceImagelessFramebufferFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES> { + typedef VkPhysicalDeviceImagelessFramebufferFeatures Type; +}; + +// Map type VkFramebufferAttachmentImageInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO +template <> +struct LvlTypeMap<VkFramebufferAttachmentImageInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO> { + typedef VkFramebufferAttachmentImageInfo Type; +}; + +// Map type VkRenderPassAttachmentBeginInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO +template <> +struct LvlTypeMap<VkRenderPassAttachmentBeginInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO> { + typedef VkRenderPassAttachmentBeginInfo Type; +}; + +// Map type VkFramebufferAttachmentsCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO +template <> +struct LvlTypeMap<VkFramebufferAttachmentsCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO> { + typedef VkFramebufferAttachmentsCreateInfo Type; +}; + +// Map type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES> { + typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures Type; +}; + +// Map type VkAttachmentReferenceStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT +template <> +struct LvlTypeMap<VkAttachmentReferenceStencilLayout> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT> { + typedef VkAttachmentReferenceStencilLayout Type; +}; + +// Map type VkAttachmentDescriptionStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT +template <> +struct LvlTypeMap<VkAttachmentDescriptionStencilLayout> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT> { + typedef VkAttachmentDescriptionStencilLayout Type; +}; + // Map type VkPhysicalDeviceVulkan13Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan13Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan13Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES> { typedef VkPhysicalDeviceVulkan13Features Type; }; // Map type VkPhysicalDeviceVulkan13Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan13Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan13Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES> { typedef VkPhysicalDeviceVulkan13Properties Type; }; -// Map type VkPipelineCreationFeedbackCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineCreationFeedbackCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO> { - typedef VkPipelineCreationFeedbackCreateInfo Type; -}; - -// Map type VkPhysicalDeviceShaderTerminateInvocationFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderTerminateInvocationFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES> { - typedef VkPhysicalDeviceShaderTerminateInvocationFeatures Type; -}; - // Map type VkPhysicalDeviceToolProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceToolProperties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceToolProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES> { typedef VkPhysicalDeviceToolProperties Type; }; -// Map type VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES> { - typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures Type; -}; - // Map type VkPhysicalDevicePrivateDataFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES -template <> struct LvlTypeMap<VkPhysicalDevicePrivateDataFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDevicePrivateDataFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES> { typedef VkPhysicalDevicePrivateDataFeatures Type; }; // Map type VkDevicePrivateDataCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO -template <> struct LvlTypeMap<VkDevicePrivateDataCreateInfo> { +template <> +struct LvlTypeMap<VkDevicePrivateDataCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO> { typedef VkDevicePrivateDataCreateInfo Type; }; // Map type VkPrivateDataSlotCreateInfo to id VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO -template <> struct LvlTypeMap<VkPrivateDataSlotCreateInfo> { +template <> +struct LvlTypeMap<VkPrivateDataSlotCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO> { typedef VkPrivateDataSlotCreateInfo Type; }; -// Map type VkPhysicalDevicePipelineCreationCacheControlFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES -template <> struct LvlTypeMap<VkPhysicalDevicePipelineCreationCacheControlFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES> { - typedef VkPhysicalDevicePipelineCreationCacheControlFeatures Type; -}; - // Map type VkMemoryBarrier2 to id VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 -template <> struct LvlTypeMap<VkMemoryBarrier2> { +template <> +struct LvlTypeMap<VkMemoryBarrier2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER_2> { typedef VkMemoryBarrier2 Type; }; // Map type VkBufferMemoryBarrier2 to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 -template <> struct LvlTypeMap<VkBufferMemoryBarrier2> { +template <> +struct LvlTypeMap<VkBufferMemoryBarrier2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2> { typedef VkBufferMemoryBarrier2 Type; }; // Map type VkImageMemoryBarrier2 to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 -template <> struct LvlTypeMap<VkImageMemoryBarrier2> { +template <> +struct LvlTypeMap<VkImageMemoryBarrier2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2> { typedef VkImageMemoryBarrier2 Type; }; // Map type VkDependencyInfo to id VK_STRUCTURE_TYPE_DEPENDENCY_INFO -template <> struct LvlTypeMap<VkDependencyInfo> { +template <> +struct LvlTypeMap<VkDependencyInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPENDENCY_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPENDENCY_INFO> { typedef VkDependencyInfo Type; }; // Map type VkSemaphoreSubmitInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO -template <> struct LvlTypeMap<VkSemaphoreSubmitInfo> { +template <> +struct LvlTypeMap<VkSemaphoreSubmitInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO> { typedef VkSemaphoreSubmitInfo Type; }; // Map type VkCommandBufferSubmitInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO -template <> struct LvlTypeMap<VkCommandBufferSubmitInfo> { +template <> +struct LvlTypeMap<VkCommandBufferSubmitInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO> { typedef VkCommandBufferSubmitInfo Type; }; // Map type VkSubmitInfo2 to id VK_STRUCTURE_TYPE_SUBMIT_INFO_2 -template <> struct LvlTypeMap<VkSubmitInfo2> { +template <> +struct LvlTypeMap<VkSubmitInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBMIT_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBMIT_INFO_2> { typedef VkSubmitInfo2 Type; }; // Map type VkPhysicalDeviceSynchronization2Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceSynchronization2Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceSynchronization2Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES> { typedef VkPhysicalDeviceSynchronization2Features Type; }; -// Map type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES> { - typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures Type; -}; - -// Map type VkPhysicalDeviceImageRobustnessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceImageRobustnessFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES> { - typedef VkPhysicalDeviceImageRobustnessFeatures Type; -}; - // Map type VkBufferCopy2 to id VK_STRUCTURE_TYPE_BUFFER_COPY_2 -template <> struct LvlTypeMap<VkBufferCopy2> { +template <> +struct LvlTypeMap<VkBufferCopy2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COPY_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COPY_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COPY_2> { typedef VkBufferCopy2 Type; }; // Map type VkCopyBufferInfo2 to id VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 -template <> struct LvlTypeMap<VkCopyBufferInfo2> { +template <> +struct LvlTypeMap<VkCopyBufferInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2> { typedef VkCopyBufferInfo2 Type; }; // Map type VkImageCopy2 to id VK_STRUCTURE_TYPE_IMAGE_COPY_2 -template <> struct LvlTypeMap<VkImageCopy2> { +template <> +struct LvlTypeMap<VkImageCopy2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COPY_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COPY_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COPY_2> { typedef VkImageCopy2 Type; }; // Map type VkCopyImageInfo2 to id VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 -template <> struct LvlTypeMap<VkCopyImageInfo2> { +template <> +struct LvlTypeMap<VkCopyImageInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2> { typedef VkCopyImageInfo2 Type; }; // Map type VkBufferImageCopy2 to id VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 -template <> struct LvlTypeMap<VkBufferImageCopy2> { +template <> +struct LvlTypeMap<VkBufferImageCopy2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2> { typedef VkBufferImageCopy2 Type; }; // Map type VkCopyBufferToImageInfo2 to id VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 -template <> struct LvlTypeMap<VkCopyBufferToImageInfo2> { +template <> +struct LvlTypeMap<VkCopyBufferToImageInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2> { typedef VkCopyBufferToImageInfo2 Type; }; // Map type VkCopyImageToBufferInfo2 to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 -template <> struct LvlTypeMap<VkCopyImageToBufferInfo2> { +template <> +struct LvlTypeMap<VkCopyImageToBufferInfo2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2> { typedef VkCopyImageToBufferInfo2 Type; }; -// Map type VkImageBlit2 to id VK_STRUCTURE_TYPE_IMAGE_BLIT_2 -template <> struct LvlTypeMap<VkImageBlit2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_BLIT_2> { - typedef VkImageBlit2 Type; -}; - -// Map type VkBlitImageInfo2 to id VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 -template <> struct LvlTypeMap<VkBlitImageInfo2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2> { - typedef VkBlitImageInfo2 Type; -}; - -// Map type VkImageResolve2 to id VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 -template <> struct LvlTypeMap<VkImageResolve2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2> { - typedef VkImageResolve2 Type; -}; - -// Map type VkResolveImageInfo2 to id VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 -template <> struct LvlTypeMap<VkResolveImageInfo2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2> { - typedef VkResolveImageInfo2 Type; -}; - -// Map type VkPhysicalDeviceSubgroupSizeControlFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES> { - typedef VkPhysicalDeviceSubgroupSizeControlFeatures Type; -}; - -// Map type VkPhysicalDeviceSubgroupSizeControlProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES> { - typedef VkPhysicalDeviceSubgroupSizeControlProperties Type; -}; - -// Map type VkPipelineShaderStageRequiredSubgroupSizeCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO> { - typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo Type; -}; - -// Map type VkPhysicalDeviceInlineUniformBlockFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceInlineUniformBlockFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES> { - typedef VkPhysicalDeviceInlineUniformBlockFeatures Type; -}; - -// Map type VkPhysicalDeviceInlineUniformBlockProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceInlineUniformBlockProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES> { - typedef VkPhysicalDeviceInlineUniformBlockProperties Type; -}; - -// Map type VkWriteDescriptorSetInlineUniformBlock to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK -template <> struct LvlTypeMap<VkWriteDescriptorSetInlineUniformBlock> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK> { - typedef VkWriteDescriptorSetInlineUniformBlock Type; -}; - -// Map type VkDescriptorPoolInlineUniformBlockCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO -template <> struct LvlTypeMap<VkDescriptorPoolInlineUniformBlockCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO> { - typedef VkDescriptorPoolInlineUniformBlockCreateInfo Type; -}; - -// Map type VkPhysicalDeviceTextureCompressionASTCHDRFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceTextureCompressionASTCHDRFeatures> { +// Map type VkPhysicalDeviceTextureCompressionASTCHDRFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceTextureCompressionASTCHDRFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES> { typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures Type; }; -// Map type VkRenderingAttachmentInfo to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO -template <> struct LvlTypeMap<VkRenderingAttachmentInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO> { - typedef VkRenderingAttachmentInfo Type; -}; - -// Map type VkRenderingInfo to id VK_STRUCTURE_TYPE_RENDERING_INFO -template <> struct LvlTypeMap<VkRenderingInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_INFO> { - typedef VkRenderingInfo Type; -}; - -// Map type VkPipelineRenderingCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineRenderingCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO> { - typedef VkPipelineRenderingCreateInfo Type; -}; - -// Map type VkPhysicalDeviceDynamicRenderingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES> { - typedef VkPhysicalDeviceDynamicRenderingFeatures Type; -}; - -// Map type VkCommandBufferInheritanceRenderingInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO -template <> struct LvlTypeMap<VkCommandBufferInheritanceRenderingInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO> { - typedef VkCommandBufferInheritanceRenderingInfo Type; -}; - -// Map type VkPhysicalDeviceShaderIntegerDotProductFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderIntegerDotProductFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES> { - typedef VkPhysicalDeviceShaderIntegerDotProductFeatures Type; -}; - -// Map type VkPhysicalDeviceShaderIntegerDotProductProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderIntegerDotProductProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES> { - typedef VkPhysicalDeviceShaderIntegerDotProductProperties Type; -}; - -// Map type VkPhysicalDeviceTexelBufferAlignmentProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceTexelBufferAlignmentProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES> { - typedef VkPhysicalDeviceTexelBufferAlignmentProperties Type; -}; - // Map type VkFormatProperties3 to id VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 -template <> struct LvlTypeMap<VkFormatProperties3> { +template <> +struct LvlTypeMap<VkFormatProperties3> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3> { typedef VkFormatProperties3 Type; }; // Map type VkPhysicalDeviceMaintenance4Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance4Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance4Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES> { typedef VkPhysicalDeviceMaintenance4Features Type; }; // Map type VkPhysicalDeviceMaintenance4Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance4Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance4Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES> { typedef VkPhysicalDeviceMaintenance4Properties Type; }; // Map type VkDeviceBufferMemoryRequirements to id VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS -template <> struct LvlTypeMap<VkDeviceBufferMemoryRequirements> { +template <> +struct LvlTypeMap<VkDeviceBufferMemoryRequirements> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS> { typedef VkDeviceBufferMemoryRequirements Type; }; // Map type VkDeviceImageMemoryRequirements to id VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS -template <> struct LvlTypeMap<VkDeviceImageMemoryRequirements> { +template <> +struct LvlTypeMap<VkDeviceImageMemoryRequirements> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS> { typedef VkDeviceImageMemoryRequirements Type; }; +// Map type VkPipelineCreationFeedbackCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineCreationFeedbackCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO> { + typedef VkPipelineCreationFeedbackCreateInfo Type; +}; + +// Map type VkPhysicalDeviceShaderTerminateInvocationFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderTerminateInvocationFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES> { + typedef VkPhysicalDeviceShaderTerminateInvocationFeatures Type; +}; + +// Map type VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES> { + typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures Type; +}; + +// Map type VkPhysicalDevicePipelineCreationCacheControlFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineCreationCacheControlFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES> { + typedef VkPhysicalDevicePipelineCreationCacheControlFeatures Type; +}; + +// Map type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES> { + typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures Type; +}; + +// Map type VkPhysicalDeviceImageRobustnessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceImageRobustnessFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES> { + typedef VkPhysicalDeviceImageRobustnessFeatures Type; +}; + +// Map type VkPhysicalDeviceSubgroupSizeControlFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES> { + typedef VkPhysicalDeviceSubgroupSizeControlFeatures Type; +}; + +// Map type VkPhysicalDeviceSubgroupSizeControlProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES> { + typedef VkPhysicalDeviceSubgroupSizeControlProperties Type; +}; + +// Map type VkPipelineShaderStageRequiredSubgroupSizeCreateInfo to id +// VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO> { + typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo Type; +}; + +// Map type VkPhysicalDeviceInlineUniformBlockFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceInlineUniformBlockFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES> { + typedef VkPhysicalDeviceInlineUniformBlockFeatures Type; +}; + +// Map type VkPhysicalDeviceInlineUniformBlockProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceInlineUniformBlockProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES> { + typedef VkPhysicalDeviceInlineUniformBlockProperties Type; +}; + +// Map type VkWriteDescriptorSetInlineUniformBlock to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK +template <> +struct LvlTypeMap<VkWriteDescriptorSetInlineUniformBlock> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK> { + typedef VkWriteDescriptorSetInlineUniformBlock Type; +}; + +// Map type VkDescriptorPoolInlineUniformBlockCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO +template <> +struct LvlTypeMap<VkDescriptorPoolInlineUniformBlockCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO> { + typedef VkDescriptorPoolInlineUniformBlockCreateInfo Type; +}; + +// Map type VkPhysicalDeviceShaderIntegerDotProductFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderIntegerDotProductFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES> { + typedef VkPhysicalDeviceShaderIntegerDotProductFeatures Type; +}; + +// Map type VkPhysicalDeviceShaderIntegerDotProductProperties to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderIntegerDotProductProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES> { + typedef VkPhysicalDeviceShaderIntegerDotProductProperties Type; +}; + +// Map type VkPhysicalDeviceTexelBufferAlignmentProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceTexelBufferAlignmentProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES> { + typedef VkPhysicalDeviceTexelBufferAlignmentProperties Type; +}; + +// Map type VkImageBlit2 to id VK_STRUCTURE_TYPE_IMAGE_BLIT_2 +template <> +struct LvlTypeMap<VkImageBlit2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_BLIT_2> { + typedef VkImageBlit2 Type; +}; + +// Map type VkBlitImageInfo2 to id VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 +template <> +struct LvlTypeMap<VkBlitImageInfo2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2> { + typedef VkBlitImageInfo2 Type; +}; + +// Map type VkImageResolve2 to id VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 +template <> +struct LvlTypeMap<VkImageResolve2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2> { + typedef VkImageResolve2 Type; +}; + +// Map type VkResolveImageInfo2 to id VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 +template <> +struct LvlTypeMap<VkResolveImageInfo2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2> { + typedef VkResolveImageInfo2 Type; +}; + +// Map type VkRenderingAttachmentInfo to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO +template <> +struct LvlTypeMap<VkRenderingAttachmentInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO> { + typedef VkRenderingAttachmentInfo Type; +}; + +// Map type VkRenderingInfo to id VK_STRUCTURE_TYPE_RENDERING_INFO +template <> +struct LvlTypeMap<VkRenderingInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_INFO> { + typedef VkRenderingInfo Type; +}; + +// Map type VkPipelineRenderingCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineRenderingCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO> { + typedef VkPipelineRenderingCreateInfo Type; +}; + +// Map type VkPhysicalDeviceDynamicRenderingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES> { + typedef VkPhysicalDeviceDynamicRenderingFeatures Type; +}; + +// Map type VkCommandBufferInheritanceRenderingInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO +template <> +struct LvlTypeMap<VkCommandBufferInheritanceRenderingInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO> { + typedef VkCommandBufferInheritanceRenderingInfo Type; +}; + // Map type VkPhysicalDeviceVulkan14Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan14Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan14Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES> { typedef VkPhysicalDeviceVulkan14Features Type; }; // Map type VkPhysicalDeviceVulkan14Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceVulkan14Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVulkan14Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES> { typedef VkPhysicalDeviceVulkan14Properties Type; }; // Map type VkDeviceQueueGlobalPriorityCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO -template <> struct LvlTypeMap<VkDeviceQueueGlobalPriorityCreateInfo> { +template <> +struct LvlTypeMap<VkDeviceQueueGlobalPriorityCreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO> { typedef VkDeviceQueueGlobalPriorityCreateInfo Type; }; // Map type VkPhysicalDeviceGlobalPriorityQueryFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceGlobalPriorityQueryFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceGlobalPriorityQueryFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES> { typedef VkPhysicalDeviceGlobalPriorityQueryFeatures Type; }; // Map type VkQueueFamilyGlobalPriorityProperties to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES -template <> struct LvlTypeMap<VkQueueFamilyGlobalPriorityProperties> { +template <> +struct LvlTypeMap<VkQueueFamilyGlobalPriorityProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES> { typedef VkQueueFamilyGlobalPriorityProperties Type; }; -// Map type VkPhysicalDeviceShaderSubgroupRotateFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupRotateFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES> { - typedef VkPhysicalDeviceShaderSubgroupRotateFeatures Type; -}; - -// Map type VkPhysicalDeviceShaderFloatControls2Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderFloatControls2Features> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES> { - typedef VkPhysicalDeviceShaderFloatControls2Features Type; -}; - -// Map type VkPhysicalDeviceShaderExpectAssumeFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceShaderExpectAssumeFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES> { - typedef VkPhysicalDeviceShaderExpectAssumeFeatures Type; -}; - -// Map type VkPhysicalDeviceLineRasterizationFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceLineRasterizationFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES> { - typedef VkPhysicalDeviceLineRasterizationFeatures Type; -}; - -// Map type VkPhysicalDeviceLineRasterizationProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceLineRasterizationProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES> { - typedef VkPhysicalDeviceLineRasterizationProperties Type; -}; - -// Map type VkPipelineRasterizationLineStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineRasterizationLineStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO> { - typedef VkPipelineRasterizationLineStateCreateInfo Type; -}; - -// Map type VkPhysicalDeviceVertexAttributeDivisorProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES> { - typedef VkPhysicalDeviceVertexAttributeDivisorProperties Type; -}; - -// Map type VkPipelineVertexInputDivisorStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineVertexInputDivisorStateCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO> { - typedef VkPipelineVertexInputDivisorStateCreateInfo Type; -}; - -// Map type VkPhysicalDeviceVertexAttributeDivisorFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES> { - typedef VkPhysicalDeviceVertexAttributeDivisorFeatures Type; -}; - // Map type VkPhysicalDeviceIndexTypeUint8Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceIndexTypeUint8Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceIndexTypeUint8Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES> { typedef VkPhysicalDeviceIndexTypeUint8Features Type; }; // Map type VkMemoryMapInfo to id VK_STRUCTURE_TYPE_MEMORY_MAP_INFO -template <> struct LvlTypeMap<VkMemoryMapInfo> { +template <> +struct LvlTypeMap<VkMemoryMapInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MAP_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MAP_INFO> { typedef VkMemoryMapInfo Type; }; // Map type VkMemoryUnmapInfo to id VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO -template <> struct LvlTypeMap<VkMemoryUnmapInfo> { +template <> +struct LvlTypeMap<VkMemoryUnmapInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO> { typedef VkMemoryUnmapInfo Type; }; // Map type VkPhysicalDeviceMaintenance5Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance5Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance5Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES> { typedef VkPhysicalDeviceMaintenance5Features Type; }; // Map type VkPhysicalDeviceMaintenance5Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance5Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance5Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES> { typedef VkPhysicalDeviceMaintenance5Properties Type; }; -// Map type VkRenderingAreaInfo to id VK_STRUCTURE_TYPE_RENDERING_AREA_INFO -template <> struct LvlTypeMap<VkRenderingAreaInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO; +// Map type VkSubresourceLayout2 to id VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2 +template <> +struct LvlTypeMap<VkSubresourceLayout2> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_AREA_INFO> { - typedef VkRenderingAreaInfo Type; +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2> { + typedef VkSubresourceLayout2 Type; }; // Map type VkImageSubresource2 to id VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2 -template <> struct LvlTypeMap<VkImageSubresource2> { +template <> +struct LvlTypeMap<VkImageSubresource2> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2> { typedef VkImageSubresource2 Type; }; // Map type VkDeviceImageSubresourceInfo to id VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO -template <> struct LvlTypeMap<VkDeviceImageSubresourceInfo> { +template <> +struct LvlTypeMap<VkDeviceImageSubresourceInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO> { typedef VkDeviceImageSubresourceInfo Type; }; -// Map type VkSubresourceLayout2 to id VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2 -template <> struct LvlTypeMap<VkSubresourceLayout2> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2> { - typedef VkSubresourceLayout2 Type; -}; - -// Map type VkPipelineCreateFlags2CreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineCreateFlags2CreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO> { - typedef VkPipelineCreateFlags2CreateInfo Type; -}; - // Map type VkBufferUsageFlags2CreateInfo to id VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO -template <> struct LvlTypeMap<VkBufferUsageFlags2CreateInfo> { +template <> +struct LvlTypeMap<VkBufferUsageFlags2CreateInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO> { typedef VkBufferUsageFlags2CreateInfo Type; }; -// Map type VkPhysicalDevicePushDescriptorProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDevicePushDescriptorProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES> { - typedef VkPhysicalDevicePushDescriptorProperties Type; -}; - -// Map type VkPhysicalDeviceDynamicRenderingLocalReadFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingLocalReadFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES> { - typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures Type; -}; - -// Map type VkRenderingAttachmentLocationInfo to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO -template <> struct LvlTypeMap<VkRenderingAttachmentLocationInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO> { - typedef VkRenderingAttachmentLocationInfo Type; -}; - -// Map type VkRenderingInputAttachmentIndexInfo to id VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO -template <> struct LvlTypeMap<VkRenderingInputAttachmentIndexInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO> { - typedef VkRenderingInputAttachmentIndexInfo Type; -}; - // Map type VkPhysicalDeviceMaintenance6Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance6Features> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance6Features> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES> { typedef VkPhysicalDeviceMaintenance6Features Type; }; // Map type VkPhysicalDeviceMaintenance6Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance6Properties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance6Properties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES> { typedef VkPhysicalDeviceMaintenance6Properties Type; }; // Map type VkBindMemoryStatus to id VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS -template <> struct LvlTypeMap<VkBindMemoryStatus> { +template <> +struct LvlTypeMap<VkBindMemoryStatus> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS> { typedef VkBindMemoryStatus Type; }; -// Map type VkBindDescriptorSetsInfo to id VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO -template <> struct LvlTypeMap<VkBindDescriptorSetsInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO> { - typedef VkBindDescriptorSetsInfo Type; -}; - -// Map type VkPushConstantsInfo to id VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO -template <> struct LvlTypeMap<VkPushConstantsInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO> { - typedef VkPushConstantsInfo Type; -}; - -// Map type VkPushDescriptorSetInfo to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO -template <> struct LvlTypeMap<VkPushDescriptorSetInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO> { - typedef VkPushDescriptorSetInfo Type; -}; - -// Map type VkPushDescriptorSetWithTemplateInfo to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO -template <> struct LvlTypeMap<VkPushDescriptorSetWithTemplateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO> { - typedef VkPushDescriptorSetWithTemplateInfo Type; -}; - -// Map type VkPhysicalDevicePipelineProtectedAccessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES -template <> struct LvlTypeMap<VkPhysicalDevicePipelineProtectedAccessFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES> { - typedef VkPhysicalDevicePipelineProtectedAccessFeatures Type; -}; - -// Map type VkPhysicalDevicePipelineRobustnessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES -template <> struct LvlTypeMap<VkPhysicalDevicePipelineRobustnessFeatures> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES> { - typedef VkPhysicalDevicePipelineRobustnessFeatures Type; -}; - -// Map type VkPhysicalDevicePipelineRobustnessProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDevicePipelineRobustnessProperties> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES> { - typedef VkPhysicalDevicePipelineRobustnessProperties Type; -}; - -// Map type VkPipelineRobustnessCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO -template <> struct LvlTypeMap<VkPipelineRobustnessCreateInfo> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO> { - typedef VkPipelineRobustnessCreateInfo Type; -}; - // Map type VkPhysicalDeviceHostImageCopyFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES -template <> struct LvlTypeMap<VkPhysicalDeviceHostImageCopyFeatures> { +template <> +struct LvlTypeMap<VkPhysicalDeviceHostImageCopyFeatures> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES> { typedef VkPhysicalDeviceHostImageCopyFeatures Type; }; // Map type VkPhysicalDeviceHostImageCopyProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES -template <> struct LvlTypeMap<VkPhysicalDeviceHostImageCopyProperties> { +template <> +struct LvlTypeMap<VkPhysicalDeviceHostImageCopyProperties> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES> { typedef VkPhysicalDeviceHostImageCopyProperties Type; }; // Map type VkMemoryToImageCopy to id VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY -template <> struct LvlTypeMap<VkMemoryToImageCopy> { +template <> +struct LvlTypeMap<VkMemoryToImageCopy> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY> { typedef VkMemoryToImageCopy Type; }; // Map type VkImageToMemoryCopy to id VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY -template <> struct LvlTypeMap<VkImageToMemoryCopy> { +template <> +struct LvlTypeMap<VkImageToMemoryCopy> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY> { typedef VkImageToMemoryCopy Type; }; // Map type VkCopyMemoryToImageInfo to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO -template <> struct LvlTypeMap<VkCopyMemoryToImageInfo> { +template <> +struct LvlTypeMap<VkCopyMemoryToImageInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO> { typedef VkCopyMemoryToImageInfo Type; }; // Map type VkCopyImageToMemoryInfo to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO -template <> struct LvlTypeMap<VkCopyImageToMemoryInfo> { +template <> +struct LvlTypeMap<VkCopyImageToMemoryInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO> { typedef VkCopyImageToMemoryInfo Type; }; // Map type VkCopyImageToImageInfo to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO -template <> struct LvlTypeMap<VkCopyImageToImageInfo> { +template <> +struct LvlTypeMap<VkCopyImageToImageInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO> { typedef VkCopyImageToImageInfo Type; }; // Map type VkHostImageLayoutTransitionInfo to id VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO -template <> struct LvlTypeMap<VkHostImageLayoutTransitionInfo> { +template <> +struct LvlTypeMap<VkHostImageLayoutTransitionInfo> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO> { typedef VkHostImageLayoutTransitionInfo Type; }; // Map type VkSubresourceHostMemcpySize to id VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE -template <> struct LvlTypeMap<VkSubresourceHostMemcpySize> { +template <> +struct LvlTypeMap<VkSubresourceHostMemcpySize> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE> { typedef VkSubresourceHostMemcpySize Type; }; // Map type VkHostImageCopyDevicePerformanceQuery to id VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY -template <> struct LvlTypeMap<VkHostImageCopyDevicePerformanceQuery> { +template <> +struct LvlTypeMap<VkHostImageCopyDevicePerformanceQuery> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY> { typedef VkHostImageCopyDevicePerformanceQuery Type; }; +// Map type VkPhysicalDeviceShaderSubgroupRotateFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupRotateFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES> { + typedef VkPhysicalDeviceShaderSubgroupRotateFeatures Type; +}; + +// Map type VkPhysicalDeviceShaderFloatControls2Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderFloatControls2Features> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES> { + typedef VkPhysicalDeviceShaderFloatControls2Features Type; +}; + +// Map type VkPhysicalDeviceShaderExpectAssumeFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderExpectAssumeFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES> { + typedef VkPhysicalDeviceShaderExpectAssumeFeatures Type; +}; + +// Map type VkPipelineCreateFlags2CreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineCreateFlags2CreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO> { + typedef VkPipelineCreateFlags2CreateInfo Type; +}; + +// Map type VkPhysicalDevicePushDescriptorProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDevicePushDescriptorProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES> { + typedef VkPhysicalDevicePushDescriptorProperties Type; +}; + +// Map type VkBindDescriptorSetsInfo to id VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO +template <> +struct LvlTypeMap<VkBindDescriptorSetsInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO> { + typedef VkBindDescriptorSetsInfo Type; +}; + +// Map type VkPushConstantsInfo to id VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO +template <> +struct LvlTypeMap<VkPushConstantsInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO> { + typedef VkPushConstantsInfo Type; +}; + +// Map type VkPushDescriptorSetInfo to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO +template <> +struct LvlTypeMap<VkPushDescriptorSetInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO> { + typedef VkPushDescriptorSetInfo Type; +}; + +// Map type VkPushDescriptorSetWithTemplateInfo to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO +template <> +struct LvlTypeMap<VkPushDescriptorSetWithTemplateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO> { + typedef VkPushDescriptorSetWithTemplateInfo Type; +}; + +// Map type VkPhysicalDevicePipelineProtectedAccessFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineProtectedAccessFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES> { + typedef VkPhysicalDevicePipelineProtectedAccessFeatures Type; +}; + +// Map type VkPhysicalDevicePipelineRobustnessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineRobustnessFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES> { + typedef VkPhysicalDevicePipelineRobustnessFeatures Type; +}; + +// Map type VkPhysicalDevicePipelineRobustnessProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineRobustnessProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES> { + typedef VkPhysicalDevicePipelineRobustnessProperties Type; +}; + +// Map type VkPipelineRobustnessCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineRobustnessCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO> { + typedef VkPipelineRobustnessCreateInfo Type; +}; + +// Map type VkPhysicalDeviceLineRasterizationFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceLineRasterizationFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES> { + typedef VkPhysicalDeviceLineRasterizationFeatures Type; +}; + +// Map type VkPhysicalDeviceLineRasterizationProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceLineRasterizationProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES> { + typedef VkPhysicalDeviceLineRasterizationProperties Type; +}; + +// Map type VkPipelineRasterizationLineStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineRasterizationLineStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO> { + typedef VkPipelineRasterizationLineStateCreateInfo Type; +}; + +// Map type VkPhysicalDeviceVertexAttributeDivisorProperties to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES +template <> +struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorProperties> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES> { + typedef VkPhysicalDeviceVertexAttributeDivisorProperties Type; +}; + +// Map type VkPipelineVertexInputDivisorStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO +template <> +struct LvlTypeMap<VkPipelineVertexInputDivisorStateCreateInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO> { + typedef VkPipelineVertexInputDivisorStateCreateInfo Type; +}; + +// Map type VkPhysicalDeviceVertexAttributeDivisorFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES> { + typedef VkPhysicalDeviceVertexAttributeDivisorFeatures Type; +}; + +// Map type VkRenderingAreaInfo to id VK_STRUCTURE_TYPE_RENDERING_AREA_INFO +template <> +struct LvlTypeMap<VkRenderingAreaInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_AREA_INFO> { + typedef VkRenderingAreaInfo Type; +}; + +// Map type VkPhysicalDeviceDynamicRenderingLocalReadFeatures to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES +template <> +struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingLocalReadFeatures> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES> { + typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures Type; +}; + +// Map type VkRenderingAttachmentLocationInfo to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO +template <> +struct LvlTypeMap<VkRenderingAttachmentLocationInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO> { + typedef VkRenderingAttachmentLocationInfo Type; +}; + +// Map type VkRenderingInputAttachmentIndexInfo to id VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO +template <> +struct LvlTypeMap<VkRenderingInputAttachmentIndexInfo> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO> { + typedef VkRenderingInputAttachmentIndexInfo Type; +}; + // Map type VkSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkSwapchainCreateInfoKHR> { +template <> +struct LvlTypeMap<VkSwapchainCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR> { typedef VkSwapchainCreateInfoKHR Type; }; // Map type VkPresentInfoKHR to id VK_STRUCTURE_TYPE_PRESENT_INFO_KHR -template <> struct LvlTypeMap<VkPresentInfoKHR> { +template <> +struct LvlTypeMap<VkPresentInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_INFO_KHR> { typedef VkPresentInfoKHR Type; }; // Map type VkImageSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkImageSwapchainCreateInfoKHR> { +template <> +struct LvlTypeMap<VkImageSwapchainCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR> { typedef VkImageSwapchainCreateInfoKHR Type; }; // Map type VkBindImageMemorySwapchainInfoKHR to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR -template <> struct LvlTypeMap<VkBindImageMemorySwapchainInfoKHR> { +template <> +struct LvlTypeMap<VkBindImageMemorySwapchainInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR> { typedef VkBindImageMemorySwapchainInfoKHR Type; }; // Map type VkAcquireNextImageInfoKHR to id VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR -template <> struct LvlTypeMap<VkAcquireNextImageInfoKHR> { +template <> +struct LvlTypeMap<VkAcquireNextImageInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR> { typedef VkAcquireNextImageInfoKHR Type; }; // Map type VkDeviceGroupPresentCapabilitiesKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkDeviceGroupPresentCapabilitiesKHR> { +template <> +struct LvlTypeMap<VkDeviceGroupPresentCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR> { typedef VkDeviceGroupPresentCapabilitiesKHR Type; }; // Map type VkDeviceGroupPresentInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR -template <> struct LvlTypeMap<VkDeviceGroupPresentInfoKHR> { +template <> +struct LvlTypeMap<VkDeviceGroupPresentInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR> { typedef VkDeviceGroupPresentInfoKHR Type; }; // Map type VkDeviceGroupSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkDeviceGroupSwapchainCreateInfoKHR> { +template <> +struct LvlTypeMap<VkDeviceGroupSwapchainCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR> { typedef VkDeviceGroupSwapchainCreateInfoKHR Type; }; // Map type VkDisplayModeCreateInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkDisplayModeCreateInfoKHR> { +template <> +struct LvlTypeMap<VkDisplayModeCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR> { typedef VkDisplayModeCreateInfoKHR Type; }; // Map type VkDisplaySurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkDisplaySurfaceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkDisplaySurfaceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR> { typedef VkDisplaySurfaceCreateInfoKHR Type; }; // Map type VkDisplayPresentInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR -template <> struct LvlTypeMap<VkDisplayPresentInfoKHR> { +template <> +struct LvlTypeMap<VkDisplayPresentInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR> { typedef VkDisplayPresentInfoKHR Type; }; #ifdef VK_USE_PLATFORM_XLIB_KHR // Map type VkXlibSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkXlibSurfaceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkXlibSurfaceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR> { typedef VkXlibSurfaceCreateInfoKHR Type; }; -#endif // VK_USE_PLATFORM_XLIB_KHR +#endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR // Map type VkXcbSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkXcbSurfaceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkXcbSurfaceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR> { typedef VkXcbSurfaceCreateInfoKHR Type; }; -#endif // VK_USE_PLATFORM_XCB_KHR +#endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR // Map type VkWaylandSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkWaylandSurfaceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkWaylandSurfaceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR> { typedef VkWaylandSurfaceCreateInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WAYLAND_KHR +#endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR // Map type VkAndroidSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkAndroidSurfaceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkAndroidSurfaceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR> { typedef VkAndroidSurfaceCreateInfoKHR Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkWin32SurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkWin32SurfaceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkWin32SurfaceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR> { typedef VkWin32SurfaceCreateInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR // Map type VkQueueFamilyQueryResultStatusPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR -template <> struct LvlTypeMap<VkQueueFamilyQueryResultStatusPropertiesKHR> { +template <> +struct LvlTypeMap<VkQueueFamilyQueryResultStatusPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR> { typedef VkQueueFamilyQueryResultStatusPropertiesKHR Type; }; // Map type VkQueueFamilyVideoPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR -template <> struct LvlTypeMap<VkQueueFamilyVideoPropertiesKHR> { +template <> +struct LvlTypeMap<VkQueueFamilyVideoPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR> { typedef VkQueueFamilyVideoPropertiesKHR Type; }; // Map type VkVideoProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR -template <> struct LvlTypeMap<VkVideoProfileInfoKHR> { +template <> +struct LvlTypeMap<VkVideoProfileInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR> { typedef VkVideoProfileInfoKHR Type; }; // Map type VkVideoProfileListInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR -template <> struct LvlTypeMap<VkVideoProfileListInfoKHR> { +template <> +struct LvlTypeMap<VkVideoProfileListInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR> { typedef VkVideoProfileListInfoKHR Type; }; // Map type VkVideoCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoCapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR> { typedef VkVideoCapabilitiesKHR Type; }; // Map type VkPhysicalDeviceVideoFormatInfoKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceVideoFormatInfoKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoFormatInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR> { typedef VkPhysicalDeviceVideoFormatInfoKHR Type; }; // Map type VkVideoFormatPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoFormatPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoFormatPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR> { typedef VkVideoFormatPropertiesKHR Type; }; // Map type VkVideoPictureResourceInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR -template <> struct LvlTypeMap<VkVideoPictureResourceInfoKHR> { +template <> +struct LvlTypeMap<VkVideoPictureResourceInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR> { typedef VkVideoPictureResourceInfoKHR Type; }; // Map type VkVideoReferenceSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR -template <> struct LvlTypeMap<VkVideoReferenceSlotInfoKHR> { +template <> +struct LvlTypeMap<VkVideoReferenceSlotInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR> { typedef VkVideoReferenceSlotInfoKHR Type; }; // Map type VkVideoSessionMemoryRequirementsKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR -template <> struct LvlTypeMap<VkVideoSessionMemoryRequirementsKHR> { +template <> +struct LvlTypeMap<VkVideoSessionMemoryRequirementsKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR> { typedef VkVideoSessionMemoryRequirementsKHR Type; }; // Map type VkBindVideoSessionMemoryInfoKHR to id VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR -template <> struct LvlTypeMap<VkBindVideoSessionMemoryInfoKHR> { +template <> +struct LvlTypeMap<VkBindVideoSessionMemoryInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR> { typedef VkBindVideoSessionMemoryInfoKHR Type; }; // Map type VkVideoSessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoSessionCreateInfoKHR> { +template <> +struct LvlTypeMap<VkVideoSessionCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR> { typedef VkVideoSessionCreateInfoKHR Type; }; // Map type VkVideoSessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoSessionParametersCreateInfoKHR> { +template <> +struct LvlTypeMap<VkVideoSessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoSessionParametersCreateInfoKHR Type; }; // Map type VkVideoSessionParametersUpdateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoSessionParametersUpdateInfoKHR> { +template <> +struct LvlTypeMap<VkVideoSessionParametersUpdateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR> { typedef VkVideoSessionParametersUpdateInfoKHR Type; }; // Map type VkVideoBeginCodingInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR -template <> struct LvlTypeMap<VkVideoBeginCodingInfoKHR> { +template <> +struct LvlTypeMap<VkVideoBeginCodingInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR> { typedef VkVideoBeginCodingInfoKHR Type; }; // Map type VkVideoEndCodingInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR -template <> struct LvlTypeMap<VkVideoEndCodingInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEndCodingInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR> { typedef VkVideoEndCodingInfoKHR Type; }; // Map type VkVideoCodingControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR -template <> struct LvlTypeMap<VkVideoCodingControlInfoKHR> { +template <> +struct LvlTypeMap<VkVideoCodingControlInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR> { typedef VkVideoCodingControlInfoKHR Type; }; // Map type VkVideoDecodeCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoDecodeCapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR> { typedef VkVideoDecodeCapabilitiesKHR Type; }; // Map type VkVideoDecodeUsageInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeUsageInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeUsageInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR> { typedef VkVideoDecodeUsageInfoKHR Type; }; // Map type VkVideoDecodeInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR> { typedef VkVideoDecodeInfoKHR Type; }; // Map type VkVideoEncodeH264CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264CapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264CapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR> { typedef VkVideoEncodeH264CapabilitiesKHR Type; }; // Map type VkVideoEncodeH264QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264QualityLevelPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264QualityLevelPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR> { typedef VkVideoEncodeH264QualityLevelPropertiesKHR Type; }; // Map type VkVideoEncodeH264SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264SessionCreateInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264SessionCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR> { typedef VkVideoEncodeH264SessionCreateInfoKHR Type; }; // Map type VkVideoEncodeH264SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264SessionParametersAddInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264SessionParametersAddInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR> { typedef VkVideoEncodeH264SessionParametersAddInfoKHR Type; }; -// Map type VkVideoEncodeH264SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264SessionParametersCreateInfoKHR> { +// Map type VkVideoEncodeH264SessionParametersCreateInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeH264SessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoEncodeH264SessionParametersCreateInfoKHR Type; }; // Map type VkVideoEncodeH264SessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264SessionParametersGetInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264SessionParametersGetInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR> { typedef VkVideoEncodeH264SessionParametersGetInfoKHR Type; }; -// Map type VkVideoEncodeH264SessionParametersFeedbackInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264SessionParametersFeedbackInfoKHR> { +// Map type VkVideoEncodeH264SessionParametersFeedbackInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeH264SessionParametersFeedbackInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> { typedef VkVideoEncodeH264SessionParametersFeedbackInfoKHR Type; }; // Map type VkVideoEncodeH264NaluSliceInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264NaluSliceInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264NaluSliceInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR> { typedef VkVideoEncodeH264NaluSliceInfoKHR Type; }; // Map type VkVideoEncodeH264PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264PictureInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264PictureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR> { typedef VkVideoEncodeH264PictureInfoKHR Type; }; // Map type VkVideoEncodeH264DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264DpbSlotInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264DpbSlotInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR> { typedef VkVideoEncodeH264DpbSlotInfoKHR Type; }; // Map type VkVideoEncodeH264ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264ProfileInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264ProfileInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR> { typedef VkVideoEncodeH264ProfileInfoKHR Type; }; // Map type VkVideoEncodeH264RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264RateControlInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264RateControlInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR> { typedef VkVideoEncodeH264RateControlInfoKHR Type; }; // Map type VkVideoEncodeH264RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264RateControlLayerInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264RateControlLayerInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR> { typedef VkVideoEncodeH264RateControlLayerInfoKHR Type; }; // Map type VkVideoEncodeH264GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264GopRemainingFrameInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH264GopRemainingFrameInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR> { typedef VkVideoEncodeH264GopRemainingFrameInfoKHR Type; }; // Map type VkVideoEncodeH265CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265CapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265CapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR> { typedef VkVideoEncodeH265CapabilitiesKHR Type; }; // Map type VkVideoEncodeH265SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265SessionCreateInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265SessionCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR> { typedef VkVideoEncodeH265SessionCreateInfoKHR Type; }; // Map type VkVideoEncodeH265QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265QualityLevelPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265QualityLevelPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR> { typedef VkVideoEncodeH265QualityLevelPropertiesKHR Type; }; // Map type VkVideoEncodeH265SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265SessionParametersAddInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265SessionParametersAddInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR> { typedef VkVideoEncodeH265SessionParametersAddInfoKHR Type; }; -// Map type VkVideoEncodeH265SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265SessionParametersCreateInfoKHR> { +// Map type VkVideoEncodeH265SessionParametersCreateInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeH265SessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoEncodeH265SessionParametersCreateInfoKHR Type; }; // Map type VkVideoEncodeH265SessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265SessionParametersGetInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265SessionParametersGetInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR> { typedef VkVideoEncodeH265SessionParametersGetInfoKHR Type; }; -// Map type VkVideoEncodeH265SessionParametersFeedbackInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265SessionParametersFeedbackInfoKHR> { +// Map type VkVideoEncodeH265SessionParametersFeedbackInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeH265SessionParametersFeedbackInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> { typedef VkVideoEncodeH265SessionParametersFeedbackInfoKHR Type; }; // Map type VkVideoEncodeH265NaluSliceSegmentInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265NaluSliceSegmentInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265NaluSliceSegmentInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR> { typedef VkVideoEncodeH265NaluSliceSegmentInfoKHR Type; }; // Map type VkVideoEncodeH265PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265PictureInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265PictureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR> { typedef VkVideoEncodeH265PictureInfoKHR Type; }; // Map type VkVideoEncodeH265DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265DpbSlotInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265DpbSlotInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR> { typedef VkVideoEncodeH265DpbSlotInfoKHR Type; }; // Map type VkVideoEncodeH265ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265ProfileInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265ProfileInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR> { typedef VkVideoEncodeH265ProfileInfoKHR Type; }; // Map type VkVideoEncodeH265RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265RateControlInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265RateControlInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR> { typedef VkVideoEncodeH265RateControlInfoKHR Type; }; // Map type VkVideoEncodeH265RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265RateControlLayerInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265RateControlLayerInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR> { typedef VkVideoEncodeH265RateControlLayerInfoKHR Type; }; // Map type VkVideoEncodeH265GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265GopRemainingFrameInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeH265GopRemainingFrameInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR> { typedef VkVideoEncodeH265GopRemainingFrameInfoKHR Type; }; // Map type VkVideoDecodeH264ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH264ProfileInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH264ProfileInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR> { typedef VkVideoDecodeH264ProfileInfoKHR Type; }; // Map type VkVideoDecodeH264CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoDecodeH264CapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH264CapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR> { typedef VkVideoDecodeH264CapabilitiesKHR Type; }; // Map type VkVideoDecodeH264SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH264SessionParametersAddInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH264SessionParametersAddInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR> { typedef VkVideoDecodeH264SessionParametersAddInfoKHR Type; }; -// Map type VkVideoDecodeH264SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH264SessionParametersCreateInfoKHR> { +// Map type VkVideoDecodeH264SessionParametersCreateInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeH264SessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoDecodeH264SessionParametersCreateInfoKHR Type; }; // Map type VkVideoDecodeH264PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH264PictureInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH264PictureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR> { typedef VkVideoDecodeH264PictureInfoKHR Type; }; // Map type VkVideoDecodeH264DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH264DpbSlotInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH264DpbSlotInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR> { typedef VkVideoDecodeH264DpbSlotInfoKHR Type; }; #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkImportMemoryWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkImportMemoryWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkImportMemoryWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR> { typedef VkImportMemoryWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkExportMemoryWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkExportMemoryWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkExportMemoryWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR> { typedef VkExportMemoryWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkMemoryWin32HandlePropertiesKHR to id VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR -template <> struct LvlTypeMap<VkMemoryWin32HandlePropertiesKHR> { +template <> +struct LvlTypeMap<VkMemoryWin32HandlePropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR> { typedef VkMemoryWin32HandlePropertiesKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkMemoryGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkMemoryGetWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkMemoryGetWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR> { typedef VkMemoryGetWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR // Map type VkImportMemoryFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR -template <> struct LvlTypeMap<VkImportMemoryFdInfoKHR> { +template <> +struct LvlTypeMap<VkImportMemoryFdInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR> { typedef VkImportMemoryFdInfoKHR Type; }; // Map type VkMemoryFdPropertiesKHR to id VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR -template <> struct LvlTypeMap<VkMemoryFdPropertiesKHR> { +template <> +struct LvlTypeMap<VkMemoryFdPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR> { typedef VkMemoryFdPropertiesKHR Type; }; // Map type VkMemoryGetFdInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR -template <> struct LvlTypeMap<VkMemoryGetFdInfoKHR> { +template <> +struct LvlTypeMap<VkMemoryGetFdInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR> { typedef VkMemoryGetFdInfoKHR Type; }; #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkWin32KeyedMutexAcquireReleaseInfoKHR to id VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR -template <> struct LvlTypeMap<VkWin32KeyedMutexAcquireReleaseInfoKHR> { +template <> +struct LvlTypeMap<VkWin32KeyedMutexAcquireReleaseInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR> { typedef VkWin32KeyedMutexAcquireReleaseInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkImportSemaphoreWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkImportSemaphoreWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkImportSemaphoreWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR> { typedef VkImportSemaphoreWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkExportSemaphoreWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkExportSemaphoreWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkExportSemaphoreWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR> { typedef VkExportSemaphoreWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkD3D12FenceSubmitInfoKHR to id VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR -template <> struct LvlTypeMap<VkD3D12FenceSubmitInfoKHR> { +template <> +struct LvlTypeMap<VkD3D12FenceSubmitInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR> { typedef VkD3D12FenceSubmitInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkSemaphoreGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkSemaphoreGetWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkSemaphoreGetWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR> { typedef VkSemaphoreGetWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR // Map type VkImportSemaphoreFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR -template <> struct LvlTypeMap<VkImportSemaphoreFdInfoKHR> { +template <> +struct LvlTypeMap<VkImportSemaphoreFdInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR> { typedef VkImportSemaphoreFdInfoKHR Type; }; // Map type VkSemaphoreGetFdInfoKHR to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR -template <> struct LvlTypeMap<VkSemaphoreGetFdInfoKHR> { +template <> +struct LvlTypeMap<VkSemaphoreGetFdInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR> { typedef VkSemaphoreGetFdInfoKHR Type; }; // Map type VkPresentRegionsKHR to id VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR -template <> struct LvlTypeMap<VkPresentRegionsKHR> { +template <> +struct LvlTypeMap<VkPresentRegionsKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR> { typedef VkPresentRegionsKHR Type; }; // Map type VkSharedPresentSurfaceCapabilitiesKHR to id VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkSharedPresentSurfaceCapabilitiesKHR> { +template <> +struct LvlTypeMap<VkSharedPresentSurfaceCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR> { typedef VkSharedPresentSurfaceCapabilitiesKHR Type; }; #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkImportFenceWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkImportFenceWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkImportFenceWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR> { typedef VkImportFenceWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkExportFenceWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkExportFenceWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkExportFenceWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR> { typedef VkExportFenceWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkFenceGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR -template <> struct LvlTypeMap<VkFenceGetWin32HandleInfoKHR> { +template <> +struct LvlTypeMap<VkFenceGetWin32HandleInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR> { typedef VkFenceGetWin32HandleInfoKHR Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR // Map type VkImportFenceFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR -template <> struct LvlTypeMap<VkImportFenceFdInfoKHR> { +template <> +struct LvlTypeMap<VkImportFenceFdInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR> { typedef VkImportFenceFdInfoKHR Type; }; // Map type VkFenceGetFdInfoKHR to id VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR -template <> struct LvlTypeMap<VkFenceGetFdInfoKHR> { +template <> +struct LvlTypeMap<VkFenceGetFdInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR> { typedef VkFenceGetFdInfoKHR Type; }; // Map type VkPhysicalDevicePerformanceQueryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePerformanceQueryFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePerformanceQueryFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR> { typedef VkPhysicalDevicePerformanceQueryFeaturesKHR Type; }; // Map type VkPhysicalDevicePerformanceQueryPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePerformanceQueryPropertiesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePerformanceQueryPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR> { typedef VkPhysicalDevicePerformanceQueryPropertiesKHR Type; }; // Map type VkPerformanceCounterKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR -template <> struct LvlTypeMap<VkPerformanceCounterKHR> { +template <> +struct LvlTypeMap<VkPerformanceCounterKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR> { typedef VkPerformanceCounterKHR Type; }; // Map type VkPerformanceCounterDescriptionKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR -template <> struct LvlTypeMap<VkPerformanceCounterDescriptionKHR> { +template <> +struct LvlTypeMap<VkPerformanceCounterDescriptionKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR> { typedef VkPerformanceCounterDescriptionKHR Type; }; // Map type VkQueryPoolPerformanceCreateInfoKHR to id VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkQueryPoolPerformanceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkQueryPoolPerformanceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR> { typedef VkQueryPoolPerformanceCreateInfoKHR Type; }; // Map type VkAcquireProfilingLockInfoKHR to id VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR -template <> struct LvlTypeMap<VkAcquireProfilingLockInfoKHR> { +template <> +struct LvlTypeMap<VkAcquireProfilingLockInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR> { typedef VkAcquireProfilingLockInfoKHR Type; }; // Map type VkPerformanceQuerySubmitInfoKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR -template <> struct LvlTypeMap<VkPerformanceQuerySubmitInfoKHR> { +template <> +struct LvlTypeMap<VkPerformanceQuerySubmitInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR> { typedef VkPerformanceQuerySubmitInfoKHR Type; }; // Map type VkPhysicalDeviceSurfaceInfo2KHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceSurfaceInfo2KHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceSurfaceInfo2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR> { typedef VkPhysicalDeviceSurfaceInfo2KHR Type; }; // Map type VkSurfaceCapabilities2KHR to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR -template <> struct LvlTypeMap<VkSurfaceCapabilities2KHR> { +template <> +struct LvlTypeMap<VkSurfaceCapabilities2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR> { typedef VkSurfaceCapabilities2KHR Type; }; // Map type VkSurfaceFormat2KHR to id VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR -template <> struct LvlTypeMap<VkSurfaceFormat2KHR> { +template <> +struct LvlTypeMap<VkSurfaceFormat2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR> { typedef VkSurfaceFormat2KHR Type; }; // Map type VkDisplayProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR -template <> struct LvlTypeMap<VkDisplayProperties2KHR> { +template <> +struct LvlTypeMap<VkDisplayProperties2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR> { typedef VkDisplayProperties2KHR Type; }; // Map type VkDisplayPlaneProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR -template <> struct LvlTypeMap<VkDisplayPlaneProperties2KHR> { +template <> +struct LvlTypeMap<VkDisplayPlaneProperties2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR> { typedef VkDisplayPlaneProperties2KHR Type; }; // Map type VkDisplayModeProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR -template <> struct LvlTypeMap<VkDisplayModeProperties2KHR> { +template <> +struct LvlTypeMap<VkDisplayModeProperties2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR> { typedef VkDisplayModeProperties2KHR Type; }; // Map type VkDisplayPlaneInfo2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR -template <> struct LvlTypeMap<VkDisplayPlaneInfo2KHR> { +template <> +struct LvlTypeMap<VkDisplayPlaneInfo2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR> { typedef VkDisplayPlaneInfo2KHR Type; }; // Map type VkDisplayPlaneCapabilities2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR -template <> struct LvlTypeMap<VkDisplayPlaneCapabilities2KHR> { +template <> +struct LvlTypeMap<VkDisplayPlaneCapabilities2KHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR> { typedef VkDisplayPlaneCapabilities2KHR Type; }; +// Map type VkPhysicalDeviceShaderBfloat16FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderBfloat16FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR> { + typedef VkPhysicalDeviceShaderBfloat16FeaturesKHR Type; +}; + #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDevicePortabilitySubsetFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePortabilitySubsetFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePortabilitySubsetFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR> { typedef VkPhysicalDevicePortabilitySubsetFeaturesKHR Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDevicePortabilitySubsetPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePortabilitySubsetPropertiesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePortabilitySubsetPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR> { typedef VkPhysicalDevicePortabilitySubsetPropertiesKHR Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDeviceShaderClockFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceShaderClockFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderClockFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR> { typedef VkPhysicalDeviceShaderClockFeaturesKHR Type; }; // Map type VkVideoDecodeH265ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH265ProfileInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH265ProfileInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR> { typedef VkVideoDecodeH265ProfileInfoKHR Type; }; // Map type VkVideoDecodeH265CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoDecodeH265CapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH265CapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR> { typedef VkVideoDecodeH265CapabilitiesKHR Type; }; // Map type VkVideoDecodeH265SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH265SessionParametersAddInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH265SessionParametersAddInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR> { typedef VkVideoDecodeH265SessionParametersAddInfoKHR Type; }; -// Map type VkVideoDecodeH265SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH265SessionParametersCreateInfoKHR> { +// Map type VkVideoDecodeH265SessionParametersCreateInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeH265SessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoDecodeH265SessionParametersCreateInfoKHR Type; }; // Map type VkVideoDecodeH265PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH265PictureInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH265PictureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR> { typedef VkVideoDecodeH265PictureInfoKHR Type; }; // Map type VkVideoDecodeH265DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeH265DpbSlotInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeH265DpbSlotInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR> { typedef VkVideoDecodeH265DpbSlotInfoKHR Type; }; // Map type VkFragmentShadingRateAttachmentInfoKHR to id VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR -template <> struct LvlTypeMap<VkFragmentShadingRateAttachmentInfoKHR> { +template <> +struct LvlTypeMap<VkFragmentShadingRateAttachmentInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR> { typedef VkFragmentShadingRateAttachmentInfoKHR Type; }; -// Map type VkPipelineFragmentShadingRateStateCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkPipelineFragmentShadingRateStateCreateInfoKHR> { +// Map type VkPipelineFragmentShadingRateStateCreateInfoKHR to id +// VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkPipelineFragmentShadingRateStateCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR> { typedef VkPipelineFragmentShadingRateStateCreateInfoKHR Type; }; -// Map type VkPhysicalDeviceFragmentShadingRateFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateFeaturesKHR> { +// Map type VkPhysicalDeviceFragmentShadingRateFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR> { typedef VkPhysicalDeviceFragmentShadingRateFeaturesKHR Type; }; -// Map type VkPhysicalDeviceFragmentShadingRatePropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRatePropertiesKHR> { +// Map type VkPhysicalDeviceFragmentShadingRatePropertiesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRatePropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR> { typedef VkPhysicalDeviceFragmentShadingRatePropertiesKHR Type; }; // Map type VkPhysicalDeviceFragmentShadingRateKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR> { typedef VkPhysicalDeviceFragmentShadingRateKHR Type; }; -// Map type VkRenderingFragmentShadingRateAttachmentInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR -template <> struct LvlTypeMap<VkRenderingFragmentShadingRateAttachmentInfoKHR> { +// Map type VkRenderingFragmentShadingRateAttachmentInfoKHR to id +// VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR +template <> +struct LvlTypeMap<VkRenderingFragmentShadingRateAttachmentInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR> { typedef VkRenderingFragmentShadingRateAttachmentInfoKHR Type; }; +// Map type VkPhysicalDeviceShaderConstantDataFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderConstantDataFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR> { + typedef VkPhysicalDeviceShaderConstantDataFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceShaderAbortFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderAbortFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR> { + typedef VkPhysicalDeviceShaderAbortFeaturesKHR Type; +}; + +// Map type VkDeviceFaultShaderAbortMessageInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR +template <> +struct LvlTypeMap<VkDeviceFaultShaderAbortMessageInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR> { + typedef VkDeviceFaultShaderAbortMessageInfoKHR Type; +}; + +// Map type VkPhysicalDeviceShaderAbortPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderAbortPropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR> { + typedef VkPhysicalDeviceShaderAbortPropertiesKHR Type; +}; + // Map type VkPhysicalDeviceShaderQuadControlFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceShaderQuadControlFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderQuadControlFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR> { typedef VkPhysicalDeviceShaderQuadControlFeaturesKHR Type; }; // Map type VkSurfaceProtectedCapabilitiesKHR to id VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkSurfaceProtectedCapabilitiesKHR> { +template <> +struct LvlTypeMap<VkSurfaceProtectedCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR> { typedef VkSurfaceProtectedCapabilitiesKHR Type; }; // Map type VkPhysicalDevicePresentWaitFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePresentWaitFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePresentWaitFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR> { typedef VkPhysicalDevicePresentWaitFeaturesKHR Type; }; -// Map type VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR> { +// Map type VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR> { typedef VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR Type; }; // Map type VkPipelineInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR -template <> struct LvlTypeMap<VkPipelineInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR> { typedef VkPipelineInfoKHR Type; }; // Map type VkPipelineExecutablePropertiesKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPipelineExecutablePropertiesKHR> { +template <> +struct LvlTypeMap<VkPipelineExecutablePropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR> { typedef VkPipelineExecutablePropertiesKHR Type; }; // Map type VkPipelineExecutableInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR -template <> struct LvlTypeMap<VkPipelineExecutableInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineExecutableInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR> { typedef VkPipelineExecutableInfoKHR Type; }; // Map type VkPipelineExecutableStatisticKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR -template <> struct LvlTypeMap<VkPipelineExecutableStatisticKHR> { +template <> +struct LvlTypeMap<VkPipelineExecutableStatisticKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR> { typedef VkPipelineExecutableStatisticKHR Type; }; // Map type VkPipelineExecutableInternalRepresentationKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR -template <> struct LvlTypeMap<VkPipelineExecutableInternalRepresentationKHR> { +template <> +struct LvlTypeMap<VkPipelineExecutableInternalRepresentationKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR> { typedef VkPipelineExecutableInternalRepresentationKHR Type; }; // Map type VkPipelineLibraryCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkPipelineLibraryCreateInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineLibraryCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR> { typedef VkPipelineLibraryCreateInfoKHR Type; }; // Map type VkPresentIdKHR to id VK_STRUCTURE_TYPE_PRESENT_ID_KHR -template <> struct LvlTypeMap<VkPresentIdKHR> { +template <> +struct LvlTypeMap<VkPresentIdKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_ID_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_ID_KHR> { typedef VkPresentIdKHR Type; }; // Map type VkPhysicalDevicePresentIdFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePresentIdFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePresentIdFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR> { typedef VkPhysicalDevicePresentIdFeaturesKHR Type; }; // Map type VkVideoEncodeInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR> { typedef VkVideoEncodeInfoKHR Type; }; // Map type VkVideoEncodeCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeCapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR> { typedef VkVideoEncodeCapabilitiesKHR Type; }; // Map type VkQueryPoolVideoEncodeFeedbackCreateInfoKHR to id VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR> { +template <> +struct LvlTypeMap<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR> { typedef VkQueryPoolVideoEncodeFeedbackCreateInfoKHR Type; }; // Map type VkVideoEncodeUsageInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeUsageInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeUsageInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR> { typedef VkVideoEncodeUsageInfoKHR Type; }; // Map type VkVideoEncodeRateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeRateControlLayerInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeRateControlLayerInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR> { typedef VkVideoEncodeRateControlLayerInfoKHR Type; }; // Map type VkVideoEncodeRateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeRateControlInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeRateControlInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR> { typedef VkVideoEncodeRateControlInfoKHR Type; }; -// Map type VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR> { +// Map type VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR> { typedef VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR Type; }; // Map type VkVideoEncodeQualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeQualityLevelPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeQualityLevelPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR> { typedef VkVideoEncodeQualityLevelPropertiesKHR Type; }; // Map type VkVideoEncodeQualityLevelInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeQualityLevelInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeQualityLevelInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR> { typedef VkVideoEncodeQualityLevelInfoKHR Type; }; // Map type VkVideoEncodeSessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeSessionParametersGetInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeSessionParametersGetInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR> { typedef VkVideoEncodeSessionParametersGetInfoKHR Type; }; // Map type VkVideoEncodeSessionParametersFeedbackInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeSessionParametersFeedbackInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeSessionParametersFeedbackInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> { typedef VkVideoEncodeSessionParametersFeedbackInfoKHR Type; }; -// Map type VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR> { +// Map type VkDeviceMemoryCopyKHR to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR +template <> +struct LvlTypeMap<VkDeviceMemoryCopyKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR> { + typedef VkDeviceMemoryCopyKHR Type; +}; + +// Map type VkCopyDeviceMemoryInfoKHR to id VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR +template <> +struct LvlTypeMap<VkCopyDeviceMemoryInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR> { + typedef VkCopyDeviceMemoryInfoKHR Type; +}; + +// Map type VkDeviceMemoryImageCopyKHR to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR +template <> +struct LvlTypeMap<VkDeviceMemoryImageCopyKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR> { + typedef VkDeviceMemoryImageCopyKHR Type; +}; + +// Map type VkCopyDeviceMemoryImageInfoKHR to id VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR +template <> +struct LvlTypeMap<VkCopyDeviceMemoryImageInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR> { + typedef VkCopyDeviceMemoryImageInfoKHR Type; +}; + +// Map type VkMemoryRangeBarrierKHR to id VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR +template <> +struct LvlTypeMap<VkMemoryRangeBarrierKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR> { + typedef VkMemoryRangeBarrierKHR Type; +}; + +// Map type VkMemoryRangeBarriersInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR +template <> +struct LvlTypeMap<VkMemoryRangeBarriersInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR> { + typedef VkMemoryRangeBarriersInfoKHR Type; +}; + +// Map type VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR> { + typedef VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR Type; +}; + +// Map type VkBindIndexBuffer3InfoKHR to id VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR +template <> +struct LvlTypeMap<VkBindIndexBuffer3InfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR> { + typedef VkBindIndexBuffer3InfoKHR Type; +}; + +// Map type VkBindVertexBuffer3InfoKHR to id VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR +template <> +struct LvlTypeMap<VkBindVertexBuffer3InfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR> { + typedef VkBindVertexBuffer3InfoKHR Type; +}; + +// Map type VkDrawIndirect2InfoKHR to id VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR +template <> +struct LvlTypeMap<VkDrawIndirect2InfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR> { + typedef VkDrawIndirect2InfoKHR Type; +}; + +// Map type VkDrawIndirectCount2InfoKHR to id VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR +template <> +struct LvlTypeMap<VkDrawIndirectCount2InfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR> { + typedef VkDrawIndirectCount2InfoKHR Type; +}; + +// Map type VkDispatchIndirect2InfoKHR to id VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR +template <> +struct LvlTypeMap<VkDispatchIndirect2InfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR> { + typedef VkDispatchIndirect2InfoKHR Type; +}; + +// Map type VkConditionalRenderingBeginInfo2EXT to id VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT +template <> +struct LvlTypeMap<VkConditionalRenderingBeginInfo2EXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT> { + typedef VkConditionalRenderingBeginInfo2EXT Type; +}; + +// Map type VkBindTransformFeedbackBuffer2InfoEXT to id VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT +template <> +struct LvlTypeMap<VkBindTransformFeedbackBuffer2InfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT> { + typedef VkBindTransformFeedbackBuffer2InfoEXT Type; +}; + +// Map type VkMemoryMarkerInfoAMD to id VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD +template <> +struct LvlTypeMap<VkMemoryMarkerInfoAMD> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD> { + typedef VkMemoryMarkerInfoAMD Type; +}; + +// Map type VkAccelerationStructureCreateInfo2KHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR +template <> +struct LvlTypeMap<VkAccelerationStructureCreateInfo2KHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR> { + typedef VkAccelerationStructureCreateInfo2KHR Type; +}; + +// Map type VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR> { typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR Type; }; -// Map type VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR> { +// Map type VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR> { typedef VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR Type; }; -// Map type VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR> { +// Map type VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR> { typedef VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR Type; }; -// Map type VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR> { +// Map type VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR> { typedef VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR Type; }; -// Map type VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR> { +// Map type VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR> { typedef VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR Type; }; -// Map type VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR> { +// Map type VkPhysicalDeviceShaderUntypedPointersFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderUntypedPointersFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR> { + typedef VkPhysicalDeviceShaderUntypedPointersFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR> { typedef VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR Type; }; -// Map type VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR> { +// Map type VkSurfaceCapabilitiesPresentId2KHR to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR +template <> +struct LvlTypeMap<VkSurfaceCapabilitiesPresentId2KHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR> { + typedef VkSurfaceCapabilitiesPresentId2KHR Type; +}; + +// Map type VkPresentId2KHR to id VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR +template <> +struct LvlTypeMap<VkPresentId2KHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR> { + typedef VkPresentId2KHR Type; +}; + +// Map type VkPhysicalDevicePresentId2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDevicePresentId2FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR> { + typedef VkPhysicalDevicePresentId2FeaturesKHR Type; +}; + +// Map type VkSurfaceCapabilitiesPresentWait2KHR to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR +template <> +struct LvlTypeMap<VkSurfaceCapabilitiesPresentWait2KHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR> { + typedef VkSurfaceCapabilitiesPresentWait2KHR Type; +}; + +// Map type VkPhysicalDevicePresentWait2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDevicePresentWait2FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR> { + typedef VkPhysicalDevicePresentWait2FeaturesKHR Type; +}; + +// Map type VkPresentWait2InfoKHR to id VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR +template <> +struct LvlTypeMap<VkPresentWait2InfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR> { + typedef VkPresentWait2InfoKHR Type; +}; + +// Map type VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR> { typedef VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR Type; }; // Map type VkPhysicalDevicePipelineBinaryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePipelineBinaryFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineBinaryFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR> { typedef VkPhysicalDevicePipelineBinaryFeaturesKHR Type; }; // Map type VkPhysicalDevicePipelineBinaryPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDevicePipelineBinaryPropertiesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineBinaryPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR> { typedef VkPhysicalDevicePipelineBinaryPropertiesKHR Type; }; // Map type VkDevicePipelineBinaryInternalCacheControlKHR to id VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR -template <> struct LvlTypeMap<VkDevicePipelineBinaryInternalCacheControlKHR> { +template <> +struct LvlTypeMap<VkDevicePipelineBinaryInternalCacheControlKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR> { typedef VkDevicePipelineBinaryInternalCacheControlKHR Type; }; // Map type VkPipelineBinaryKeyKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR -template <> struct LvlTypeMap<VkPipelineBinaryKeyKHR> { +template <> +struct LvlTypeMap<VkPipelineBinaryKeyKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR> { typedef VkPipelineBinaryKeyKHR Type; }; // Map type VkPipelineCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkPipelineCreateInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR> { typedef VkPipelineCreateInfoKHR Type; }; // Map type VkPipelineBinaryCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkPipelineBinaryCreateInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineBinaryCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR> { typedef VkPipelineBinaryCreateInfoKHR Type; }; // Map type VkPipelineBinaryInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR -template <> struct LvlTypeMap<VkPipelineBinaryInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineBinaryInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR> { typedef VkPipelineBinaryInfoKHR Type; }; // Map type VkReleaseCapturedPipelineDataInfoKHR to id VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR -template <> struct LvlTypeMap<VkReleaseCapturedPipelineDataInfoKHR> { +template <> +struct LvlTypeMap<VkReleaseCapturedPipelineDataInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR> { typedef VkReleaseCapturedPipelineDataInfoKHR Type; }; // Map type VkPipelineBinaryDataInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR -template <> struct LvlTypeMap<VkPipelineBinaryDataInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineBinaryDataInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR> { typedef VkPipelineBinaryDataInfoKHR Type; }; // Map type VkPipelineBinaryHandlesInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR -template <> struct LvlTypeMap<VkPipelineBinaryHandlesInfoKHR> { +template <> +struct LvlTypeMap<VkPipelineBinaryHandlesInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR> { typedef VkPipelineBinaryHandlesInfoKHR Type; }; +// Map type VkSurfacePresentModeKHR to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR +template <> +struct LvlTypeMap<VkSurfacePresentModeKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR> { + typedef VkSurfacePresentModeKHR Type; +}; + +// Map type VkSurfacePresentScalingCapabilitiesKHR to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR +template <> +struct LvlTypeMap<VkSurfacePresentScalingCapabilitiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR> { + typedef VkSurfacePresentScalingCapabilitiesKHR Type; +}; + +// Map type VkSurfacePresentModeCompatibilityKHR to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR +template <> +struct LvlTypeMap<VkSurfacePresentModeCompatibilityKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR> { + typedef VkSurfacePresentModeCompatibilityKHR Type; +}; + +// Map type VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR> { + typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR Type; +}; + +// Map type VkSwapchainPresentFenceInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR +template <> +struct LvlTypeMap<VkSwapchainPresentFenceInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR> { + typedef VkSwapchainPresentFenceInfoKHR Type; +}; + +// Map type VkSwapchainPresentModesCreateInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkSwapchainPresentModesCreateInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR> { + typedef VkSwapchainPresentModesCreateInfoKHR Type; +}; + +// Map type VkSwapchainPresentModeInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR +template <> +struct LvlTypeMap<VkSwapchainPresentModeInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR> { + typedef VkSwapchainPresentModeInfoKHR Type; +}; + +// Map type VkSwapchainPresentScalingCreateInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkSwapchainPresentScalingCreateInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR> { + typedef VkSwapchainPresentScalingCreateInfoKHR Type; +}; + +// Map type VkReleaseSwapchainImagesInfoKHR to id VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR +template <> +struct LvlTypeMap<VkReleaseSwapchainImagesInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR> { + typedef VkReleaseSwapchainImagesInfoKHR Type; +}; + +// Map type VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR> { + typedef VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR Type; +}; + // Map type VkCooperativeMatrixPropertiesKHR to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR -template <> struct LvlTypeMap<VkCooperativeMatrixPropertiesKHR> { +template <> +struct LvlTypeMap<VkCooperativeMatrixPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR> { typedef VkCooperativeMatrixPropertiesKHR Type; }; // Map type VkPhysicalDeviceCooperativeMatrixFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR> { typedef VkPhysicalDeviceCooperativeMatrixFeaturesKHR Type; }; // Map type VkPhysicalDeviceCooperativeMatrixPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixPropertiesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR> { typedef VkPhysicalDeviceCooperativeMatrixPropertiesKHR Type; }; -// Map type VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR> { +// Map type VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR> { typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR Type; }; -// Map type VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR> { +// Map type VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR> { typedef VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR Type; }; // Map type VkVideoDecodeAV1ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeAV1ProfileInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeAV1ProfileInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR> { typedef VkVideoDecodeAV1ProfileInfoKHR Type; }; // Map type VkVideoDecodeAV1CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoDecodeAV1CapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeAV1CapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR> { typedef VkVideoDecodeAV1CapabilitiesKHR Type; }; -// Map type VkVideoDecodeAV1SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeAV1SessionParametersCreateInfoKHR> { +// Map type VkVideoDecodeAV1SessionParametersCreateInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeAV1SessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoDecodeAV1SessionParametersCreateInfoKHR Type; }; // Map type VkVideoDecodeAV1PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeAV1PictureInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeAV1PictureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR> { typedef VkVideoDecodeAV1PictureInfoKHR Type; }; // Map type VkVideoDecodeAV1DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR -template <> struct LvlTypeMap<VkVideoDecodeAV1DpbSlotInfoKHR> { +template <> +struct LvlTypeMap<VkVideoDecodeAV1DpbSlotInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR> { typedef VkVideoDecodeAV1DpbSlotInfoKHR Type; }; // Map type VkPhysicalDeviceVideoEncodeAV1FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR> { typedef VkPhysicalDeviceVideoEncodeAV1FeaturesKHR Type; }; // Map type VkVideoEncodeAV1CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1CapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1CapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR> { typedef VkVideoEncodeAV1CapabilitiesKHR Type; }; // Map type VkVideoEncodeAV1QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1QualityLevelPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1QualityLevelPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR> { typedef VkVideoEncodeAV1QualityLevelPropertiesKHR Type; }; // Map type VkVideoEncodeAV1SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1SessionCreateInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1SessionCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR> { typedef VkVideoEncodeAV1SessionCreateInfoKHR Type; }; -// Map type VkVideoEncodeAV1SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1SessionParametersCreateInfoKHR> { +// Map type VkVideoEncodeAV1SessionParametersCreateInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeAV1SessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoEncodeAV1SessionParametersCreateInfoKHR Type; }; // Map type VkVideoEncodeAV1PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1PictureInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1PictureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR> { typedef VkVideoEncodeAV1PictureInfoKHR Type; }; // Map type VkVideoEncodeAV1DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1DpbSlotInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1DpbSlotInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR> { typedef VkVideoEncodeAV1DpbSlotInfoKHR Type; }; // Map type VkVideoEncodeAV1ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1ProfileInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1ProfileInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR> { typedef VkVideoEncodeAV1ProfileInfoKHR Type; }; // Map type VkVideoEncodeAV1GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1GopRemainingFrameInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1GopRemainingFrameInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR> { typedef VkVideoEncodeAV1GopRemainingFrameInfoKHR Type; }; // Map type VkVideoEncodeAV1RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1RateControlInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1RateControlInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR> { typedef VkVideoEncodeAV1RateControlInfoKHR Type; }; // Map type VkVideoEncodeAV1RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1RateControlLayerInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeAV1RateControlLayerInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR> { typedef VkVideoEncodeAV1RateControlLayerInfoKHR Type; }; +// Map type VkPhysicalDeviceVideoDecodeVP9FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR> { + typedef VkPhysicalDeviceVideoDecodeVP9FeaturesKHR Type; +}; + +// Map type VkVideoDecodeVP9ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeVP9ProfileInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR> { + typedef VkVideoDecodeVP9ProfileInfoKHR Type; +}; + +// Map type VkVideoDecodeVP9CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR +template <> +struct LvlTypeMap<VkVideoDecodeVP9CapabilitiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR> { + typedef VkVideoDecodeVP9CapabilitiesKHR Type; +}; + +// Map type VkVideoDecodeVP9PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeVP9PictureInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR> { + typedef VkVideoDecodeVP9PictureInfoKHR Type; +}; + // Map type VkPhysicalDeviceVideoMaintenance1FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceVideoMaintenance1FeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoMaintenance1FeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR> { typedef VkPhysicalDeviceVideoMaintenance1FeaturesKHR Type; }; // Map type VkVideoInlineQueryInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR -template <> struct LvlTypeMap<VkVideoInlineQueryInfoKHR> { +template <> +struct LvlTypeMap<VkVideoInlineQueryInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR> { typedef VkVideoInlineQueryInfoKHR Type; }; +// Map type VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR> { + typedef VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR Type; +}; + +// Map type VkAttachmentFeedbackLoopInfoEXT to id VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT +template <> +struct LvlTypeMap<VkAttachmentFeedbackLoopInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT> { + typedef VkAttachmentFeedbackLoopInfoEXT Type; +}; + // Map type VkCalibratedTimestampInfoKHR to id VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR -template <> struct LvlTypeMap<VkCalibratedTimestampInfoKHR> { +template <> +struct LvlTypeMap<VkCalibratedTimestampInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR> { typedef VkCalibratedTimestampInfoKHR Type; }; // Map type VkSetDescriptorBufferOffsetsInfoEXT to id VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT -template <> struct LvlTypeMap<VkSetDescriptorBufferOffsetsInfoEXT> { +template <> +struct LvlTypeMap<VkSetDescriptorBufferOffsetsInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT> { typedef VkSetDescriptorBufferOffsetsInfoEXT Type; }; // Map type VkBindDescriptorBufferEmbeddedSamplersInfoEXT to id VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT -template <> struct LvlTypeMap<VkBindDescriptorBufferEmbeddedSamplersInfoEXT> { +template <> +struct LvlTypeMap<VkBindDescriptorBufferEmbeddedSamplersInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT> { typedef VkBindDescriptorBufferEmbeddedSamplersInfoEXT Type; }; +// Map type VkCopyMemoryIndirectInfoKHR to id VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR +template <> +struct LvlTypeMap<VkCopyMemoryIndirectInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR> { + typedef VkCopyMemoryIndirectInfoKHR Type; +}; + +// Map type VkCopyMemoryToImageIndirectInfoKHR to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR +template <> +struct LvlTypeMap<VkCopyMemoryToImageIndirectInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR> { + typedef VkCopyMemoryToImageIndirectInfoKHR Type; +}; + +// Map type VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR> { + typedef VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR> { + typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR Type; +}; + +// Map type VkVideoEncodeIntraRefreshCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR +template <> +struct LvlTypeMap<VkVideoEncodeIntraRefreshCapabilitiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR> { + typedef VkVideoEncodeIntraRefreshCapabilitiesKHR Type; +}; + +// Map type VkVideoEncodeSessionIntraRefreshCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeSessionIntraRefreshCreateInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR> { + typedef VkVideoEncodeSessionIntraRefreshCreateInfoKHR Type; +}; + +// Map type VkVideoEncodeIntraRefreshInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeIntraRefreshInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR> { + typedef VkVideoEncodeIntraRefreshInfoKHR Type; +}; + +// Map type VkVideoReferenceIntraRefreshInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR +template <> +struct LvlTypeMap<VkVideoReferenceIntraRefreshInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR> { + typedef VkVideoReferenceIntraRefreshInfoKHR Type; +}; + +// Map type VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR> { + typedef VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR Type; +}; + // Map type VkVideoEncodeQuantizationMapCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeQuantizationMapCapabilitiesKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeQuantizationMapCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR> { typedef VkVideoEncodeQuantizationMapCapabilitiesKHR Type; }; // Map type VkVideoFormatQuantizationMapPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoFormatQuantizationMapPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoFormatQuantizationMapPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR> { typedef VkVideoFormatQuantizationMapPropertiesKHR Type; }; // Map type VkVideoEncodeQuantizationMapInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeQuantizationMapInfoKHR> { +template <> +struct LvlTypeMap<VkVideoEncodeQuantizationMapInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR> { typedef VkVideoEncodeQuantizationMapInfoKHR Type; }; -// Map type VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR> { +// Map type VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> +struct LvlTypeMap<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR> { typedef VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR Type; }; -// Map type VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR> { +// Map type VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR> { typedef VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR Type; }; -// Map type VkVideoEncodeH264QuantizationMapCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeH264QuantizationMapCapabilitiesKHR> { +// Map type VkVideoEncodeH264QuantizationMapCapabilitiesKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR +template <> +struct LvlTypeMap<VkVideoEncodeH264QuantizationMapCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR> { typedef VkVideoEncodeH264QuantizationMapCapabilitiesKHR Type; }; -// Map type VkVideoEncodeH265QuantizationMapCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeH265QuantizationMapCapabilitiesKHR> { +// Map type VkVideoEncodeH265QuantizationMapCapabilitiesKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR +template <> +struct LvlTypeMap<VkVideoEncodeH265QuantizationMapCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR> { typedef VkVideoEncodeH265QuantizationMapCapabilitiesKHR Type; }; // Map type VkVideoFormatH265QuantizationMapPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoFormatH265QuantizationMapPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoFormatH265QuantizationMapPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR> { typedef VkVideoFormatH265QuantizationMapPropertiesKHR Type; }; -// Map type VkVideoEncodeAV1QuantizationMapCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR -template <> struct LvlTypeMap<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR> { +// Map type VkVideoEncodeAV1QuantizationMapCapabilitiesKHR to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR +template <> +struct LvlTypeMap<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR> { typedef VkVideoEncodeAV1QuantizationMapCapabilitiesKHR Type; }; // Map type VkVideoFormatAV1QuantizationMapPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR -template <> struct LvlTypeMap<VkVideoFormatAV1QuantizationMapPropertiesKHR> { +template <> +struct LvlTypeMap<VkVideoFormatAV1QuantizationMapPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR> { typedef VkVideoFormatAV1QuantizationMapPropertiesKHR Type; }; -// Map type VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR> { +// Map type VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR> { typedef VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR Type; }; // Map type VkPhysicalDeviceMaintenance7FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance7FeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance7FeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR> { typedef VkPhysicalDeviceMaintenance7FeaturesKHR Type; }; // Map type VkPhysicalDeviceMaintenance7PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance7PropertiesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance7PropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR> { typedef VkPhysicalDeviceMaintenance7PropertiesKHR Type; }; // Map type VkPhysicalDeviceLayeredApiPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceLayeredApiPropertiesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceLayeredApiPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR> { typedef VkPhysicalDeviceLayeredApiPropertiesKHR Type; }; // Map type VkPhysicalDeviceLayeredApiPropertiesListKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceLayeredApiPropertiesListKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceLayeredApiPropertiesListKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR> { typedef VkPhysicalDeviceLayeredApiPropertiesListKHR Type; }; // Map type VkPhysicalDeviceLayeredApiVulkanPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR> { typedef VkPhysicalDeviceLayeredApiVulkanPropertiesKHR Type; }; +// Map type VkPhysicalDeviceFaultFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceFaultFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR> { + typedef VkPhysicalDeviceFaultFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceFaultPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceFaultPropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR> { + typedef VkPhysicalDeviceFaultPropertiesKHR Type; +}; + +// Map type VkDeviceFaultInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR +template <> +struct LvlTypeMap<VkDeviceFaultInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR> { + typedef VkDeviceFaultInfoKHR Type; +}; + +// Map type VkDeviceFaultDebugInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR +template <> +struct LvlTypeMap<VkDeviceFaultDebugInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR> { + typedef VkDeviceFaultDebugInfoKHR Type; +}; + +// Map type VkMemoryBarrierAccessFlags3KHR to id VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR +template <> +struct LvlTypeMap<VkMemoryBarrierAccessFlags3KHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR> { + typedef VkMemoryBarrierAccessFlags3KHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance8FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance8FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR> { + typedef VkPhysicalDeviceMaintenance8FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceShaderFmaFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderFmaFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR> { + typedef VkPhysicalDeviceShaderFmaFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance9FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance9FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR> { + typedef VkPhysicalDeviceMaintenance9FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance9PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance9PropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR> { + typedef VkPhysicalDeviceMaintenance9PropertiesKHR Type; +}; + +// Map type VkQueueFamilyOwnershipTransferPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkQueueFamilyOwnershipTransferPropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR> { + typedef VkQueueFamilyOwnershipTransferPropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceVideoMaintenance2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoMaintenance2FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR> { + typedef VkPhysicalDeviceVideoMaintenance2FeaturesKHR Type; +}; + +// Map type VkVideoDecodeH264InlineSessionParametersInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeH264InlineSessionParametersInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR> { + typedef VkVideoDecodeH264InlineSessionParametersInfoKHR Type; +}; + +// Map type VkVideoDecodeH265InlineSessionParametersInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeH265InlineSessionParametersInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR> { + typedef VkVideoDecodeH265InlineSessionParametersInfoKHR Type; +}; + +// Map type VkVideoDecodeAV1InlineSessionParametersInfoKHR to id +// VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR +template <> +struct LvlTypeMap<VkVideoDecodeAV1InlineSessionParametersInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR> { + typedef VkVideoDecodeAV1InlineSessionParametersInfoKHR Type; +}; + +// Map type VkPhysicalDeviceDepthClampZeroOneFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR> { + typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceRobustness2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceRobustness2FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR> { + typedef VkPhysicalDeviceRobustness2FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceRobustness2PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceRobustness2PropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR> { + typedef VkPhysicalDeviceRobustness2PropertiesKHR Type; +}; + +// Map type VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR> { + typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance10FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance10FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR> { + typedef VkPhysicalDeviceMaintenance10FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance10PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance10PropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR> { + typedef VkPhysicalDeviceMaintenance10PropertiesKHR Type; +}; + +// Map type VkRenderingEndInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR +template <> +struct LvlTypeMap<VkRenderingEndInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR> { + typedef VkRenderingEndInfoKHR Type; +}; + +// Map type VkRenderingAttachmentFlagsInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR +template <> +struct LvlTypeMap<VkRenderingAttachmentFlagsInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR> { + typedef VkRenderingAttachmentFlagsInfoKHR Type; +}; + +// Map type VkResolveImageModeInfoKHR to id VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR +template <> +struct LvlTypeMap<VkResolveImageModeInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR> { + typedef VkResolveImageModeInfoKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance11FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceMaintenance11FeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR> { + typedef VkPhysicalDeviceMaintenance11FeaturesKHR Type; +}; + +// Map type VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR to id +// VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR> { + typedef VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR Type; +}; + // Map type VkDebugReportCallbackCreateInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkDebugReportCallbackCreateInfoEXT> { +template <> +struct LvlTypeMap<VkDebugReportCallbackCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT> { typedef VkDebugReportCallbackCreateInfoEXT Type; }; -// Map type VkPipelineRasterizationStateRasterizationOrderAMD to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD -template <> struct LvlTypeMap<VkPipelineRasterizationStateRasterizationOrderAMD> { +// Map type VkPipelineRasterizationStateRasterizationOrderAMD to id +// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD +template <> +struct LvlTypeMap<VkPipelineRasterizationStateRasterizationOrderAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD> { typedef VkPipelineRasterizationStateRasterizationOrderAMD Type; }; // Map type VkDebugMarkerObjectNameInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT -template <> struct LvlTypeMap<VkDebugMarkerObjectNameInfoEXT> { +template <> +struct LvlTypeMap<VkDebugMarkerObjectNameInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT> { typedef VkDebugMarkerObjectNameInfoEXT Type; }; // Map type VkDebugMarkerObjectTagInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT -template <> struct LvlTypeMap<VkDebugMarkerObjectTagInfoEXT> { +template <> +struct LvlTypeMap<VkDebugMarkerObjectTagInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT> { typedef VkDebugMarkerObjectTagInfoEXT Type; }; // Map type VkDebugMarkerMarkerInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT -template <> struct LvlTypeMap<VkDebugMarkerMarkerInfoEXT> { +template <> +struct LvlTypeMap<VkDebugMarkerMarkerInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT> { typedef VkDebugMarkerMarkerInfoEXT Type; }; // Map type VkDedicatedAllocationImageCreateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkDedicatedAllocationImageCreateInfoNV> { +template <> +struct LvlTypeMap<VkDedicatedAllocationImageCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV> { typedef VkDedicatedAllocationImageCreateInfoNV Type; }; // Map type VkDedicatedAllocationBufferCreateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV -template <> struct LvlTypeMap<VkDedicatedAllocationBufferCreateInfoNV> { +template <> +struct LvlTypeMap<VkDedicatedAllocationBufferCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV> { typedef VkDedicatedAllocationBufferCreateInfoNV Type; }; // Map type VkDedicatedAllocationMemoryAllocateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV -template <> struct LvlTypeMap<VkDedicatedAllocationMemoryAllocateInfoNV> { +template <> +struct LvlTypeMap<VkDedicatedAllocationMemoryAllocateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV> { typedef VkDedicatedAllocationMemoryAllocateInfoNV Type; }; // Map type VkPhysicalDeviceTransformFeedbackFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceTransformFeedbackFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceTransformFeedbackFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT> { typedef VkPhysicalDeviceTransformFeedbackFeaturesEXT Type; }; // Map type VkPhysicalDeviceTransformFeedbackPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceTransformFeedbackPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceTransformFeedbackPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT> { typedef VkPhysicalDeviceTransformFeedbackPropertiesEXT Type; }; -// Map type VkPipelineRasterizationStateStreamCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineRasterizationStateStreamCreateInfoEXT> { +// Map type VkPipelineRasterizationStateStreamCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineRasterizationStateStreamCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT> { typedef VkPipelineRasterizationStateStreamCreateInfoEXT Type; }; // Map type VkCuModuleCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX -template <> struct LvlTypeMap<VkCuModuleCreateInfoNVX> { +template <> +struct LvlTypeMap<VkCuModuleCreateInfoNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX> { typedef VkCuModuleCreateInfoNVX Type; }; // Map type VkCuModuleTexturingModeCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX -template <> struct LvlTypeMap<VkCuModuleTexturingModeCreateInfoNVX> { +template <> +struct LvlTypeMap<VkCuModuleTexturingModeCreateInfoNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX> { typedef VkCuModuleTexturingModeCreateInfoNVX Type; }; // Map type VkCuFunctionCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX -template <> struct LvlTypeMap<VkCuFunctionCreateInfoNVX> { +template <> +struct LvlTypeMap<VkCuFunctionCreateInfoNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX> { typedef VkCuFunctionCreateInfoNVX Type; }; // Map type VkCuLaunchInfoNVX to id VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX -template <> struct LvlTypeMap<VkCuLaunchInfoNVX> { +template <> +struct LvlTypeMap<VkCuLaunchInfoNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX> { typedef VkCuLaunchInfoNVX Type; }; // Map type VkImageViewHandleInfoNVX to id VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX -template <> struct LvlTypeMap<VkImageViewHandleInfoNVX> { +template <> +struct LvlTypeMap<VkImageViewHandleInfoNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX> { typedef VkImageViewHandleInfoNVX Type; }; // Map type VkImageViewAddressPropertiesNVX to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX -template <> struct LvlTypeMap<VkImageViewAddressPropertiesNVX> { +template <> +struct LvlTypeMap<VkImageViewAddressPropertiesNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX> { typedef VkImageViewAddressPropertiesNVX Type; }; // Map type VkTextureLODGatherFormatPropertiesAMD to id VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD -template <> struct LvlTypeMap<VkTextureLODGatherFormatPropertiesAMD> { +template <> +struct LvlTypeMap<VkTextureLODGatherFormatPropertiesAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD> { typedef VkTextureLODGatherFormatPropertiesAMD Type; }; #ifdef VK_USE_PLATFORM_GGP // Map type VkStreamDescriptorSurfaceCreateInfoGGP to id VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP -template <> struct LvlTypeMap<VkStreamDescriptorSurfaceCreateInfoGGP> { +template <> +struct LvlTypeMap<VkStreamDescriptorSurfaceCreateInfoGGP> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP> { typedef VkStreamDescriptorSurfaceCreateInfoGGP Type; }; -#endif // VK_USE_PLATFORM_GGP +#endif // VK_USE_PLATFORM_GGP // Map type VkPhysicalDeviceCornerSampledImageFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCornerSampledImageFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCornerSampledImageFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV> { typedef VkPhysicalDeviceCornerSampledImageFeaturesNV Type; }; // Map type VkExternalMemoryImageCreateInfoNV to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkExternalMemoryImageCreateInfoNV> { +template <> +struct LvlTypeMap<VkExternalMemoryImageCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV> { typedef VkExternalMemoryImageCreateInfoNV Type; }; // Map type VkExportMemoryAllocateInfoNV to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV -template <> struct LvlTypeMap<VkExportMemoryAllocateInfoNV> { +template <> +struct LvlTypeMap<VkExportMemoryAllocateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV> { typedef VkExportMemoryAllocateInfoNV Type; }; #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkImportMemoryWin32HandleInfoNV to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV -template <> struct LvlTypeMap<VkImportMemoryWin32HandleInfoNV> { +template <> +struct LvlTypeMap<VkImportMemoryWin32HandleInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV> { typedef VkImportMemoryWin32HandleInfoNV Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkExportMemoryWin32HandleInfoNV to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV -template <> struct LvlTypeMap<VkExportMemoryWin32HandleInfoNV> { +template <> +struct LvlTypeMap<VkExportMemoryWin32HandleInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV> { typedef VkExportMemoryWin32HandleInfoNV Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkWin32KeyedMutexAcquireReleaseInfoNV to id VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV -template <> struct LvlTypeMap<VkWin32KeyedMutexAcquireReleaseInfoNV> { +template <> +struct LvlTypeMap<VkWin32KeyedMutexAcquireReleaseInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV> { typedef VkWin32KeyedMutexAcquireReleaseInfoNV Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR // Map type VkValidationFlagsEXT to id VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT -template <> struct LvlTypeMap<VkValidationFlagsEXT> { +template <> +struct LvlTypeMap<VkValidationFlagsEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT> { typedef VkValidationFlagsEXT Type; }; #ifdef VK_USE_PLATFORM_VI_NN // Map type VkViSurfaceCreateInfoNN to id VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN -template <> struct LvlTypeMap<VkViSurfaceCreateInfoNN> { +template <> +struct LvlTypeMap<VkViSurfaceCreateInfoNN> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN> { typedef VkViSurfaceCreateInfoNN Type; }; -#endif // VK_USE_PLATFORM_VI_NN +#endif // VK_USE_PLATFORM_VI_NN // Map type VkImageViewASTCDecodeModeEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT -template <> struct LvlTypeMap<VkImageViewASTCDecodeModeEXT> { +template <> +struct LvlTypeMap<VkImageViewASTCDecodeModeEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT> { typedef VkImageViewASTCDecodeModeEXT Type; }; // Map type VkPhysicalDeviceASTCDecodeFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceASTCDecodeFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceASTCDecodeFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT> { typedef VkPhysicalDeviceASTCDecodeFeaturesEXT Type; }; // Map type VkConditionalRenderingBeginInfoEXT to id VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT -template <> struct LvlTypeMap<VkConditionalRenderingBeginInfoEXT> { +template <> +struct LvlTypeMap<VkConditionalRenderingBeginInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT> { typedef VkConditionalRenderingBeginInfoEXT Type; }; -// Map type VkPhysicalDeviceConditionalRenderingFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceConditionalRenderingFeaturesEXT> { +// Map type VkPhysicalDeviceConditionalRenderingFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceConditionalRenderingFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT> { typedef VkPhysicalDeviceConditionalRenderingFeaturesEXT Type; }; -// Map type VkCommandBufferInheritanceConditionalRenderingInfoEXT to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT -template <> struct LvlTypeMap<VkCommandBufferInheritanceConditionalRenderingInfoEXT> { +// Map type VkCommandBufferInheritanceConditionalRenderingInfoEXT to id +// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT +template <> +struct LvlTypeMap<VkCommandBufferInheritanceConditionalRenderingInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT> { typedef VkCommandBufferInheritanceConditionalRenderingInfoEXT Type; }; // Map type VkPipelineViewportWScalingStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineViewportWScalingStateCreateInfoNV> { +template <> +struct LvlTypeMap<VkPipelineViewportWScalingStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV> { typedef VkPipelineViewportWScalingStateCreateInfoNV Type; }; // Map type VkSurfaceCapabilities2EXT to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT -template <> struct LvlTypeMap<VkSurfaceCapabilities2EXT> { +template <> +struct LvlTypeMap<VkSurfaceCapabilities2EXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT> { typedef VkSurfaceCapabilities2EXT Type; }; // Map type VkDisplayPowerInfoEXT to id VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT -template <> struct LvlTypeMap<VkDisplayPowerInfoEXT> { +template <> +struct LvlTypeMap<VkDisplayPowerInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT> { typedef VkDisplayPowerInfoEXT Type; }; // Map type VkDeviceEventInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT -template <> struct LvlTypeMap<VkDeviceEventInfoEXT> { +template <> +struct LvlTypeMap<VkDeviceEventInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT> { typedef VkDeviceEventInfoEXT Type; }; // Map type VkDisplayEventInfoEXT to id VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT -template <> struct LvlTypeMap<VkDisplayEventInfoEXT> { +template <> +struct LvlTypeMap<VkDisplayEventInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT> { typedef VkDisplayEventInfoEXT Type; }; // Map type VkSwapchainCounterCreateInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkSwapchainCounterCreateInfoEXT> { +template <> +struct LvlTypeMap<VkSwapchainCounterCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT> { typedef VkSwapchainCounterCreateInfoEXT Type; }; // Map type VkPresentTimesInfoGOOGLE to id VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE -template <> struct LvlTypeMap<VkPresentTimesInfoGOOGLE> { +template <> +struct LvlTypeMap<VkPresentTimesInfoGOOGLE> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE> { typedef VkPresentTimesInfoGOOGLE Type; }; -// Map type VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX -template <> struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> { +// Map type VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX +template <> +struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX> { typedef VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX Type; }; // Map type VkMultiviewPerViewAttributesInfoNVX to id VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX -template <> struct LvlTypeMap<VkMultiviewPerViewAttributesInfoNVX> { +template <> +struct LvlTypeMap<VkMultiviewPerViewAttributesInfoNVX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX> { typedef VkMultiviewPerViewAttributesInfoNVX Type; }; // Map type VkPipelineViewportSwizzleStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineViewportSwizzleStateCreateInfoNV> { +template <> +struct LvlTypeMap<VkPipelineViewportSwizzleStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV> { typedef VkPipelineViewportSwizzleStateCreateInfoNV Type; }; // Map type VkPhysicalDeviceDiscardRectanglePropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDiscardRectanglePropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDiscardRectanglePropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT> { typedef VkPhysicalDeviceDiscardRectanglePropertiesEXT Type; }; // Map type VkPipelineDiscardRectangleStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineDiscardRectangleStateCreateInfoEXT> { +template <> +struct LvlTypeMap<VkPipelineDiscardRectangleStateCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT> { typedef VkPipelineDiscardRectangleStateCreateInfoEXT Type; }; -// Map type VkPhysicalDeviceConservativeRasterizationPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceConservativeRasterizationPropertiesEXT> { +// Map type VkPhysicalDeviceConservativeRasterizationPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceConservativeRasterizationPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT> { typedef VkPhysicalDeviceConservativeRasterizationPropertiesEXT Type; }; -// Map type VkPipelineRasterizationConservativeStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineRasterizationConservativeStateCreateInfoEXT> { +// Map type VkPipelineRasterizationConservativeStateCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineRasterizationConservativeStateCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT> { typedef VkPipelineRasterizationConservativeStateCreateInfoEXT Type; }; // Map type VkPhysicalDeviceDepthClipEnableFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDepthClipEnableFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDepthClipEnableFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT> { typedef VkPhysicalDeviceDepthClipEnableFeaturesEXT Type; }; -// Map type VkPipelineRasterizationDepthClipStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineRasterizationDepthClipStateCreateInfoEXT> { +// Map type VkPipelineRasterizationDepthClipStateCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineRasterizationDepthClipStateCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT> { typedef VkPipelineRasterizationDepthClipStateCreateInfoEXT Type; }; // Map type VkHdrMetadataEXT to id VK_STRUCTURE_TYPE_HDR_METADATA_EXT -template <> struct LvlTypeMap<VkHdrMetadataEXT> { +template <> +struct LvlTypeMap<VkHdrMetadataEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_HDR_METADATA_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_HDR_METADATA_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_HDR_METADATA_EXT> { typedef VkHdrMetadataEXT Type; }; -// Map type VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG -template <> struct LvlTypeMap<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG> { +// Map type VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG +template <> +struct LvlTypeMap<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG> { typedef VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG Type; }; #ifdef VK_USE_PLATFORM_IOS_MVK // Map type VkIOSSurfaceCreateInfoMVK to id VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK -template <> struct LvlTypeMap<VkIOSSurfaceCreateInfoMVK> { +template <> +struct LvlTypeMap<VkIOSSurfaceCreateInfoMVK> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK> { typedef VkIOSSurfaceCreateInfoMVK Type; }; -#endif // VK_USE_PLATFORM_IOS_MVK +#endif // VK_USE_PLATFORM_IOS_MVK #ifdef VK_USE_PLATFORM_MACOS_MVK // Map type VkMacOSSurfaceCreateInfoMVK to id VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK -template <> struct LvlTypeMap<VkMacOSSurfaceCreateInfoMVK> { +template <> +struct LvlTypeMap<VkMacOSSurfaceCreateInfoMVK> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK> { typedef VkMacOSSurfaceCreateInfoMVK Type; }; -#endif // VK_USE_PLATFORM_MACOS_MVK +#endif // VK_USE_PLATFORM_MACOS_MVK // Map type VkDebugUtilsLabelEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT -template <> struct LvlTypeMap<VkDebugUtilsLabelEXT> { +template <> +struct LvlTypeMap<VkDebugUtilsLabelEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT> { typedef VkDebugUtilsLabelEXT Type; }; // Map type VkDebugUtilsObjectNameInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT -template <> struct LvlTypeMap<VkDebugUtilsObjectNameInfoEXT> { +template <> +struct LvlTypeMap<VkDebugUtilsObjectNameInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT> { typedef VkDebugUtilsObjectNameInfoEXT Type; }; // Map type VkDebugUtilsMessengerCallbackDataEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT -template <> struct LvlTypeMap<VkDebugUtilsMessengerCallbackDataEXT> { +template <> +struct LvlTypeMap<VkDebugUtilsMessengerCallbackDataEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT> { typedef VkDebugUtilsMessengerCallbackDataEXT Type; }; // Map type VkDebugUtilsMessengerCreateInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkDebugUtilsMessengerCreateInfoEXT> { +template <> +struct LvlTypeMap<VkDebugUtilsMessengerCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT> { typedef VkDebugUtilsMessengerCreateInfoEXT Type; }; // Map type VkDebugUtilsObjectTagInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT -template <> struct LvlTypeMap<VkDebugUtilsObjectTagInfoEXT> { +template <> +struct LvlTypeMap<VkDebugUtilsObjectTagInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT> { typedef VkDebugUtilsObjectTagInfoEXT Type; }; #ifdef VK_USE_PLATFORM_ANDROID_KHR // Map type VkAndroidHardwareBufferUsageANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID -template <> struct LvlTypeMap<VkAndroidHardwareBufferUsageANDROID> { +template <> +struct LvlTypeMap<VkAndroidHardwareBufferUsageANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID> { typedef VkAndroidHardwareBufferUsageANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR // Map type VkAndroidHardwareBufferPropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID -template <> struct LvlTypeMap<VkAndroidHardwareBufferPropertiesANDROID> { +template <> +struct LvlTypeMap<VkAndroidHardwareBufferPropertiesANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID> { typedef VkAndroidHardwareBufferPropertiesANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR // Map type VkAndroidHardwareBufferFormatPropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID -template <> struct LvlTypeMap<VkAndroidHardwareBufferFormatPropertiesANDROID> { +template <> +struct LvlTypeMap<VkAndroidHardwareBufferFormatPropertiesANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID> { typedef VkAndroidHardwareBufferFormatPropertiesANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR // Map type VkImportAndroidHardwareBufferInfoANDROID to id VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID -template <> struct LvlTypeMap<VkImportAndroidHardwareBufferInfoANDROID> { +template <> +struct LvlTypeMap<VkImportAndroidHardwareBufferInfoANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID> { typedef VkImportAndroidHardwareBufferInfoANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR // Map type VkMemoryGetAndroidHardwareBufferInfoANDROID to id VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID -template <> struct LvlTypeMap<VkMemoryGetAndroidHardwareBufferInfoANDROID> { +template <> +struct LvlTypeMap<VkMemoryGetAndroidHardwareBufferInfoANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID> { typedef VkMemoryGetAndroidHardwareBufferInfoANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR // Map type VkExternalFormatANDROID to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID -template <> struct LvlTypeMap<VkExternalFormatANDROID> { +template <> +struct LvlTypeMap<VkExternalFormatANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID> { typedef VkExternalFormatANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR -// Map type VkAndroidHardwareBufferFormatProperties2ANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID -template <> struct LvlTypeMap<VkAndroidHardwareBufferFormatProperties2ANDROID> { +// Map type VkAndroidHardwareBufferFormatProperties2ANDROID to id +// VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID +template <> +struct LvlTypeMap<VkAndroidHardwareBufferFormatProperties2ANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID> { typedef VkAndroidHardwareBufferFormatProperties2ANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDeviceShaderEnqueueFeaturesAMDX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX -template <> struct LvlTypeMap<VkPhysicalDeviceShaderEnqueueFeaturesAMDX> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderEnqueueFeaturesAMDX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX> { typedef VkPhysicalDeviceShaderEnqueueFeaturesAMDX Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDeviceShaderEnqueuePropertiesAMDX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX -template <> struct LvlTypeMap<VkPhysicalDeviceShaderEnqueuePropertiesAMDX> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderEnqueuePropertiesAMDX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX> { typedef VkPhysicalDeviceShaderEnqueuePropertiesAMDX Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkExecutionGraphPipelineScratchSizeAMDX to id VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX -template <> struct LvlTypeMap<VkExecutionGraphPipelineScratchSizeAMDX> { +template <> +struct LvlTypeMap<VkExecutionGraphPipelineScratchSizeAMDX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX> { typedef VkExecutionGraphPipelineScratchSizeAMDX Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkExecutionGraphPipelineCreateInfoAMDX to id VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX -template <> struct LvlTypeMap<VkExecutionGraphPipelineCreateInfoAMDX> { +template <> +struct LvlTypeMap<VkExecutionGraphPipelineCreateInfoAMDX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX> { typedef VkExecutionGraphPipelineCreateInfoAMDX Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPipelineShaderStageNodeCreateInfoAMDX to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX -template <> struct LvlTypeMap<VkPipelineShaderStageNodeCreateInfoAMDX> { +template <> +struct LvlTypeMap<VkPipelineShaderStageNodeCreateInfoAMDX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX> { typedef VkPipelineShaderStageNodeCreateInfoAMDX Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS +// Map type VkTexelBufferDescriptorInfoEXT to id VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT +template <> +struct LvlTypeMap<VkTexelBufferDescriptorInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT> { + typedef VkTexelBufferDescriptorInfoEXT Type; +}; + +// Map type VkImageDescriptorInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT +template <> +struct LvlTypeMap<VkImageDescriptorInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT> { + typedef VkImageDescriptorInfoEXT Type; +}; + +// Map type VkTensorViewCreateInfoARM to id VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkTensorViewCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM> { + typedef VkTensorViewCreateInfoARM Type; +}; + +// Map type VkResourceDescriptorInfoEXT to id VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT +template <> +struct LvlTypeMap<VkResourceDescriptorInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT> { + typedef VkResourceDescriptorInfoEXT Type; +}; + +// Map type VkBindHeapInfoEXT to id VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT +template <> +struct LvlTypeMap<VkBindHeapInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT> { + typedef VkBindHeapInfoEXT Type; +}; + +// Map type VkPushDataInfoEXT to id VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT +template <> +struct LvlTypeMap<VkPushDataInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT> { + typedef VkPushDataInfoEXT Type; +}; + +// Map type VkDescriptorSetAndBindingMappingEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT +template <> +struct LvlTypeMap<VkDescriptorSetAndBindingMappingEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT> { + typedef VkDescriptorSetAndBindingMappingEXT Type; +}; + +// Map type VkShaderDescriptorSetAndBindingMappingInfoEXT to id VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT +template <> +struct LvlTypeMap<VkShaderDescriptorSetAndBindingMappingInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT> { + typedef VkShaderDescriptorSetAndBindingMappingInfoEXT Type; +}; + +// Map type VkOpaqueCaptureDataCreateInfoEXT to id VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkOpaqueCaptureDataCreateInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT> { + typedef VkOpaqueCaptureDataCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceDescriptorHeapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorHeapFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT> { + typedef VkPhysicalDeviceDescriptorHeapFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceDescriptorHeapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorHeapPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT> { + typedef VkPhysicalDeviceDescriptorHeapPropertiesEXT Type; +}; + +// Map type VkCommandBufferInheritanceDescriptorHeapInfoEXT to id +// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT +template <> +struct LvlTypeMap<VkCommandBufferInheritanceDescriptorHeapInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT> { + typedef VkCommandBufferInheritanceDescriptorHeapInfoEXT Type; +}; + +// Map type VkSamplerCustomBorderColorIndexCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkSamplerCustomBorderColorIndexCreateInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT> { + typedef VkSamplerCustomBorderColorIndexCreateInfoEXT Type; +}; + +// Map type VkSamplerCustomBorderColorCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkSamplerCustomBorderColorCreateInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT> { + typedef VkSamplerCustomBorderColorCreateInfoEXT Type; +}; + +// Map type VkIndirectCommandsLayoutPushDataTokenNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV +template <> +struct LvlTypeMap<VkIndirectCommandsLayoutPushDataTokenNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV> { + typedef VkIndirectCommandsLayoutPushDataTokenNV Type; +}; + +// Map type VkSubsampledImageFormatPropertiesEXT to id VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkSubsampledImageFormatPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT> { + typedef VkSubsampledImageFormatPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceDescriptorHeapTensorPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorHeapTensorPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM> { + typedef VkPhysicalDeviceDescriptorHeapTensorPropertiesARM Type; +}; + // Map type VkAttachmentSampleCountInfoAMD to id VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD -template <> struct LvlTypeMap<VkAttachmentSampleCountInfoAMD> { +template <> +struct LvlTypeMap<VkAttachmentSampleCountInfoAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD> { typedef VkAttachmentSampleCountInfoAMD Type; }; // Map type VkSampleLocationsInfoEXT to id VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT -template <> struct LvlTypeMap<VkSampleLocationsInfoEXT> { +template <> +struct LvlTypeMap<VkSampleLocationsInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT> { typedef VkSampleLocationsInfoEXT Type; }; // Map type VkRenderPassSampleLocationsBeginInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT -template <> struct LvlTypeMap<VkRenderPassSampleLocationsBeginInfoEXT> { +template <> +struct LvlTypeMap<VkRenderPassSampleLocationsBeginInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT> { typedef VkRenderPassSampleLocationsBeginInfoEXT Type; }; // Map type VkPipelineSampleLocationsStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineSampleLocationsStateCreateInfoEXT> { +template <> +struct LvlTypeMap<VkPipelineSampleLocationsStateCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT> { typedef VkPipelineSampleLocationsStateCreateInfoEXT Type; }; // Map type VkPhysicalDeviceSampleLocationsPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceSampleLocationsPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceSampleLocationsPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT> { typedef VkPhysicalDeviceSampleLocationsPropertiesEXT Type; }; // Map type VkMultisamplePropertiesEXT to id VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT -template <> struct LvlTypeMap<VkMultisamplePropertiesEXT> { +template <> +struct LvlTypeMap<VkMultisamplePropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT> { typedef VkMultisamplePropertiesEXT Type; }; -// Map type VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT> { +// Map type VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT> { typedef VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT Type; }; -// Map type VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT> { +// Map type VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT> { typedef VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT Type; }; -// Map type VkPipelineColorBlendAdvancedStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineColorBlendAdvancedStateCreateInfoEXT> { +// Map type VkPipelineColorBlendAdvancedStateCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineColorBlendAdvancedStateCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT> { typedef VkPipelineColorBlendAdvancedStateCreateInfoEXT Type; }; // Map type VkPipelineCoverageToColorStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineCoverageToColorStateCreateInfoNV> { +template <> +struct LvlTypeMap<VkPipelineCoverageToColorStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV> { typedef VkPipelineCoverageToColorStateCreateInfoNV Type; }; // Map type VkPipelineCoverageModulationStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineCoverageModulationStateCreateInfoNV> { +template <> +struct LvlTypeMap<VkPipelineCoverageModulationStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV> { typedef VkPipelineCoverageModulationStateCreateInfoNV Type; }; // Map type VkPhysicalDeviceShaderSMBuiltinsPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV> { typedef VkPhysicalDeviceShaderSMBuiltinsPropertiesNV Type; }; // Map type VkPhysicalDeviceShaderSMBuiltinsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV> { typedef VkPhysicalDeviceShaderSMBuiltinsFeaturesNV Type; }; // Map type VkDrmFormatModifierPropertiesListEXT to id VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT -template <> struct LvlTypeMap<VkDrmFormatModifierPropertiesListEXT> { +template <> +struct LvlTypeMap<VkDrmFormatModifierPropertiesListEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT> { typedef VkDrmFormatModifierPropertiesListEXT Type; }; // Map type VkPhysicalDeviceImageDrmFormatModifierInfoEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceImageDrmFormatModifierInfoEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImageDrmFormatModifierInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT> { typedef VkPhysicalDeviceImageDrmFormatModifierInfoEXT Type; }; // Map type VkImageDrmFormatModifierListCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkImageDrmFormatModifierListCreateInfoEXT> { +template <> +struct LvlTypeMap<VkImageDrmFormatModifierListCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT> { typedef VkImageDrmFormatModifierListCreateInfoEXT Type; }; // Map type VkImageDrmFormatModifierExplicitCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkImageDrmFormatModifierExplicitCreateInfoEXT> { +template <> +struct LvlTypeMap<VkImageDrmFormatModifierExplicitCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT> { typedef VkImageDrmFormatModifierExplicitCreateInfoEXT Type; }; // Map type VkImageDrmFormatModifierPropertiesEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT -template <> struct LvlTypeMap<VkImageDrmFormatModifierPropertiesEXT> { +template <> +struct LvlTypeMap<VkImageDrmFormatModifierPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT> { typedef VkImageDrmFormatModifierPropertiesEXT Type; }; // Map type VkDrmFormatModifierPropertiesList2EXT to id VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT -template <> struct LvlTypeMap<VkDrmFormatModifierPropertiesList2EXT> { +template <> +struct LvlTypeMap<VkDrmFormatModifierPropertiesList2EXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT> { typedef VkDrmFormatModifierPropertiesList2EXT Type; }; // Map type VkValidationCacheCreateInfoEXT to id VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkValidationCacheCreateInfoEXT> { +template <> +struct LvlTypeMap<VkValidationCacheCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT> { typedef VkValidationCacheCreateInfoEXT Type; }; // Map type VkShaderModuleValidationCacheCreateInfoEXT to id VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkShaderModuleValidationCacheCreateInfoEXT> { +template <> +struct LvlTypeMap<VkShaderModuleValidationCacheCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT> { typedef VkShaderModuleValidationCacheCreateInfoEXT Type; }; -// Map type VkPipelineViewportShadingRateImageStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineViewportShadingRateImageStateCreateInfoNV> { +// Map type VkPipelineViewportShadingRateImageStateCreateInfoNV to id +// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkPipelineViewportShadingRateImageStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV> { typedef VkPipelineViewportShadingRateImageStateCreateInfoNV Type; }; // Map type VkPhysicalDeviceShadingRateImageFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceShadingRateImageFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShadingRateImageFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV> { typedef VkPhysicalDeviceShadingRateImageFeaturesNV Type; }; // Map type VkPhysicalDeviceShadingRateImagePropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceShadingRateImagePropertiesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShadingRateImagePropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV> { typedef VkPhysicalDeviceShadingRateImagePropertiesNV Type; }; -// Map type VkPipelineViewportCoarseSampleOrderStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV> { +// Map type VkPipelineViewportCoarseSampleOrderStateCreateInfoNV to id +// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV> { typedef VkPipelineViewportCoarseSampleOrderStateCreateInfoNV Type; }; // Map type VkRayTracingShaderGroupCreateInfoNV to id VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV -template <> struct LvlTypeMap<VkRayTracingShaderGroupCreateInfoNV> { +template <> +struct LvlTypeMap<VkRayTracingShaderGroupCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV> { typedef VkRayTracingShaderGroupCreateInfoNV Type; }; // Map type VkRayTracingPipelineCreateInfoNV to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkRayTracingPipelineCreateInfoNV> { +template <> +struct LvlTypeMap<VkRayTracingPipelineCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV> { typedef VkRayTracingPipelineCreateInfoNV Type; }; // Map type VkGeometryTrianglesNV to id VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV -template <> struct LvlTypeMap<VkGeometryTrianglesNV> { +template <> +struct LvlTypeMap<VkGeometryTrianglesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV> { typedef VkGeometryTrianglesNV Type; }; // Map type VkGeometryAABBNV to id VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV -template <> struct LvlTypeMap<VkGeometryAABBNV> { +template <> +struct LvlTypeMap<VkGeometryAABBNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV> { typedef VkGeometryAABBNV Type; }; // Map type VkGeometryNV to id VK_STRUCTURE_TYPE_GEOMETRY_NV -template <> struct LvlTypeMap<VkGeometryNV> { +template <> +struct LvlTypeMap<VkGeometryNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_NV> { typedef VkGeometryNV Type; }; // Map type VkAccelerationStructureInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV -template <> struct LvlTypeMap<VkAccelerationStructureInfoNV> { +template <> +struct LvlTypeMap<VkAccelerationStructureInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV> { typedef VkAccelerationStructureInfoNV Type; }; // Map type VkAccelerationStructureCreateInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkAccelerationStructureCreateInfoNV> { +template <> +struct LvlTypeMap<VkAccelerationStructureCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV> { typedef VkAccelerationStructureCreateInfoNV Type; }; // Map type VkBindAccelerationStructureMemoryInfoNV to id VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV -template <> struct LvlTypeMap<VkBindAccelerationStructureMemoryInfoNV> { +template <> +struct LvlTypeMap<VkBindAccelerationStructureMemoryInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV> { typedef VkBindAccelerationStructureMemoryInfoNV Type; }; // Map type VkWriteDescriptorSetAccelerationStructureNV to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV -template <> struct LvlTypeMap<VkWriteDescriptorSetAccelerationStructureNV> { +template <> +struct LvlTypeMap<VkWriteDescriptorSetAccelerationStructureNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV> { typedef VkWriteDescriptorSetAccelerationStructureNV Type; }; -// Map type VkAccelerationStructureMemoryRequirementsInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV -template <> struct LvlTypeMap<VkAccelerationStructureMemoryRequirementsInfoNV> { +// Map type VkAccelerationStructureMemoryRequirementsInfoNV to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV +template <> +struct LvlTypeMap<VkAccelerationStructureMemoryRequirementsInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV> { typedef VkAccelerationStructureMemoryRequirementsInfoNV Type; }; // Map type VkPhysicalDeviceRayTracingPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingPropertiesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV> { typedef VkPhysicalDeviceRayTracingPropertiesNV Type; }; -// Map type VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV> { +// Map type VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV> { typedef VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV Type; }; -// Map type VkPipelineRepresentativeFragmentTestStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineRepresentativeFragmentTestStateCreateInfoNV> { +// Map type VkPipelineRepresentativeFragmentTestStateCreateInfoNV to id +// VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkPipelineRepresentativeFragmentTestStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV> { typedef VkPipelineRepresentativeFragmentTestStateCreateInfoNV Type; }; // Map type VkPhysicalDeviceImageViewImageFormatInfoEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceImageViewImageFormatInfoEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImageViewImageFormatInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT> { typedef VkPhysicalDeviceImageViewImageFormatInfoEXT Type; }; -// Map type VkFilterCubicImageViewImageFormatPropertiesEXT to id VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT -template <> struct LvlTypeMap<VkFilterCubicImageViewImageFormatPropertiesEXT> { +// Map type VkFilterCubicImageViewImageFormatPropertiesEXT to id +// VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkFilterCubicImageViewImageFormatPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT> { typedef VkFilterCubicImageViewImageFormatPropertiesEXT Type; }; +// Map type VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM> { + typedef VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM Type; +}; + // Map type VkImportMemoryHostPointerInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT -template <> struct LvlTypeMap<VkImportMemoryHostPointerInfoEXT> { +template <> +struct LvlTypeMap<VkImportMemoryHostPointerInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT> { typedef VkImportMemoryHostPointerInfoEXT Type; }; // Map type VkMemoryHostPointerPropertiesEXT to id VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT -template <> struct LvlTypeMap<VkMemoryHostPointerPropertiesEXT> { +template <> +struct LvlTypeMap<VkMemoryHostPointerPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT> { typedef VkMemoryHostPointerPropertiesEXT Type; }; -// Map type VkPhysicalDeviceExternalMemoryHostPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceExternalMemoryHostPropertiesEXT> { +// Map type VkPhysicalDeviceExternalMemoryHostPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalMemoryHostPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT> { typedef VkPhysicalDeviceExternalMemoryHostPropertiesEXT Type; }; // Map type VkPipelineCompilerControlCreateInfoAMD to id VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD -template <> struct LvlTypeMap<VkPipelineCompilerControlCreateInfoAMD> { +template <> +struct LvlTypeMap<VkPipelineCompilerControlCreateInfoAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD> { typedef VkPipelineCompilerControlCreateInfoAMD Type; }; // Map type VkPhysicalDeviceShaderCorePropertiesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD -template <> struct LvlTypeMap<VkPhysicalDeviceShaderCorePropertiesAMD> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderCorePropertiesAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD> { typedef VkPhysicalDeviceShaderCorePropertiesAMD Type; }; // Map type VkDeviceMemoryOverallocationCreateInfoAMD to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD -template <> struct LvlTypeMap<VkDeviceMemoryOverallocationCreateInfoAMD> { +template <> +struct LvlTypeMap<VkDeviceMemoryOverallocationCreateInfoAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD> { typedef VkDeviceMemoryOverallocationCreateInfoAMD Type; }; -// Map type VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT> { +// Map type VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT> { typedef VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT Type; }; #ifdef VK_USE_PLATFORM_GGP // Map type VkPresentFrameTokenGGP to id VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP -template <> struct LvlTypeMap<VkPresentFrameTokenGGP> { +template <> +struct LvlTypeMap<VkPresentFrameTokenGGP> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP> { typedef VkPresentFrameTokenGGP Type; }; -#endif // VK_USE_PLATFORM_GGP +#endif // VK_USE_PLATFORM_GGP // Map type VkPhysicalDeviceMeshShaderFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceMeshShaderFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMeshShaderFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV> { typedef VkPhysicalDeviceMeshShaderFeaturesNV Type; }; // Map type VkPhysicalDeviceMeshShaderPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceMeshShaderPropertiesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMeshShaderPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV> { typedef VkPhysicalDeviceMeshShaderPropertiesNV Type; }; -// Map type VkPhysicalDeviceShaderImageFootprintFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceShaderImageFootprintFeaturesNV> { +// Map type VkPhysicalDeviceShaderImageFootprintFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderImageFootprintFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV> { typedef VkPhysicalDeviceShaderImageFootprintFeaturesNV Type; }; -// Map type VkPipelineViewportExclusiveScissorStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineViewportExclusiveScissorStateCreateInfoNV> { +// Map type VkPipelineViewportExclusiveScissorStateCreateInfoNV to id +// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkPipelineViewportExclusiveScissorStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV> { typedef VkPipelineViewportExclusiveScissorStateCreateInfoNV Type; }; // Map type VkPhysicalDeviceExclusiveScissorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceExclusiveScissorFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceExclusiveScissorFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV> { typedef VkPhysicalDeviceExclusiveScissorFeaturesNV Type; }; // Map type VkQueueFamilyCheckpointPropertiesNV to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV -template <> struct LvlTypeMap<VkQueueFamilyCheckpointPropertiesNV> { +template <> +struct LvlTypeMap<VkQueueFamilyCheckpointPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV> { typedef VkQueueFamilyCheckpointPropertiesNV Type; }; // Map type VkCheckpointDataNV to id VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV -template <> struct LvlTypeMap<VkCheckpointDataNV> { +template <> +struct LvlTypeMap<VkCheckpointDataNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV> { typedef VkCheckpointDataNV Type; }; // Map type VkQueueFamilyCheckpointProperties2NV to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV -template <> struct LvlTypeMap<VkQueueFamilyCheckpointProperties2NV> { +template <> +struct LvlTypeMap<VkQueueFamilyCheckpointProperties2NV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV> { typedef VkQueueFamilyCheckpointProperties2NV Type; }; // Map type VkCheckpointData2NV to id VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV -template <> struct LvlTypeMap<VkCheckpointData2NV> { +template <> +struct LvlTypeMap<VkCheckpointData2NV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV> { typedef VkCheckpointData2NV Type; }; -// Map type VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL -template <> struct LvlTypeMap<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> { +// Map type VkPhysicalDevicePresentTimingFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDevicePresentTimingFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT> { + typedef VkPhysicalDevicePresentTimingFeaturesEXT Type; +}; + +// Map type VkPresentTimingSurfaceCapabilitiesEXT to id VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT +template <> +struct LvlTypeMap<VkPresentTimingSurfaceCapabilitiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT> { + typedef VkPresentTimingSurfaceCapabilitiesEXT Type; +}; + +// Map type VkSwapchainCalibratedTimestampInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT +template <> +struct LvlTypeMap<VkSwapchainCalibratedTimestampInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT> { + typedef VkSwapchainCalibratedTimestampInfoEXT Type; +}; + +// Map type VkSwapchainTimingPropertiesEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkSwapchainTimingPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT> { + typedef VkSwapchainTimingPropertiesEXT Type; +}; + +// Map type VkSwapchainTimeDomainPropertiesEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkSwapchainTimeDomainPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT> { + typedef VkSwapchainTimeDomainPropertiesEXT Type; +}; + +// Map type VkPastPresentationTimingInfoEXT to id VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT +template <> +struct LvlTypeMap<VkPastPresentationTimingInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT> { + typedef VkPastPresentationTimingInfoEXT Type; +}; + +// Map type VkPastPresentationTimingEXT to id VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT +template <> +struct LvlTypeMap<VkPastPresentationTimingEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT> { + typedef VkPastPresentationTimingEXT Type; +}; + +// Map type VkPastPresentationTimingPropertiesEXT to id VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPastPresentationTimingPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT> { + typedef VkPastPresentationTimingPropertiesEXT Type; +}; + +// Map type VkPresentTimingInfoEXT to id VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT +template <> +struct LvlTypeMap<VkPresentTimingInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT> { + typedef VkPresentTimingInfoEXT Type; +}; + +// Map type VkPresentTimingsInfoEXT to id VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT +template <> +struct LvlTypeMap<VkPresentTimingsInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT> { + typedef VkPresentTimingsInfoEXT Type; +}; + +// Map type VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL> { typedef VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL Type; }; // Map type VkInitializePerformanceApiInfoINTEL to id VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL -template <> struct LvlTypeMap<VkInitializePerformanceApiInfoINTEL> { +template <> +struct LvlTypeMap<VkInitializePerformanceApiInfoINTEL> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL> { typedef VkInitializePerformanceApiInfoINTEL Type; }; // Map type VkQueryPoolPerformanceQueryCreateInfoINTEL to id VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL -template <> struct LvlTypeMap<VkQueryPoolPerformanceQueryCreateInfoINTEL> { +template <> +struct LvlTypeMap<VkQueryPoolPerformanceQueryCreateInfoINTEL> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL> { typedef VkQueryPoolPerformanceQueryCreateInfoINTEL Type; }; // Map type VkPerformanceMarkerInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL -template <> struct LvlTypeMap<VkPerformanceMarkerInfoINTEL> { +template <> +struct LvlTypeMap<VkPerformanceMarkerInfoINTEL> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL> { typedef VkPerformanceMarkerInfoINTEL Type; }; // Map type VkPerformanceStreamMarkerInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL -template <> struct LvlTypeMap<VkPerformanceStreamMarkerInfoINTEL> { +template <> +struct LvlTypeMap<VkPerformanceStreamMarkerInfoINTEL> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL> { typedef VkPerformanceStreamMarkerInfoINTEL Type; }; // Map type VkPerformanceOverrideInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL -template <> struct LvlTypeMap<VkPerformanceOverrideInfoINTEL> { +template <> +struct LvlTypeMap<VkPerformanceOverrideInfoINTEL> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL> { typedef VkPerformanceOverrideInfoINTEL Type; }; // Map type VkPerformanceConfigurationAcquireInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL -template <> struct LvlTypeMap<VkPerformanceConfigurationAcquireInfoINTEL> { +template <> +struct LvlTypeMap<VkPerformanceConfigurationAcquireInfoINTEL> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL> { typedef VkPerformanceConfigurationAcquireInfoINTEL Type; }; // Map type VkPhysicalDevicePCIBusInfoPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDevicePCIBusInfoPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDevicePCIBusInfoPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT> { typedef VkPhysicalDevicePCIBusInfoPropertiesEXT Type; }; // Map type VkDisplayNativeHdrSurfaceCapabilitiesAMD to id VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD -template <> struct LvlTypeMap<VkDisplayNativeHdrSurfaceCapabilitiesAMD> { +template <> +struct LvlTypeMap<VkDisplayNativeHdrSurfaceCapabilitiesAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD> { typedef VkDisplayNativeHdrSurfaceCapabilitiesAMD Type; }; // Map type VkSwapchainDisplayNativeHdrCreateInfoAMD to id VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD -template <> struct LvlTypeMap<VkSwapchainDisplayNativeHdrCreateInfoAMD> { +template <> +struct LvlTypeMap<VkSwapchainDisplayNativeHdrCreateInfoAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD> { typedef VkSwapchainDisplayNativeHdrCreateInfoAMD Type; }; #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkImagePipeSurfaceCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkImagePipeSurfaceCreateInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkImagePipeSurfaceCreateInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA> { typedef VkImagePipeSurfaceCreateInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkMetalSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkMetalSurfaceCreateInfoEXT> { +template <> +struct LvlTypeMap<VkMetalSurfaceCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT> { typedef VkMetalSurfaceCreateInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT // Map type VkPhysicalDeviceFragmentDensityMapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT> { typedef VkPhysicalDeviceFragmentDensityMapFeaturesEXT Type; }; -// Map type VkPhysicalDeviceFragmentDensityMapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapPropertiesEXT> { +// Map type VkPhysicalDeviceFragmentDensityMapPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT> { typedef VkPhysicalDeviceFragmentDensityMapPropertiesEXT Type; }; // Map type VkRenderPassFragmentDensityMapCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkRenderPassFragmentDensityMapCreateInfoEXT> { +template <> +struct LvlTypeMap<VkRenderPassFragmentDensityMapCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT> { typedef VkRenderPassFragmentDensityMapCreateInfoEXT Type; }; -// Map type VkRenderingFragmentDensityMapAttachmentInfoEXT to id VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT -template <> struct LvlTypeMap<VkRenderingFragmentDensityMapAttachmentInfoEXT> { +// Map type VkRenderingFragmentDensityMapAttachmentInfoEXT to id +// VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT +template <> +struct LvlTypeMap<VkRenderingFragmentDensityMapAttachmentInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT> { typedef VkRenderingFragmentDensityMapAttachmentInfoEXT Type; }; // Map type VkPhysicalDeviceShaderCoreProperties2AMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD -template <> struct LvlTypeMap<VkPhysicalDeviceShaderCoreProperties2AMD> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderCoreProperties2AMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD> { typedef VkPhysicalDeviceShaderCoreProperties2AMD Type; }; // Map type VkPhysicalDeviceCoherentMemoryFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD -template <> struct LvlTypeMap<VkPhysicalDeviceCoherentMemoryFeaturesAMD> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCoherentMemoryFeaturesAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD> { typedef VkPhysicalDeviceCoherentMemoryFeaturesAMD Type; }; -// Map type VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT> { +// Map type VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT> { typedef VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT Type; }; // Map type VkPhysicalDeviceMemoryBudgetPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMemoryBudgetPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMemoryBudgetPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT> { typedef VkPhysicalDeviceMemoryBudgetPropertiesEXT Type; }; // Map type VkPhysicalDeviceMemoryPriorityFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMemoryPriorityFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMemoryPriorityFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT> { typedef VkPhysicalDeviceMemoryPriorityFeaturesEXT Type; }; // Map type VkMemoryPriorityAllocateInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT -template <> struct LvlTypeMap<VkMemoryPriorityAllocateInfoEXT> { +template <> +struct LvlTypeMap<VkMemoryPriorityAllocateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT> { typedef VkMemoryPriorityAllocateInfoEXT Type; }; -// Map type VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> { +// Map type VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV> { typedef VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV Type; }; -// Map type VkPhysicalDeviceBufferDeviceAddressFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT> { +// Map type VkPhysicalDeviceBufferDeviceAddressFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT> { typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT Type; }; // Map type VkBufferDeviceAddressCreateInfoEXT to id VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkBufferDeviceAddressCreateInfoEXT> { +template <> +struct LvlTypeMap<VkBufferDeviceAddressCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT> { typedef VkBufferDeviceAddressCreateInfoEXT Type; }; // Map type VkValidationFeaturesEXT to id VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT -template <> struct LvlTypeMap<VkValidationFeaturesEXT> { +template <> +struct LvlTypeMap<VkValidationFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT> { typedef VkValidationFeaturesEXT Type; }; // Map type VkCooperativeMatrixPropertiesNV to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV -template <> struct LvlTypeMap<VkCooperativeMatrixPropertiesNV> { +template <> +struct LvlTypeMap<VkCooperativeMatrixPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV> { typedef VkCooperativeMatrixPropertiesNV Type; }; // Map type VkPhysicalDeviceCooperativeMatrixFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV> { typedef VkPhysicalDeviceCooperativeMatrixFeaturesNV Type; }; // Map type VkPhysicalDeviceCooperativeMatrixPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixPropertiesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV> { typedef VkPhysicalDeviceCooperativeMatrixPropertiesNV Type; }; -// Map type VkPhysicalDeviceCoverageReductionModeFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCoverageReductionModeFeaturesNV> { +// Map type VkPhysicalDeviceCoverageReductionModeFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceCoverageReductionModeFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV> { typedef VkPhysicalDeviceCoverageReductionModeFeaturesNV Type; }; // Map type VkPipelineCoverageReductionStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineCoverageReductionStateCreateInfoNV> { +template <> +struct LvlTypeMap<VkPipelineCoverageReductionStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV> { typedef VkPipelineCoverageReductionStateCreateInfoNV Type; }; // Map type VkFramebufferMixedSamplesCombinationNV to id VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV -template <> struct LvlTypeMap<VkFramebufferMixedSamplesCombinationNV> { +template <> +struct LvlTypeMap<VkFramebufferMixedSamplesCombinationNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV> { typedef VkFramebufferMixedSamplesCombinationNV Type; }; -// Map type VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT> { +// Map type VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT> { typedef VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT Type; }; // Map type VkPhysicalDeviceYcbcrImageArraysFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT> { typedef VkPhysicalDeviceYcbcrImageArraysFeaturesEXT Type; }; // Map type VkPhysicalDeviceProvokingVertexFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceProvokingVertexFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceProvokingVertexFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT> { typedef VkPhysicalDeviceProvokingVertexFeaturesEXT Type; }; // Map type VkPhysicalDeviceProvokingVertexPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceProvokingVertexPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceProvokingVertexPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT> { typedef VkPhysicalDeviceProvokingVertexPropertiesEXT Type; }; -// Map type VkPipelineRasterizationProvokingVertexStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT> { +// Map type VkPipelineRasterizationProvokingVertexStateCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT> { typedef VkPipelineRasterizationProvokingVertexStateCreateInfoEXT Type; }; #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkSurfaceFullScreenExclusiveInfoEXT to id VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT -template <> struct LvlTypeMap<VkSurfaceFullScreenExclusiveInfoEXT> { +template <> +struct LvlTypeMap<VkSurfaceFullScreenExclusiveInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT> { typedef VkSurfaceFullScreenExclusiveInfoEXT Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkSurfaceCapabilitiesFullScreenExclusiveEXT to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT -template <> struct LvlTypeMap<VkSurfaceCapabilitiesFullScreenExclusiveEXT> { +template <> +struct LvlTypeMap<VkSurfaceCapabilitiesFullScreenExclusiveEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT> { typedef VkSurfaceCapabilitiesFullScreenExclusiveEXT Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR // Map type VkSurfaceFullScreenExclusiveWin32InfoEXT to id VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT -template <> struct LvlTypeMap<VkSurfaceFullScreenExclusiveWin32InfoEXT> { +template <> +struct LvlTypeMap<VkSurfaceFullScreenExclusiveWin32InfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT> { typedef VkSurfaceFullScreenExclusiveWin32InfoEXT Type; }; -#endif // VK_USE_PLATFORM_WIN32_KHR +#endif // VK_USE_PLATFORM_WIN32_KHR // Map type VkHeadlessSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkHeadlessSurfaceCreateInfoEXT> { +template <> +struct LvlTypeMap<VkHeadlessSurfaceCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT> { typedef VkHeadlessSurfaceCreateInfoEXT Type; }; // Map type VkPhysicalDeviceShaderAtomicFloatFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT> { typedef VkPhysicalDeviceShaderAtomicFloatFeaturesEXT Type; }; -// Map type VkPhysicalDeviceExtendedDynamicStateFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT> { +// Map type VkPhysicalDeviceExtendedDynamicStateFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT> { typedef VkPhysicalDeviceExtendedDynamicStateFeaturesEXT Type; }; // Map type VkPhysicalDeviceMapMemoryPlacedFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT> { typedef VkPhysicalDeviceMapMemoryPlacedFeaturesEXT Type; }; // Map type VkPhysicalDeviceMapMemoryPlacedPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT> { typedef VkPhysicalDeviceMapMemoryPlacedPropertiesEXT Type; }; // Map type VkMemoryMapPlacedInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT -template <> struct LvlTypeMap<VkMemoryMapPlacedInfoEXT> { +template <> +struct LvlTypeMap<VkMemoryMapPlacedInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT> { typedef VkMemoryMapPlacedInfoEXT Type; }; // Map type VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT> { typedef VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT Type; }; -// Map type VkSurfacePresentModeEXT to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT -template <> struct LvlTypeMap<VkSurfacePresentModeEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT> { - typedef VkSurfacePresentModeEXT Type; -}; - -// Map type VkSurfacePresentScalingCapabilitiesEXT to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT -template <> struct LvlTypeMap<VkSurfacePresentScalingCapabilitiesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT> { - typedef VkSurfacePresentScalingCapabilitiesEXT Type; -}; - -// Map type VkSurfacePresentModeCompatibilityEXT to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT -template <> struct LvlTypeMap<VkSurfacePresentModeCompatibilityEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT> { - typedef VkSurfacePresentModeCompatibilityEXT Type; -}; - -// Map type VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT> { - typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT Type; -}; - -// Map type VkSwapchainPresentFenceInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT -template <> struct LvlTypeMap<VkSwapchainPresentFenceInfoEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT> { - typedef VkSwapchainPresentFenceInfoEXT Type; -}; - -// Map type VkSwapchainPresentModesCreateInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkSwapchainPresentModesCreateInfoEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT> { - typedef VkSwapchainPresentModesCreateInfoEXT Type; -}; - -// Map type VkSwapchainPresentModeInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT -template <> struct LvlTypeMap<VkSwapchainPresentModeInfoEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT> { - typedef VkSwapchainPresentModeInfoEXT Type; -}; - -// Map type VkSwapchainPresentScalingCreateInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkSwapchainPresentScalingCreateInfoEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT> { - typedef VkSwapchainPresentScalingCreateInfoEXT Type; -}; - -// Map type VkReleaseSwapchainImagesInfoEXT to id VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT -template <> struct LvlTypeMap<VkReleaseSwapchainImagesInfoEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT> { - typedef VkReleaseSwapchainImagesInfoEXT Type; -}; - -// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV> { +// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV> { typedef VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV Type; }; -// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV> { +// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV> { typedef VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV Type; }; // Map type VkGraphicsShaderGroupCreateInfoNV to id VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV -template <> struct LvlTypeMap<VkGraphicsShaderGroupCreateInfoNV> { +template <> +struct LvlTypeMap<VkGraphicsShaderGroupCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV> { typedef VkGraphicsShaderGroupCreateInfoNV Type; }; // Map type VkGraphicsPipelineShaderGroupsCreateInfoNV to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV -template <> struct LvlTypeMap<VkGraphicsPipelineShaderGroupsCreateInfoNV> { +template <> +struct LvlTypeMap<VkGraphicsPipelineShaderGroupsCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV> { typedef VkGraphicsPipelineShaderGroupsCreateInfoNV Type; }; // Map type VkIndirectCommandsLayoutTokenNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV -template <> struct LvlTypeMap<VkIndirectCommandsLayoutTokenNV> { +template <> +struct LvlTypeMap<VkIndirectCommandsLayoutTokenNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV> { typedef VkIndirectCommandsLayoutTokenNV Type; }; // Map type VkIndirectCommandsLayoutCreateInfoNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV -template <> struct LvlTypeMap<VkIndirectCommandsLayoutCreateInfoNV> { +template <> +struct LvlTypeMap<VkIndirectCommandsLayoutCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV> { typedef VkIndirectCommandsLayoutCreateInfoNV Type; }; // Map type VkGeneratedCommandsInfoNV to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV -template <> struct LvlTypeMap<VkGeneratedCommandsInfoNV> { +template <> +struct LvlTypeMap<VkGeneratedCommandsInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV> { typedef VkGeneratedCommandsInfoNV Type; }; // Map type VkGeneratedCommandsMemoryRequirementsInfoNV to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV -template <> struct LvlTypeMap<VkGeneratedCommandsMemoryRequirementsInfoNV> { +template <> +struct LvlTypeMap<VkGeneratedCommandsMemoryRequirementsInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV> { typedef VkGeneratedCommandsMemoryRequirementsInfoNV Type; }; -// Map type VkPhysicalDeviceInheritedViewportScissorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceInheritedViewportScissorFeaturesNV> { +// Map type VkPhysicalDeviceInheritedViewportScissorFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceInheritedViewportScissorFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV> { typedef VkPhysicalDeviceInheritedViewportScissorFeaturesNV Type; }; -// Map type VkCommandBufferInheritanceViewportScissorInfoNV to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV -template <> struct LvlTypeMap<VkCommandBufferInheritanceViewportScissorInfoNV> { +// Map type VkCommandBufferInheritanceViewportScissorInfoNV to id +// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV +template <> +struct LvlTypeMap<VkCommandBufferInheritanceViewportScissorInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV> { typedef VkCommandBufferInheritanceViewportScissorInfoNV Type; }; -// Map type VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT> { +// Map type VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT> { typedef VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT Type; }; // Map type VkRenderPassTransformBeginInfoQCOM to id VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM -template <> struct LvlTypeMap<VkRenderPassTransformBeginInfoQCOM> { +template <> +struct LvlTypeMap<VkRenderPassTransformBeginInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM> { typedef VkRenderPassTransformBeginInfoQCOM Type; }; -// Map type VkCommandBufferInheritanceRenderPassTransformInfoQCOM to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM -template <> struct LvlTypeMap<VkCommandBufferInheritanceRenderPassTransformInfoQCOM> { +// Map type VkCommandBufferInheritanceRenderPassTransformInfoQCOM to id +// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM +template <> +struct LvlTypeMap<VkCommandBufferInheritanceRenderPassTransformInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM> { typedef VkCommandBufferInheritanceRenderPassTransformInfoQCOM Type; }; // Map type VkPhysicalDeviceDepthBiasControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDepthBiasControlFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDepthBiasControlFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT> { typedef VkPhysicalDeviceDepthBiasControlFeaturesEXT Type; }; // Map type VkDepthBiasInfoEXT to id VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT -template <> struct LvlTypeMap<VkDepthBiasInfoEXT> { +template <> +struct LvlTypeMap<VkDepthBiasInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT> { typedef VkDepthBiasInfoEXT Type; }; // Map type VkDepthBiasRepresentationInfoEXT to id VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT -template <> struct LvlTypeMap<VkDepthBiasRepresentationInfoEXT> { +template <> +struct LvlTypeMap<VkDepthBiasRepresentationInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT> { typedef VkDepthBiasRepresentationInfoEXT Type; }; // Map type VkPhysicalDeviceDeviceMemoryReportFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT> { typedef VkPhysicalDeviceDeviceMemoryReportFeaturesEXT Type; }; // Map type VkDeviceMemoryReportCallbackDataEXT to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT -template <> struct LvlTypeMap<VkDeviceMemoryReportCallbackDataEXT> { +template <> +struct LvlTypeMap<VkDeviceMemoryReportCallbackDataEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT> { typedef VkDeviceMemoryReportCallbackDataEXT Type; }; // Map type VkDeviceDeviceMemoryReportCreateInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkDeviceDeviceMemoryReportCreateInfoEXT> { +template <> +struct LvlTypeMap<VkDeviceDeviceMemoryReportCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT> { typedef VkDeviceDeviceMemoryReportCreateInfoEXT Type; }; -// Map type VkPhysicalDeviceRobustness2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceRobustness2FeaturesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT> { - typedef VkPhysicalDeviceRobustness2FeaturesEXT Type; -}; - -// Map type VkPhysicalDeviceRobustness2PropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceRobustness2PropertiesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT> { - typedef VkPhysicalDeviceRobustness2PropertiesEXT Type; -}; - -// Map type VkSamplerCustomBorderColorCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkSamplerCustomBorderColorCreateInfoEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT> { - typedef VkSamplerCustomBorderColorCreateInfoEXT Type; -}; - -// Map type VkPhysicalDeviceCustomBorderColorPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceCustomBorderColorPropertiesEXT> { +// Map type VkPhysicalDeviceCustomBorderColorPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceCustomBorderColorPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT> { typedef VkPhysicalDeviceCustomBorderColorPropertiesEXT Type; }; // Map type VkPhysicalDeviceCustomBorderColorFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceCustomBorderColorFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCustomBorderColorFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT> { typedef VkPhysicalDeviceCustomBorderColorFeaturesEXT Type; }; +// Map type VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT> { + typedef VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT Type; +}; + // Map type VkPhysicalDevicePresentBarrierFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDevicePresentBarrierFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDevicePresentBarrierFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV> { typedef VkPhysicalDevicePresentBarrierFeaturesNV Type; }; // Map type VkSurfaceCapabilitiesPresentBarrierNV to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV -template <> struct LvlTypeMap<VkSurfaceCapabilitiesPresentBarrierNV> { +template <> +struct LvlTypeMap<VkSurfaceCapabilitiesPresentBarrierNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV> { typedef VkSurfaceCapabilitiesPresentBarrierNV Type; }; // Map type VkSwapchainPresentBarrierCreateInfoNV to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV -template <> struct LvlTypeMap<VkSwapchainPresentBarrierCreateInfoNV> { +template <> +struct LvlTypeMap<VkSwapchainPresentBarrierCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV> { typedef VkSwapchainPresentBarrierCreateInfoNV Type; }; // Map type VkPhysicalDeviceDiagnosticsConfigFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDiagnosticsConfigFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDiagnosticsConfigFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV> { typedef VkPhysicalDeviceDiagnosticsConfigFeaturesNV Type; }; // Map type VkDeviceDiagnosticsConfigCreateInfoNV to id VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV -template <> struct LvlTypeMap<VkDeviceDiagnosticsConfigCreateInfoNV> { +template <> +struct LvlTypeMap<VkDeviceDiagnosticsConfigCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV> { typedef VkDeviceDiagnosticsConfigCreateInfoNV Type; }; +// Map type VkPerfHintInfoQCOM to id VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM +template <> +struct LvlTypeMap<VkPerfHintInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM> { + typedef VkPerfHintInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceQueuePerfHintFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceQueuePerfHintFeaturesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM> { + typedef VkPhysicalDeviceQueuePerfHintFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceQueuePerfHintPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceQueuePerfHintPropertiesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM> { + typedef VkPhysicalDeviceQueuePerfHintPropertiesQCOM Type; +}; + +#ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkCudaModuleCreateInfoNV to id VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkCudaModuleCreateInfoNV> { +template <> +struct LvlTypeMap<VkCudaModuleCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV> { typedef VkCudaModuleCreateInfoNV Type; }; +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkCudaFunctionCreateInfoNV to id VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV -template <> struct LvlTypeMap<VkCudaFunctionCreateInfoNV> { +template <> +struct LvlTypeMap<VkCudaFunctionCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV> { typedef VkCudaFunctionCreateInfoNV Type; }; +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkCudaLaunchInfoNV to id VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV -template <> struct LvlTypeMap<VkCudaLaunchInfoNV> { +template <> +struct LvlTypeMap<VkCudaLaunchInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV> { typedef VkCudaLaunchInfoNV Type; }; +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDeviceCudaKernelLaunchFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCudaKernelLaunchFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCudaKernelLaunchFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV> { typedef VkPhysicalDeviceCudaKernelLaunchFeaturesNV Type; }; +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDeviceCudaKernelLaunchPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCudaKernelLaunchPropertiesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCudaKernelLaunchPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV> { typedef VkPhysicalDeviceCudaKernelLaunchPropertiesNV Type; }; +#endif // VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceTileShadingFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceTileShadingFeaturesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM> { + typedef VkPhysicalDeviceTileShadingFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceTileShadingPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceTileShadingPropertiesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM> { + typedef VkPhysicalDeviceTileShadingPropertiesQCOM Type; +}; + +// Map type VkRenderPassTileShadingCreateInfoQCOM to id VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM +template <> +struct LvlTypeMap<VkRenderPassTileShadingCreateInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM> { + typedef VkRenderPassTileShadingCreateInfoQCOM Type; +}; + +// Map type VkPerTileBeginInfoQCOM to id VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM +template <> +struct LvlTypeMap<VkPerTileBeginInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM> { + typedef VkPerTileBeginInfoQCOM Type; +}; + +// Map type VkPerTileEndInfoQCOM to id VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM +template <> +struct LvlTypeMap<VkPerTileEndInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM> { + typedef VkPerTileEndInfoQCOM Type; +}; + +// Map type VkDispatchTileInfoQCOM to id VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM +template <> +struct LvlTypeMap<VkDispatchTileInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM> { + typedef VkDispatchTileInfoQCOM Type; +}; + // Map type VkQueryLowLatencySupportNV to id VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV -template <> struct LvlTypeMap<VkQueryLowLatencySupportNV> { +template <> +struct LvlTypeMap<VkQueryLowLatencySupportNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV> { typedef VkQueryLowLatencySupportNV Type; }; #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalObjectCreateInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalObjectCreateInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalObjectCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT> { typedef VkExportMetalObjectCreateInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalObjectsInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalObjectsInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalObjectsInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT> { typedef VkExportMetalObjectsInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalDeviceInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalDeviceInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalDeviceInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT> { typedef VkExportMetalDeviceInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalCommandQueueInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalCommandQueueInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalCommandQueueInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT> { typedef VkExportMetalCommandQueueInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalBufferInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalBufferInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalBufferInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT> { typedef VkExportMetalBufferInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkImportMetalBufferInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT -template <> struct LvlTypeMap<VkImportMetalBufferInfoEXT> { +template <> +struct LvlTypeMap<VkImportMetalBufferInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT> { typedef VkImportMetalBufferInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalTextureInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalTextureInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalTextureInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT> { typedef VkExportMetalTextureInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkImportMetalTextureInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT -template <> struct LvlTypeMap<VkImportMetalTextureInfoEXT> { +template <> +struct LvlTypeMap<VkImportMetalTextureInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT> { typedef VkImportMetalTextureInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalIOSurfaceInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalIOSurfaceInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalIOSurfaceInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT> { typedef VkExportMetalIOSurfaceInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkImportMetalIOSurfaceInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT -template <> struct LvlTypeMap<VkImportMetalIOSurfaceInfoEXT> { +template <> +struct LvlTypeMap<VkImportMetalIOSurfaceInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT> { typedef VkImportMetalIOSurfaceInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkExportMetalSharedEventInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT -template <> struct LvlTypeMap<VkExportMetalSharedEventInfoEXT> { +template <> +struct LvlTypeMap<VkExportMetalSharedEventInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT> { typedef VkExportMetalSharedEventInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT // Map type VkImportMetalSharedEventInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT -template <> struct LvlTypeMap<VkImportMetalSharedEventInfoEXT> { +template <> +struct LvlTypeMap<VkImportMetalSharedEventInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT> { typedef VkImportMetalSharedEventInfoEXT Type; }; -#endif // VK_USE_PLATFORM_METAL_EXT +#endif // VK_USE_PLATFORM_METAL_EXT // Map type VkPhysicalDeviceDescriptorBufferPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT> { typedef VkPhysicalDeviceDescriptorBufferPropertiesEXT Type; }; -// Map type VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT> { - typedef VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT Type; -}; - // Map type VkPhysicalDeviceDescriptorBufferFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT> { typedef VkPhysicalDeviceDescriptorBufferFeaturesEXT Type; }; // Map type VkDescriptorAddressInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT -template <> struct LvlTypeMap<VkDescriptorAddressInfoEXT> { +template <> +struct LvlTypeMap<VkDescriptorAddressInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT> { typedef VkDescriptorAddressInfoEXT Type; }; // Map type VkDescriptorBufferBindingInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT -template <> struct LvlTypeMap<VkDescriptorBufferBindingInfoEXT> { +template <> +struct LvlTypeMap<VkDescriptorBufferBindingInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT> { typedef VkDescriptorBufferBindingInfoEXT Type; }; -// Map type VkDescriptorBufferBindingPushDescriptorBufferHandleEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT -template <> struct LvlTypeMap<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT> { +// Map type VkDescriptorBufferBindingPushDescriptorBufferHandleEXT to id +// VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT +template <> +struct LvlTypeMap<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT> { typedef VkDescriptorBufferBindingPushDescriptorBufferHandleEXT Type; }; // Map type VkDescriptorGetInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT -template <> struct LvlTypeMap<VkDescriptorGetInfoEXT> { +template <> +struct LvlTypeMap<VkDescriptorGetInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT> { typedef VkDescriptorGetInfoEXT Type; }; // Map type VkBufferCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT -template <> struct LvlTypeMap<VkBufferCaptureDescriptorDataInfoEXT> { +template <> +struct LvlTypeMap<VkBufferCaptureDescriptorDataInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { typedef VkBufferCaptureDescriptorDataInfoEXT Type; }; // Map type VkImageCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT -template <> struct LvlTypeMap<VkImageCaptureDescriptorDataInfoEXT> { +template <> +struct LvlTypeMap<VkImageCaptureDescriptorDataInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { typedef VkImageCaptureDescriptorDataInfoEXT Type; }; // Map type VkImageViewCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT -template <> struct LvlTypeMap<VkImageViewCaptureDescriptorDataInfoEXT> { +template <> +struct LvlTypeMap<VkImageViewCaptureDescriptorDataInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { typedef VkImageViewCaptureDescriptorDataInfoEXT Type; }; // Map type VkSamplerCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT -template <> struct LvlTypeMap<VkSamplerCaptureDescriptorDataInfoEXT> { +template <> +struct LvlTypeMap<VkSamplerCaptureDescriptorDataInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { typedef VkSamplerCaptureDescriptorDataInfoEXT Type; }; // Map type VkOpaqueCaptureDescriptorDataCreateInfoEXT to id VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkOpaqueCaptureDescriptorDataCreateInfoEXT> { +template <> +struct LvlTypeMap<VkOpaqueCaptureDescriptorDataCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT> { typedef VkOpaqueCaptureDescriptorDataCreateInfoEXT Type; }; -// Map type VkAccelerationStructureCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT -template <> struct LvlTypeMap<VkAccelerationStructureCaptureDescriptorDataInfoEXT> { +// Map type VkAccelerationStructureCaptureDescriptorDataInfoEXT to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT +template <> +struct LvlTypeMap<VkAccelerationStructureCaptureDescriptorDataInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> { typedef VkAccelerationStructureCaptureDescriptorDataInfoEXT Type; }; -// Map type VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT> { +// Map type VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT> { + typedef VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT> { typedef VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT Type; }; -// Map type VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT> { +// Map type VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT> { typedef VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT Type; }; // Map type VkGraphicsPipelineLibraryCreateInfoEXT to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkGraphicsPipelineLibraryCreateInfoEXT> { +template <> +struct LvlTypeMap<VkGraphicsPipelineLibraryCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT> { typedef VkGraphicsPipelineLibraryCreateInfoEXT Type; }; -// Map type VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD -template <> struct LvlTypeMap<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD> { +// Map type VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD> { typedef VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD Type; }; -// Map type VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV> { +// Map type VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV> { typedef VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV Type; }; -// Map type VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV> { +// Map type VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV> { typedef VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV Type; }; -// Map type VkPipelineFragmentShadingRateEnumStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV -template <> struct LvlTypeMap<VkPipelineFragmentShadingRateEnumStateCreateInfoNV> { +// Map type VkPipelineFragmentShadingRateEnumStateCreateInfoNV to id +// VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkPipelineFragmentShadingRateEnumStateCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV> { typedef VkPipelineFragmentShadingRateEnumStateCreateInfoNV Type; }; -// Map type VkAccelerationStructureGeometryMotionTrianglesDataNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV -template <> struct LvlTypeMap<VkAccelerationStructureGeometryMotionTrianglesDataNV> { +// Map type VkAccelerationStructureGeometryMotionTrianglesDataNV to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV +template <> +struct LvlTypeMap<VkAccelerationStructureGeometryMotionTrianglesDataNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV> { typedef VkAccelerationStructureGeometryMotionTrianglesDataNV Type; }; // Map type VkAccelerationStructureMotionInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV -template <> struct LvlTypeMap<VkAccelerationStructureMotionInfoNV> { +template <> +struct LvlTypeMap<VkAccelerationStructureMotionInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV> { typedef VkAccelerationStructureMotionInfoNV Type; }; -// Map type VkPhysicalDeviceRayTracingMotionBlurFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV> { +// Map type VkPhysicalDeviceRayTracingMotionBlurFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV> { typedef VkPhysicalDeviceRayTracingMotionBlurFeaturesNV Type; }; -// Map type VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT> { +// Map type VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT> { typedef VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT Type; }; -// Map type VkPhysicalDeviceFragmentDensityMap2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT> { +// Map type VkPhysicalDeviceFragmentDensityMap2FeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT> { typedef VkPhysicalDeviceFragmentDensityMap2FeaturesEXT Type; }; -// Map type VkPhysicalDeviceFragmentDensityMap2PropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT> { +// Map type VkPhysicalDeviceFragmentDensityMap2PropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT> { typedef VkPhysicalDeviceFragmentDensityMap2PropertiesEXT Type; }; // Map type VkCopyCommandTransformInfoQCOM to id VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM -template <> struct LvlTypeMap<VkCopyCommandTransformInfoQCOM> { +template <> +struct LvlTypeMap<VkCopyCommandTransformInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM> { typedef VkCopyCommandTransformInfoQCOM Type; }; -// Map type VkPhysicalDeviceImageCompressionControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceImageCompressionControlFeaturesEXT> { +// Map type VkPhysicalDeviceImageCompressionControlFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceImageCompressionControlFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT> { typedef VkPhysicalDeviceImageCompressionControlFeaturesEXT Type; }; // Map type VkImageCompressionControlEXT to id VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT -template <> struct LvlTypeMap<VkImageCompressionControlEXT> { +template <> +struct LvlTypeMap<VkImageCompressionControlEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT> { typedef VkImageCompressionControlEXT Type; }; // Map type VkImageCompressionPropertiesEXT to id VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT -template <> struct LvlTypeMap<VkImageCompressionPropertiesEXT> { +template <> +struct LvlTypeMap<VkImageCompressionPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT> { typedef VkImageCompressionPropertiesEXT Type; }; -// Map type VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT> { +// Map type VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT> { typedef VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT Type; }; // Map type VkPhysicalDevice4444FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDevice4444FormatsFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDevice4444FormatsFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT> { typedef VkPhysicalDevice4444FormatsFeaturesEXT Type; }; // Map type VkPhysicalDeviceFaultFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceFaultFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceFaultFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT> { typedef VkPhysicalDeviceFaultFeaturesEXT Type; }; // Map type VkDeviceFaultCountsEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT -template <> struct LvlTypeMap<VkDeviceFaultCountsEXT> { +template <> +struct LvlTypeMap<VkDeviceFaultCountsEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT> { typedef VkDeviceFaultCountsEXT Type; }; // Map type VkDeviceFaultInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT -template <> struct LvlTypeMap<VkDeviceFaultInfoEXT> { +template <> +struct LvlTypeMap<VkDeviceFaultInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT> { typedef VkDeviceFaultInfoEXT Type; }; -// Map type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT> { +// Map type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT> { typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT Type; }; // Map type VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT> { typedef VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT Type; }; #ifdef VK_USE_PLATFORM_DIRECTFB_EXT // Map type VkDirectFBSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkDirectFBSurfaceCreateInfoEXT> { +template <> +struct LvlTypeMap<VkDirectFBSurfaceCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT> { typedef VkDirectFBSurfaceCreateInfoEXT Type; }; -#endif // VK_USE_PLATFORM_DIRECTFB_EXT -// Map type VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT> { +#endif // VK_USE_PLATFORM_DIRECTFB_EXT +// Map type VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT> { typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT Type; }; // Map type VkMutableDescriptorTypeCreateInfoEXT to id VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkMutableDescriptorTypeCreateInfoEXT> { +template <> +struct LvlTypeMap<VkMutableDescriptorTypeCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT> { typedef VkMutableDescriptorTypeCreateInfoEXT Type; }; -// Map type VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT> { +// Map type VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT> { typedef VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT Type; }; // Map type VkVertexInputBindingDescription2EXT to id VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT -template <> struct LvlTypeMap<VkVertexInputBindingDescription2EXT> { +template <> +struct LvlTypeMap<VkVertexInputBindingDescription2EXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT> { typedef VkVertexInputBindingDescription2EXT Type; }; // Map type VkVertexInputAttributeDescription2EXT to id VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT -template <> struct LvlTypeMap<VkVertexInputAttributeDescription2EXT> { +template <> +struct LvlTypeMap<VkVertexInputAttributeDescription2EXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT> { typedef VkVertexInputAttributeDescription2EXT Type; }; // Map type VkPhysicalDeviceDrmPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDrmPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDrmPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT> { typedef VkPhysicalDeviceDrmPropertiesEXT Type; }; -// Map type VkPhysicalDeviceAddressBindingReportFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceAddressBindingReportFeaturesEXT> { +// Map type VkPhysicalDeviceAddressBindingReportFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceAddressBindingReportFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT> { typedef VkPhysicalDeviceAddressBindingReportFeaturesEXT Type; }; // Map type VkDeviceAddressBindingCallbackDataEXT to id VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT -template <> struct LvlTypeMap<VkDeviceAddressBindingCallbackDataEXT> { +template <> +struct LvlTypeMap<VkDeviceAddressBindingCallbackDataEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT> { typedef VkDeviceAddressBindingCallbackDataEXT Type; }; // Map type VkPhysicalDeviceDepthClipControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDepthClipControlFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDepthClipControlFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT> { typedef VkPhysicalDeviceDepthClipControlFeaturesEXT Type; }; -// Map type VkPipelineViewportDepthClipControlCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineViewportDepthClipControlCreateInfoEXT> { +// Map type VkPipelineViewportDepthClipControlCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineViewportDepthClipControlCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT> { typedef VkPipelineViewportDepthClipControlCreateInfoEXT Type; }; -// Map type VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT> { +// Map type VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT> { typedef VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT Type; }; -// Map type VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT> { - typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT Type; -}; - #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkImportMemoryZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkImportMemoryZirconHandleInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkImportMemoryZirconHandleInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA> { typedef VkImportMemoryZirconHandleInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkMemoryZirconHandlePropertiesFUCHSIA to id VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA -template <> struct LvlTypeMap<VkMemoryZirconHandlePropertiesFUCHSIA> { +template <> +struct LvlTypeMap<VkMemoryZirconHandlePropertiesFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA> { typedef VkMemoryZirconHandlePropertiesFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkMemoryGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkMemoryGetZirconHandleInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkMemoryGetZirconHandleInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA> { typedef VkMemoryGetZirconHandleInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkImportSemaphoreZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkImportSemaphoreZirconHandleInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkImportSemaphoreZirconHandleInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA> { typedef VkImportSemaphoreZirconHandleInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkSemaphoreGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkSemaphoreGetZirconHandleInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkSemaphoreGetZirconHandleInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA> { typedef VkSemaphoreGetZirconHandleInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkBufferCollectionCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkBufferCollectionCreateInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkBufferCollectionCreateInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA> { typedef VkBufferCollectionCreateInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkImportMemoryBufferCollectionFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA -template <> struct LvlTypeMap<VkImportMemoryBufferCollectionFUCHSIA> { +template <> +struct LvlTypeMap<VkImportMemoryBufferCollectionFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA> { typedef VkImportMemoryBufferCollectionFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkBufferCollectionImageCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkBufferCollectionImageCreateInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkBufferCollectionImageCreateInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA> { typedef VkBufferCollectionImageCreateInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkBufferCollectionConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA -template <> struct LvlTypeMap<VkBufferCollectionConstraintsInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkBufferCollectionConstraintsInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA> { typedef VkBufferCollectionConstraintsInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkBufferConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA -template <> struct LvlTypeMap<VkBufferConstraintsInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkBufferConstraintsInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA> { typedef VkBufferConstraintsInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkBufferCollectionBufferCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA -template <> struct LvlTypeMap<VkBufferCollectionBufferCreateInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkBufferCollectionBufferCreateInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA> { typedef VkBufferCollectionBufferCreateInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkSysmemColorSpaceFUCHSIA to id VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA -template <> struct LvlTypeMap<VkSysmemColorSpaceFUCHSIA> { +template <> +struct LvlTypeMap<VkSysmemColorSpaceFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA> { typedef VkSysmemColorSpaceFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkBufferCollectionPropertiesFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA -template <> struct LvlTypeMap<VkBufferCollectionPropertiesFUCHSIA> { +template <> +struct LvlTypeMap<VkBufferCollectionPropertiesFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA> { typedef VkBufferCollectionPropertiesFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkImageFormatConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA -template <> struct LvlTypeMap<VkImageFormatConstraintsInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkImageFormatConstraintsInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA> { typedef VkImageFormatConstraintsInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA // Map type VkImageConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA -template <> struct LvlTypeMap<VkImageConstraintsInfoFUCHSIA> { +template <> +struct LvlTypeMap<VkImageConstraintsInfoFUCHSIA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA> { typedef VkImageConstraintsInfoFUCHSIA Type; }; -#endif // VK_USE_PLATFORM_FUCHSIA +#endif // VK_USE_PLATFORM_FUCHSIA // Map type VkSubpassShadingPipelineCreateInfoHUAWEI to id VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI -template <> struct LvlTypeMap<VkSubpassShadingPipelineCreateInfoHUAWEI> { +template <> +struct LvlTypeMap<VkSubpassShadingPipelineCreateInfoHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI> { typedef VkSubpassShadingPipelineCreateInfoHUAWEI Type; }; // Map type VkPhysicalDeviceSubpassShadingFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI -template <> struct LvlTypeMap<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI> { +template <> +struct LvlTypeMap<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI> { typedef VkPhysicalDeviceSubpassShadingFeaturesHUAWEI Type; }; // Map type VkPhysicalDeviceSubpassShadingPropertiesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI -template <> struct LvlTypeMap<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI> { +template <> +struct LvlTypeMap<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI> { typedef VkPhysicalDeviceSubpassShadingPropertiesHUAWEI Type; }; // Map type VkPhysicalDeviceInvocationMaskFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI -template <> struct LvlTypeMap<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI> { +template <> +struct LvlTypeMap<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI> { typedef VkPhysicalDeviceInvocationMaskFeaturesHUAWEI Type; }; // Map type VkMemoryGetRemoteAddressInfoNV to id VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV -template <> struct LvlTypeMap<VkMemoryGetRemoteAddressInfoNV> { +template <> +struct LvlTypeMap<VkMemoryGetRemoteAddressInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV> { typedef VkMemoryGetRemoteAddressInfoNV Type; }; // Map type VkPhysicalDeviceExternalMemoryRDMAFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV> { typedef VkPhysicalDeviceExternalMemoryRDMAFeaturesNV Type; }; // Map type VkPipelinePropertiesIdentifierEXT to id VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT -template <> struct LvlTypeMap<VkPipelinePropertiesIdentifierEXT> { +template <> +struct LvlTypeMap<VkPipelinePropertiesIdentifierEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT> { typedef VkPipelinePropertiesIdentifierEXT Type; }; // Map type VkPhysicalDevicePipelinePropertiesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDevicePipelinePropertiesFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDevicePipelinePropertiesFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT> { typedef VkPhysicalDevicePipelinePropertiesFeaturesEXT Type; }; // Map type VkPhysicalDeviceFrameBoundaryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceFrameBoundaryFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceFrameBoundaryFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT> { typedef VkPhysicalDeviceFrameBoundaryFeaturesEXT Type; }; // Map type VkFrameBoundaryEXT to id VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT -template <> struct LvlTypeMap<VkFrameBoundaryEXT> { +template <> +struct LvlTypeMap<VkFrameBoundaryEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT> { typedef VkFrameBoundaryEXT Type; }; -// Map type VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT> { +// Map type VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT> { typedef VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT Type; }; // Map type VkSubpassResolvePerformanceQueryEXT to id VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT -template <> struct LvlTypeMap<VkSubpassResolvePerformanceQueryEXT> { +template <> +struct LvlTypeMap<VkSubpassResolvePerformanceQueryEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT> { typedef VkSubpassResolvePerformanceQueryEXT Type; }; // Map type VkMultisampledRenderToSingleSampledInfoEXT to id VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT -template <> struct LvlTypeMap<VkMultisampledRenderToSingleSampledInfoEXT> { +template <> +struct LvlTypeMap<VkMultisampledRenderToSingleSampledInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT> { typedef VkMultisampledRenderToSingleSampledInfoEXT Type; }; -// Map type VkPhysicalDeviceExtendedDynamicState2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT> { +// Map type VkPhysicalDeviceExtendedDynamicState2FeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT> { typedef VkPhysicalDeviceExtendedDynamicState2FeaturesEXT Type; }; #ifdef VK_USE_PLATFORM_SCREEN_QNX // Map type VkScreenSurfaceCreateInfoQNX to id VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX -template <> struct LvlTypeMap<VkScreenSurfaceCreateInfoQNX> { +template <> +struct LvlTypeMap<VkScreenSurfaceCreateInfoQNX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX> { typedef VkScreenSurfaceCreateInfoQNX Type; }; -#endif // VK_USE_PLATFORM_SCREEN_QNX +#endif // VK_USE_PLATFORM_SCREEN_QNX // Map type VkPhysicalDeviceColorWriteEnableFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceColorWriteEnableFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceColorWriteEnableFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT> { typedef VkPhysicalDeviceColorWriteEnableFeaturesEXT Type; }; // Map type VkPipelineColorWriteCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineColorWriteCreateInfoEXT> { +template <> +struct LvlTypeMap<VkPipelineColorWriteCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT> { typedef VkPipelineColorWriteCreateInfoEXT Type; }; -// Map type VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT> { +// Map type VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT> { typedef VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT Type; }; +// Map type VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE +template <> +struct LvlTypeMap<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE> { + typedef VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE Type; +}; + +// Map type VkVideoEncodeRgbConversionCapabilitiesVALVE to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE +template <> +struct LvlTypeMap<VkVideoEncodeRgbConversionCapabilitiesVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE> { + typedef VkVideoEncodeRgbConversionCapabilitiesVALVE Type; +}; + +// Map type VkVideoEncodeProfileRgbConversionInfoVALVE to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE +template <> +struct LvlTypeMap<VkVideoEncodeProfileRgbConversionInfoVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE> { + typedef VkVideoEncodeProfileRgbConversionInfoVALVE Type; +}; + +// Map type VkVideoEncodeSessionRgbConversionCreateInfoVALVE to id +// VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE +template <> +struct LvlTypeMap<VkVideoEncodeSessionRgbConversionCreateInfoVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE> { + typedef VkVideoEncodeSessionRgbConversionCreateInfoVALVE Type; +}; + // Map type VkPhysicalDeviceImageViewMinLodFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceImageViewMinLodFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImageViewMinLodFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT> { typedef VkPhysicalDeviceImageViewMinLodFeaturesEXT Type; }; // Map type VkImageViewMinLodCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkImageViewMinLodCreateInfoEXT> { +template <> +struct LvlTypeMap<VkImageViewMinLodCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT> { typedef VkImageViewMinLodCreateInfoEXT Type; }; // Map type VkPhysicalDeviceMultiDrawFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMultiDrawFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMultiDrawFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT> { typedef VkPhysicalDeviceMultiDrawFeaturesEXT Type; }; // Map type VkPhysicalDeviceMultiDrawPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMultiDrawPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMultiDrawPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT> { typedef VkPhysicalDeviceMultiDrawPropertiesEXT Type; }; // Map type VkPhysicalDeviceImage2DViewOf3DFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT> { typedef VkPhysicalDeviceImage2DViewOf3DFeaturesEXT Type; }; // Map type VkPhysicalDeviceShaderTileImageFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderTileImageFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderTileImageFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT> { typedef VkPhysicalDeviceShaderTileImageFeaturesEXT Type; }; // Map type VkPhysicalDeviceShaderTileImagePropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderTileImagePropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderTileImagePropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT> { typedef VkPhysicalDeviceShaderTileImagePropertiesEXT Type; }; // Map type VkMicromapBuildInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT -template <> struct LvlTypeMap<VkMicromapBuildInfoEXT> { +template <> +struct LvlTypeMap<VkMicromapBuildInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT> { typedef VkMicromapBuildInfoEXT Type; }; // Map type VkMicromapCreateInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkMicromapCreateInfoEXT> { +template <> +struct LvlTypeMap<VkMicromapCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT> { typedef VkMicromapCreateInfoEXT Type; }; // Map type VkPhysicalDeviceOpacityMicromapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceOpacityMicromapFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceOpacityMicromapFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT> { typedef VkPhysicalDeviceOpacityMicromapFeaturesEXT Type; }; // Map type VkPhysicalDeviceOpacityMicromapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceOpacityMicromapPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceOpacityMicromapPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT> { typedef VkPhysicalDeviceOpacityMicromapPropertiesEXT Type; }; // Map type VkMicromapVersionInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT -template <> struct LvlTypeMap<VkMicromapVersionInfoEXT> { +template <> +struct LvlTypeMap<VkMicromapVersionInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT> { typedef VkMicromapVersionInfoEXT Type; }; // Map type VkCopyMicromapToMemoryInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT -template <> struct LvlTypeMap<VkCopyMicromapToMemoryInfoEXT> { +template <> +struct LvlTypeMap<VkCopyMicromapToMemoryInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT> { typedef VkCopyMicromapToMemoryInfoEXT Type; }; // Map type VkCopyMemoryToMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT -template <> struct LvlTypeMap<VkCopyMemoryToMicromapInfoEXT> { +template <> +struct LvlTypeMap<VkCopyMemoryToMicromapInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT> { typedef VkCopyMemoryToMicromapInfoEXT Type; }; // Map type VkCopyMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT -template <> struct LvlTypeMap<VkCopyMicromapInfoEXT> { +template <> +struct LvlTypeMap<VkCopyMicromapInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT> { typedef VkCopyMicromapInfoEXT Type; }; // Map type VkMicromapBuildSizesInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT -template <> struct LvlTypeMap<VkMicromapBuildSizesInfoEXT> { +template <> +struct LvlTypeMap<VkMicromapBuildSizesInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT> { typedef VkMicromapBuildSizesInfoEXT Type; }; -// Map type VkAccelerationStructureTrianglesOpacityMicromapEXT to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT -template <> struct LvlTypeMap<VkAccelerationStructureTrianglesOpacityMicromapEXT> { +// Map type VkAccelerationStructureTrianglesOpacityMicromapEXT to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT +template <> +struct LvlTypeMap<VkAccelerationStructureTrianglesOpacityMicromapEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT> { typedef VkAccelerationStructureTrianglesOpacityMicromapEXT Type; }; #ifdef VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDeviceDisplacementMicromapFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDisplacementMicromapFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDisplacementMicromapFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV> { typedef VkPhysicalDeviceDisplacementMicromapFeaturesNV Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS -// Map type VkPhysicalDeviceDisplacementMicromapPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDisplacementMicromapPropertiesNV> { +// Map type VkPhysicalDeviceDisplacementMicromapPropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceDisplacementMicromapPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV> { typedef VkPhysicalDeviceDisplacementMicromapPropertiesNV Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS +#endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS -// Map type VkAccelerationStructureTrianglesDisplacementMicromapNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV -template <> struct LvlTypeMap<VkAccelerationStructureTrianglesDisplacementMicromapNV> { +// Map type VkAccelerationStructureTrianglesDisplacementMicromapNV to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV +template <> +struct LvlTypeMap<VkAccelerationStructureTrianglesDisplacementMicromapNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV> { typedef VkAccelerationStructureTrianglesDisplacementMicromapNV Type; }; -#endif // VK_ENABLE_BETA_EXTENSIONS -// Map type VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI -template <> struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI> { +#endif // VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI +template <> +struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI> { typedef VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI Type; }; -// Map type VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI -template <> struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI> { +// Map type VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI +template <> +struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI> { typedef VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI Type; }; -// Map type VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI -template <> struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI> { +// Map type VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI +template <> +struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI> { typedef VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI Type; }; // Map type VkPhysicalDeviceBorderColorSwizzleFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT> { typedef VkPhysicalDeviceBorderColorSwizzleFeaturesEXT Type; }; -// Map type VkSamplerBorderColorComponentMappingCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkSamplerBorderColorComponentMappingCreateInfoEXT> { +// Map type VkSamplerBorderColorComponentMappingCreateInfoEXT to id +// VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkSamplerBorderColorComponentMappingCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT> { typedef VkSamplerBorderColorComponentMappingCreateInfoEXT Type; }; -// Map type VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT> { +// Map type VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT> { typedef VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT Type; }; // Map type VkPhysicalDeviceShaderCorePropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM -template <> struct LvlTypeMap<VkPhysicalDeviceShaderCorePropertiesARM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderCorePropertiesARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM> { typedef VkPhysicalDeviceShaderCorePropertiesARM Type; }; // Map type VkDeviceQueueShaderCoreControlCreateInfoARM to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM -template <> struct LvlTypeMap<VkDeviceQueueShaderCoreControlCreateInfoARM> { +template <> +struct LvlTypeMap<VkDeviceQueueShaderCoreControlCreateInfoARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM> { typedef VkDeviceQueueShaderCoreControlCreateInfoARM Type; }; // Map type VkPhysicalDeviceSchedulingControlsFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM -template <> struct LvlTypeMap<VkPhysicalDeviceSchedulingControlsFeaturesARM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceSchedulingControlsFeaturesARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM> { typedef VkPhysicalDeviceSchedulingControlsFeaturesARM Type; }; -// Map type VkPhysicalDeviceSchedulingControlsPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM -template <> struct LvlTypeMap<VkPhysicalDeviceSchedulingControlsPropertiesARM> { +// Map type VkPhysicalDeviceSchedulingControlsPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceSchedulingControlsPropertiesARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM> { typedef VkPhysicalDeviceSchedulingControlsPropertiesARM Type; }; -// Map type VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT> { +// Map type VkDispatchParametersARM to id VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM +template <> +struct LvlTypeMap<VkDispatchParametersARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM> { + typedef VkDispatchParametersARM Type; +}; + +// Map type VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM> { + typedef VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM Type; +}; + +// Map type VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT> { typedef VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT Type; }; // Map type VkImageViewSlicedCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkImageViewSlicedCreateInfoEXT> { +template <> +struct LvlTypeMap<VkImageViewSlicedCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT> { typedef VkImageViewSlicedCreateInfoEXT Type; }; -// Map type VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE -template <> struct LvlTypeMap<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE> { +// Map type VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE> { typedef VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE Type; }; // Map type VkDescriptorSetBindingReferenceVALVE to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE -template <> struct LvlTypeMap<VkDescriptorSetBindingReferenceVALVE> { +template <> +struct LvlTypeMap<VkDescriptorSetBindingReferenceVALVE> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE> { typedef VkDescriptorSetBindingReferenceVALVE Type; }; // Map type VkDescriptorSetLayoutHostMappingInfoVALVE to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE -template <> struct LvlTypeMap<VkDescriptorSetLayoutHostMappingInfoVALVE> { +template <> +struct LvlTypeMap<VkDescriptorSetLayoutHostMappingInfoVALVE> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE> { typedef VkDescriptorSetLayoutHostMappingInfoVALVE Type; }; -// Map type VkPhysicalDeviceDepthClampZeroOneFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT> { - typedef VkPhysicalDeviceDepthClampZeroOneFeaturesEXT Type; -}; - // Map type VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT> { typedef VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT Type; }; // Map type VkPhysicalDeviceRenderPassStripedFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM -template <> struct LvlTypeMap<VkPhysicalDeviceRenderPassStripedFeaturesARM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceRenderPassStripedFeaturesARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM> { typedef VkPhysicalDeviceRenderPassStripedFeaturesARM Type; }; -// Map type VkPhysicalDeviceRenderPassStripedPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM -template <> struct LvlTypeMap<VkPhysicalDeviceRenderPassStripedPropertiesARM> { +// Map type VkPhysicalDeviceRenderPassStripedPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceRenderPassStripedPropertiesARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM> { typedef VkPhysicalDeviceRenderPassStripedPropertiesARM Type; }; // Map type VkRenderPassStripeInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM -template <> struct LvlTypeMap<VkRenderPassStripeInfoARM> { +template <> +struct LvlTypeMap<VkRenderPassStripeInfoARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM> { typedef VkRenderPassStripeInfoARM Type; }; // Map type VkRenderPassStripeBeginInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM -template <> struct LvlTypeMap<VkRenderPassStripeBeginInfoARM> { +template <> +struct LvlTypeMap<VkRenderPassStripeBeginInfoARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM> { typedef VkRenderPassStripeBeginInfoARM Type; }; // Map type VkRenderPassStripeSubmitInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM -template <> struct LvlTypeMap<VkRenderPassStripeSubmitInfoARM> { +template <> +struct LvlTypeMap<VkRenderPassStripeSubmitInfoARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM> { typedef VkRenderPassStripeSubmitInfoARM Type; }; -// Map type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM; +// Map type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM> { - typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM Type; +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT> { + typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT Type; }; -// Map type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM; +// Map type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM> { - typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM Type; +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT> { + typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT Type; }; -// Map type VkSubpassFragmentDensityMapOffsetEndInfoQCOM to id VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM -template <> struct LvlTypeMap<VkSubpassFragmentDensityMapOffsetEndInfoQCOM> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM; +// Map type VkRenderPassFragmentDensityMapOffsetEndInfoEXT to id +// VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT +template <> +struct LvlTypeMap<VkRenderPassFragmentDensityMapOffsetEndInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM> { - typedef VkSubpassFragmentDensityMapOffsetEndInfoQCOM Type; +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT> { + typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT Type; }; // Map type VkPhysicalDeviceCopyMemoryIndirectFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV> { typedef VkPhysicalDeviceCopyMemoryIndirectFeaturesNV Type; }; -// Map type VkPhysicalDeviceCopyMemoryIndirectPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; +// Map type VkPhysicalDeviceMemoryDecompressionFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceMemoryDecompressionFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV> { - typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesNV Type; +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT> { + typedef VkPhysicalDeviceMemoryDecompressionFeaturesEXT Type; }; -// Map type VkPhysicalDeviceMemoryDecompressionFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceMemoryDecompressionFeaturesNV> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; +// Map type VkPhysicalDeviceMemoryDecompressionPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceMemoryDecompressionPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV> { - typedef VkPhysicalDeviceMemoryDecompressionFeaturesNV Type; +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT> { + typedef VkPhysicalDeviceMemoryDecompressionPropertiesEXT Type; }; -// Map type VkPhysicalDeviceMemoryDecompressionPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceMemoryDecompressionPropertiesNV> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV> { - typedef VkPhysicalDeviceMemoryDecompressionPropertiesNV Type; -}; - -// Map type VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV> { +// Map type VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV> { typedef VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV Type; }; // Map type VkComputePipelineIndirectBufferInfoNV to id VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV -template <> struct LvlTypeMap<VkComputePipelineIndirectBufferInfoNV> { +template <> +struct LvlTypeMap<VkComputePipelineIndirectBufferInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV> { typedef VkComputePipelineIndirectBufferInfoNV Type; }; // Map type VkPipelineIndirectDeviceAddressInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV -template <> struct LvlTypeMap<VkPipelineIndirectDeviceAddressInfoNV> { +template <> +struct LvlTypeMap<VkPipelineIndirectDeviceAddressInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV> { typedef VkPipelineIndirectDeviceAddressInfoNV Type; }; -// Map type VkPhysicalDeviceLinearColorAttachmentFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceLinearColorAttachmentFeaturesNV> { +// Map type VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV> { + typedef VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV Type; +}; + +// Map type VkAccelerationStructureGeometryLinearSweptSpheresDataNV to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV +template <> +struct LvlTypeMap<VkAccelerationStructureGeometryLinearSweptSpheresDataNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV> { + typedef VkAccelerationStructureGeometryLinearSweptSpheresDataNV Type; +}; + +// Map type VkAccelerationStructureGeometrySpheresDataNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV +template <> +struct LvlTypeMap<VkAccelerationStructureGeometrySpheresDataNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV> { + typedef VkAccelerationStructureGeometrySpheresDataNV Type; +}; + +// Map type VkPhysicalDeviceLinearColorAttachmentFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceLinearColorAttachmentFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV> { typedef VkPhysicalDeviceLinearColorAttachmentFeaturesNV Type; }; -// Map type VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT> { +// Map type VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT> { typedef VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT Type; }; // Map type VkImageViewSampleWeightCreateInfoQCOM to id VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM -template <> struct LvlTypeMap<VkImageViewSampleWeightCreateInfoQCOM> { +template <> +struct LvlTypeMap<VkImageViewSampleWeightCreateInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM> { typedef VkImageViewSampleWeightCreateInfoQCOM Type; }; // Map type VkPhysicalDeviceImageProcessingFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceImageProcessingFeaturesQCOM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImageProcessingFeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM> { typedef VkPhysicalDeviceImageProcessingFeaturesQCOM Type; }; // Map type VkPhysicalDeviceImageProcessingPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceImageProcessingPropertiesQCOM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImageProcessingPropertiesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM> { typedef VkPhysicalDeviceImageProcessingPropertiesQCOM Type; }; -// Map type VkPhysicalDeviceNestedCommandBufferFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceNestedCommandBufferFeaturesEXT> { +// Map type VkPhysicalDeviceNestedCommandBufferFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceNestedCommandBufferFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT> { typedef VkPhysicalDeviceNestedCommandBufferFeaturesEXT Type; }; -// Map type VkPhysicalDeviceNestedCommandBufferPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceNestedCommandBufferPropertiesEXT> { +// Map type VkPhysicalDeviceNestedCommandBufferPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceNestedCommandBufferPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT> { typedef VkPhysicalDeviceNestedCommandBufferPropertiesEXT Type; }; +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferUsageOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS +template <> +struct LvlTypeMap<VkNativeBufferUsageOHOS> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS> { + typedef VkNativeBufferUsageOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS +template <> +struct LvlTypeMap<VkNativeBufferPropertiesOHOS> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS> { + typedef VkNativeBufferPropertiesOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferFormatPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS +template <> +struct LvlTypeMap<VkNativeBufferFormatPropertiesOHOS> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS> { + typedef VkNativeBufferFormatPropertiesOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkImportNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS +template <> +struct LvlTypeMap<VkImportNativeBufferInfoOHOS> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS> { + typedef VkImportNativeBufferInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkMemoryGetNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS +template <> +struct LvlTypeMap<VkMemoryGetNativeBufferInfoOHOS> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS> { + typedef VkMemoryGetNativeBufferInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkExternalFormatOHOS to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS +template <> +struct LvlTypeMap<VkExternalFormatOHOS> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS> { + typedef VkExternalFormatOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS // Map type VkExternalMemoryAcquireUnmodifiedEXT to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT -template <> struct LvlTypeMap<VkExternalMemoryAcquireUnmodifiedEXT> { +template <> +struct LvlTypeMap<VkExternalMemoryAcquireUnmodifiedEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT> { typedef VkExternalMemoryAcquireUnmodifiedEXT Type; }; -// Map type VkPhysicalDeviceExtendedDynamicState3FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT> { +// Map type VkPhysicalDeviceExtendedDynamicState3FeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT> { typedef VkPhysicalDeviceExtendedDynamicState3FeaturesEXT Type; }; -// Map type VkPhysicalDeviceExtendedDynamicState3PropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT> { +// Map type VkPhysicalDeviceExtendedDynamicState3PropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT> { typedef VkPhysicalDeviceExtendedDynamicState3PropertiesEXT Type; }; -// Map type VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT> { +// Map type VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT> { typedef VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT Type; }; // Map type VkRenderPassCreationControlEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT -template <> struct LvlTypeMap<VkRenderPassCreationControlEXT> { +template <> +struct LvlTypeMap<VkRenderPassCreationControlEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT> { typedef VkRenderPassCreationControlEXT Type; }; // Map type VkRenderPassCreationFeedbackCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkRenderPassCreationFeedbackCreateInfoEXT> { +template <> +struct LvlTypeMap<VkRenderPassCreationFeedbackCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT> { typedef VkRenderPassCreationFeedbackCreateInfoEXT Type; }; // Map type VkRenderPassSubpassFeedbackCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkRenderPassSubpassFeedbackCreateInfoEXT> { +template <> +struct LvlTypeMap<VkRenderPassSubpassFeedbackCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT> { typedef VkRenderPassSubpassFeedbackCreateInfoEXT Type; }; // Map type VkDirectDriverLoadingInfoLUNARG to id VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG -template <> struct LvlTypeMap<VkDirectDriverLoadingInfoLUNARG> { +template <> +struct LvlTypeMap<VkDirectDriverLoadingInfoLUNARG> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG> { typedef VkDirectDriverLoadingInfoLUNARG Type; }; // Map type VkDirectDriverLoadingListLUNARG to id VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG -template <> struct LvlTypeMap<VkDirectDriverLoadingListLUNARG> { +template <> +struct LvlTypeMap<VkDirectDriverLoadingListLUNARG> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG> { typedef VkDirectDriverLoadingListLUNARG Type; }; -// Map type VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT> { +// Map type VkTensorDescriptionARM to id VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM +template <> +struct LvlTypeMap<VkTensorDescriptionARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM> { + typedef VkTensorDescriptionARM Type; +}; + +// Map type VkTensorCreateInfoARM to id VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkTensorCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM> { + typedef VkTensorCreateInfoARM Type; +}; + +// Map type VkTensorMemoryRequirementsInfoARM to id VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM +template <> +struct LvlTypeMap<VkTensorMemoryRequirementsInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM> { + typedef VkTensorMemoryRequirementsInfoARM Type; +}; + +// Map type VkBindTensorMemoryInfoARM to id VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM +template <> +struct LvlTypeMap<VkBindTensorMemoryInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM> { + typedef VkBindTensorMemoryInfoARM Type; +}; + +// Map type VkWriteDescriptorSetTensorARM to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM +template <> +struct LvlTypeMap<VkWriteDescriptorSetTensorARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM> { + typedef VkWriteDescriptorSetTensorARM Type; +}; + +// Map type VkTensorFormatPropertiesARM to id VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkTensorFormatPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM> { + typedef VkTensorFormatPropertiesARM Type; +}; + +// Map type VkPhysicalDeviceTensorPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceTensorPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM> { + typedef VkPhysicalDeviceTensorPropertiesARM Type; +}; + +// Map type VkTensorMemoryBarrierARM to id VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM +template <> +struct LvlTypeMap<VkTensorMemoryBarrierARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM> { + typedef VkTensorMemoryBarrierARM Type; +}; + +// Map type VkTensorDependencyInfoARM to id VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM +template <> +struct LvlTypeMap<VkTensorDependencyInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM> { + typedef VkTensorDependencyInfoARM Type; +}; + +// Map type VkPhysicalDeviceTensorFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceTensorFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM> { + typedef VkPhysicalDeviceTensorFeaturesARM Type; +}; + +// Map type VkDeviceTensorMemoryRequirementsARM to id VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM +template <> +struct LvlTypeMap<VkDeviceTensorMemoryRequirementsARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM> { + typedef VkDeviceTensorMemoryRequirementsARM Type; +}; + +// Map type VkTensorCopyARM to id VK_STRUCTURE_TYPE_TENSOR_COPY_ARM +template <> +struct LvlTypeMap<VkTensorCopyARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_COPY_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_COPY_ARM> { + typedef VkTensorCopyARM Type; +}; + +// Map type VkCopyTensorInfoARM to id VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM +template <> +struct LvlTypeMap<VkCopyTensorInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM> { + typedef VkCopyTensorInfoARM Type; +}; + +// Map type VkMemoryDedicatedAllocateInfoTensorARM to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM +template <> +struct LvlTypeMap<VkMemoryDedicatedAllocateInfoTensorARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM> { + typedef VkMemoryDedicatedAllocateInfoTensorARM Type; +}; + +// Map type VkPhysicalDeviceExternalTensorInfoARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalTensorInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM> { + typedef VkPhysicalDeviceExternalTensorInfoARM Type; +}; + +// Map type VkExternalTensorPropertiesARM to id VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkExternalTensorPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM> { + typedef VkExternalTensorPropertiesARM Type; +}; + +// Map type VkExternalMemoryTensorCreateInfoARM to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkExternalMemoryTensorCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM> { + typedef VkExternalMemoryTensorCreateInfoARM Type; +}; + +// Map type VkPhysicalDeviceDescriptorBufferTensorFeaturesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM> { + typedef VkPhysicalDeviceDescriptorBufferTensorFeaturesARM Type; +}; + +// Map type VkPhysicalDeviceDescriptorBufferTensorPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM> { + typedef VkPhysicalDeviceDescriptorBufferTensorPropertiesARM Type; +}; + +// Map type VkDescriptorGetTensorInfoARM to id VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM +template <> +struct LvlTypeMap<VkDescriptorGetTensorInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM> { + typedef VkDescriptorGetTensorInfoARM Type; +}; + +// Map type VkTensorCaptureDescriptorDataInfoARM to id VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM +template <> +struct LvlTypeMap<VkTensorCaptureDescriptorDataInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM> { + typedef VkTensorCaptureDescriptorDataInfoARM Type; +}; + +// Map type VkTensorViewCaptureDescriptorDataInfoARM to id VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM +template <> +struct LvlTypeMap<VkTensorViewCaptureDescriptorDataInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM> { + typedef VkTensorViewCaptureDescriptorDataInfoARM Type; +}; + +// Map type VkFrameBoundaryTensorsARM to id VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM +template <> +struct LvlTypeMap<VkFrameBoundaryTensorsARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM> { + typedef VkFrameBoundaryTensorsARM Type; +}; + +// Map type VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT> { typedef VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT Type; }; -// Map type VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT> { +// Map type VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT> { typedef VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT Type; }; -// Map type VkPipelineShaderStageModuleIdentifierCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineShaderStageModuleIdentifierCreateInfoEXT> { +// Map type VkPipelineShaderStageModuleIdentifierCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineShaderStageModuleIdentifierCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT> { typedef VkPipelineShaderStageModuleIdentifierCreateInfoEXT Type; }; // Map type VkShaderModuleIdentifierEXT to id VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT -template <> struct LvlTypeMap<VkShaderModuleIdentifierEXT> { +template <> +struct LvlTypeMap<VkShaderModuleIdentifierEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT> { typedef VkShaderModuleIdentifierEXT Type; }; // Map type VkPhysicalDeviceOpticalFlowFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceOpticalFlowFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceOpticalFlowFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV> { typedef VkPhysicalDeviceOpticalFlowFeaturesNV Type; }; // Map type VkPhysicalDeviceOpticalFlowPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceOpticalFlowPropertiesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceOpticalFlowPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV> { typedef VkPhysicalDeviceOpticalFlowPropertiesNV Type; }; // Map type VkOpticalFlowImageFormatInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV -template <> struct LvlTypeMap<VkOpticalFlowImageFormatInfoNV> { +template <> +struct LvlTypeMap<VkOpticalFlowImageFormatInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV> { typedef VkOpticalFlowImageFormatInfoNV Type; }; // Map type VkOpticalFlowImageFormatPropertiesNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV -template <> struct LvlTypeMap<VkOpticalFlowImageFormatPropertiesNV> { +template <> +struct LvlTypeMap<VkOpticalFlowImageFormatPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV> { typedef VkOpticalFlowImageFormatPropertiesNV Type; }; // Map type VkOpticalFlowSessionCreateInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV -template <> struct LvlTypeMap<VkOpticalFlowSessionCreateInfoNV> { +template <> +struct LvlTypeMap<VkOpticalFlowSessionCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV> { typedef VkOpticalFlowSessionCreateInfoNV Type; }; // Map type VkOpticalFlowSessionCreatePrivateDataInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV -template <> struct LvlTypeMap<VkOpticalFlowSessionCreatePrivateDataInfoNV> { +template <> +struct LvlTypeMap<VkOpticalFlowSessionCreatePrivateDataInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV> { typedef VkOpticalFlowSessionCreatePrivateDataInfoNV Type; }; // Map type VkOpticalFlowExecuteInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV -template <> struct LvlTypeMap<VkOpticalFlowExecuteInfoNV> { +template <> +struct LvlTypeMap<VkOpticalFlowExecuteInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV> { typedef VkOpticalFlowExecuteInfoNV Type; }; // Map type VkPhysicalDeviceLegacyDitheringFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceLegacyDitheringFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceLegacyDitheringFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT> { typedef VkPhysicalDeviceLegacyDitheringFeaturesEXT Type; }; #ifdef VK_USE_PLATFORM_ANDROID_KHR -// Map type VkPhysicalDeviceExternalFormatResolveFeaturesANDROID to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID -template <> struct LvlTypeMap<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID> { +// Map type VkPhysicalDeviceExternalFormatResolveFeaturesANDROID to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID> { typedef VkPhysicalDeviceExternalFormatResolveFeaturesANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR -// Map type VkPhysicalDeviceExternalFormatResolvePropertiesANDROID to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID -template <> struct LvlTypeMap<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID> { +// Map type VkPhysicalDeviceExternalFormatResolvePropertiesANDROID to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID> { typedef VkPhysicalDeviceExternalFormatResolvePropertiesANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR -// Map type VkAndroidHardwareBufferFormatResolvePropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID -template <> struct LvlTypeMap<VkAndroidHardwareBufferFormatResolvePropertiesANDROID> { +// Map type VkAndroidHardwareBufferFormatResolvePropertiesANDROID to id +// VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID +template <> +struct LvlTypeMap<VkAndroidHardwareBufferFormatResolvePropertiesANDROID> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID> { typedef VkAndroidHardwareBufferFormatResolvePropertiesANDROID Type; }; -#endif // VK_USE_PLATFORM_ANDROID_KHR +#endif // VK_USE_PLATFORM_ANDROID_KHR // Map type VkPhysicalDeviceAntiLagFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD -template <> struct LvlTypeMap<VkPhysicalDeviceAntiLagFeaturesAMD> { +template <> +struct LvlTypeMap<VkPhysicalDeviceAntiLagFeaturesAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD> { typedef VkPhysicalDeviceAntiLagFeaturesAMD Type; }; // Map type VkAntiLagPresentationInfoAMD to id VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD -template <> struct LvlTypeMap<VkAntiLagPresentationInfoAMD> { +template <> +struct LvlTypeMap<VkAntiLagPresentationInfoAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD> { typedef VkAntiLagPresentationInfoAMD Type; }; // Map type VkAntiLagDataAMD to id VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD -template <> struct LvlTypeMap<VkAntiLagDataAMD> { +template <> +struct LvlTypeMap<VkAntiLagDataAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD> { typedef VkAntiLagDataAMD Type; }; +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX +template <> +struct LvlTypeMap<VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX> { + typedef VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX +template <> +struct LvlTypeMap<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX> { + typedef VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS // Map type VkPhysicalDeviceShaderObjectFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderObjectFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderObjectFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT> { typedef VkPhysicalDeviceShaderObjectFeaturesEXT Type; }; // Map type VkPhysicalDeviceShaderObjectPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderObjectPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderObjectPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT> { typedef VkPhysicalDeviceShaderObjectPropertiesEXT Type; }; // Map type VkShaderCreateInfoEXT to id VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkShaderCreateInfoEXT> { +template <> +struct LvlTypeMap<VkShaderCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT> { typedef VkShaderCreateInfoEXT Type; }; // Map type VkPhysicalDeviceTilePropertiesFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceTilePropertiesFeaturesQCOM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceTilePropertiesFeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM> { typedef VkPhysicalDeviceTilePropertiesFeaturesQCOM Type; }; // Map type VkTilePropertiesQCOM to id VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM -template <> struct LvlTypeMap<VkTilePropertiesQCOM> { +template <> +struct LvlTypeMap<VkTilePropertiesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM> { typedef VkTilePropertiesQCOM Type; }; // Map type VkPhysicalDeviceAmigoProfilingFeaturesSEC to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC -template <> struct LvlTypeMap<VkPhysicalDeviceAmigoProfilingFeaturesSEC> { +template <> +struct LvlTypeMap<VkPhysicalDeviceAmigoProfilingFeaturesSEC> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC> { typedef VkPhysicalDeviceAmigoProfilingFeaturesSEC Type; }; // Map type VkAmigoProfilingSubmitInfoSEC to id VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC -template <> struct LvlTypeMap<VkAmigoProfilingSubmitInfoSEC> { +template <> +struct LvlTypeMap<VkAmigoProfilingSubmitInfoSEC> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC> { typedef VkAmigoProfilingSubmitInfoSEC Type; }; -// Map type VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM> { +// Map type VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM> { typedef VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM Type; }; -// Map type VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV> { +// Map type VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV> { typedef VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV Type; }; -// Map type VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV> { +// Map type VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV> { typedef VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV Type; }; -// Map type VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV> { +// Map type VkPhysicalDeviceCooperativeVectorPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeVectorPropertiesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV> { + typedef VkPhysicalDeviceCooperativeVectorPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceCooperativeVectorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeVectorFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV> { + typedef VkPhysicalDeviceCooperativeVectorFeaturesNV Type; +}; + +// Map type VkCooperativeVectorPropertiesNV to id VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV +template <> +struct LvlTypeMap<VkCooperativeVectorPropertiesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV> { + typedef VkCooperativeVectorPropertiesNV Type; +}; + +// Map type VkConvertCooperativeVectorMatrixInfoNV to id VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV +template <> +struct LvlTypeMap<VkConvertCooperativeVectorMatrixInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV> { + typedef VkConvertCooperativeVectorMatrixInfoNV Type; +}; + +// Map type VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV> { typedef VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV Type; }; -// Map type VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV> { +// Map type VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV> { typedef VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV Type; }; -// Map type VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT> { +// Map type VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT> { typedef VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT Type; }; -// Map type VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT> { +// Map type VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT> { typedef VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT Type; }; // Map type VkLayerSettingsCreateInfoEXT to id VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkLayerSettingsCreateInfoEXT> { +template <> +struct LvlTypeMap<VkLayerSettingsCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT> { typedef VkLayerSettingsCreateInfoEXT Type; }; // Map type VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM -template <> struct LvlTypeMap<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM> { typedef VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM Type; }; -// Map type VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM -template <> struct LvlTypeMap<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM> { +// Map type VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM> { typedef VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM Type; }; -// Map type VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> { +// Map type VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT> { typedef VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT Type; }; -// Map type VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT> { +// Map type VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT> { typedef VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT Type; }; // Map type VkLatencySleepModeInfoNV to id VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV -template <> struct LvlTypeMap<VkLatencySleepModeInfoNV> { +template <> +struct LvlTypeMap<VkLatencySleepModeInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV> { typedef VkLatencySleepModeInfoNV Type; }; // Map type VkLatencySleepInfoNV to id VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV -template <> struct LvlTypeMap<VkLatencySleepInfoNV> { +template <> +struct LvlTypeMap<VkLatencySleepInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV> { typedef VkLatencySleepInfoNV Type; }; // Map type VkSetLatencyMarkerInfoNV to id VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV -template <> struct LvlTypeMap<VkSetLatencyMarkerInfoNV> { +template <> +struct LvlTypeMap<VkSetLatencyMarkerInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV> { typedef VkSetLatencyMarkerInfoNV Type; }; // Map type VkLatencyTimingsFrameReportNV to id VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV -template <> struct LvlTypeMap<VkLatencyTimingsFrameReportNV> { +template <> +struct LvlTypeMap<VkLatencyTimingsFrameReportNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV> { typedef VkLatencyTimingsFrameReportNV Type; }; // Map type VkGetLatencyMarkerInfoNV to id VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV -template <> struct LvlTypeMap<VkGetLatencyMarkerInfoNV> { +template <> +struct LvlTypeMap<VkGetLatencyMarkerInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV> { typedef VkGetLatencyMarkerInfoNV Type; }; // Map type VkLatencySubmissionPresentIdNV to id VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV -template <> struct LvlTypeMap<VkLatencySubmissionPresentIdNV> { +template <> +struct LvlTypeMap<VkLatencySubmissionPresentIdNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV> { typedef VkLatencySubmissionPresentIdNV Type; }; // Map type VkSwapchainLatencyCreateInfoNV to id VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV -template <> struct LvlTypeMap<VkSwapchainLatencyCreateInfoNV> { +template <> +struct LvlTypeMap<VkSwapchainLatencyCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV> { typedef VkSwapchainLatencyCreateInfoNV Type; }; // Map type VkOutOfBandQueueTypeInfoNV to id VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV -template <> struct LvlTypeMap<VkOutOfBandQueueTypeInfoNV> { +template <> +struct LvlTypeMap<VkOutOfBandQueueTypeInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV> { typedef VkOutOfBandQueueTypeInfoNV Type; }; // Map type VkLatencySurfaceCapabilitiesNV to id VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV -template <> struct LvlTypeMap<VkLatencySurfaceCapabilitiesNV> { +template <> +struct LvlTypeMap<VkLatencySurfaceCapabilitiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV> { typedef VkLatencySurfaceCapabilitiesNV Type; }; -// Map type VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM> { +// Map type VkPhysicalDeviceDataGraphFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceDataGraphFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM> { + typedef VkPhysicalDeviceDataGraphFeaturesARM Type; +}; + +// Map type VkDataGraphPipelineConstantARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineConstantARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM> { + typedef VkDataGraphPipelineConstantARM Type; +}; + +// Map type VkDataGraphPipelineResourceInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineResourceInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM> { + typedef VkDataGraphPipelineResourceInfoARM Type; +}; + +// Map type VkDataGraphPipelineCompilerControlCreateInfoARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineCompilerControlCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineCompilerControlCreateInfoARM Type; +}; + +// Map type VkDataGraphPipelineCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineCreateInfoARM Type; +}; + +// Map type VkDataGraphPipelineShaderModuleCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineShaderModuleCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineShaderModuleCreateInfoARM Type; +}; + +// Map type VkDataGraphPipelineSessionCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineSessionCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineSessionCreateInfoARM Type; +}; + +// Map type VkDataGraphPipelineSessionBindPointRequirementsInfoARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineSessionBindPointRequirementsInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM> { + typedef VkDataGraphPipelineSessionBindPointRequirementsInfoARM Type; +}; + +// Map type VkDataGraphPipelineSessionBindPointRequirementARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineSessionBindPointRequirementARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM> { + typedef VkDataGraphPipelineSessionBindPointRequirementARM Type; +}; + +// Map type VkDataGraphPipelineSessionMemoryRequirementsInfoARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineSessionMemoryRequirementsInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM> { + typedef VkDataGraphPipelineSessionMemoryRequirementsInfoARM Type; +}; + +// Map type VkBindDataGraphPipelineSessionMemoryInfoARM to id VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM +template <> +struct LvlTypeMap<VkBindDataGraphPipelineSessionMemoryInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM> { + typedef VkBindDataGraphPipelineSessionMemoryInfoARM Type; +}; + +// Map type VkDataGraphPipelineInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM> { + typedef VkDataGraphPipelineInfoARM Type; +}; + +// Map type VkDataGraphPipelinePropertyQueryResultARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelinePropertyQueryResultARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM> { + typedef VkDataGraphPipelinePropertyQueryResultARM Type; +}; + +// Map type VkDataGraphPipelineIdentifierCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineIdentifierCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineIdentifierCreateInfoARM Type; +}; + +// Map type VkDataGraphPipelineDispatchInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineDispatchInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM> { + typedef VkDataGraphPipelineDispatchInfoARM Type; +}; + +// Map type VkQueueFamilyDataGraphPropertiesARM to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkQueueFamilyDataGraphPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM> { + typedef VkQueueFamilyDataGraphPropertiesARM Type; +}; + +// Map type VkDataGraphProcessingEngineCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphProcessingEngineCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM> { + typedef VkDataGraphProcessingEngineCreateInfoARM Type; +}; + +// Map type VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM> { + typedef VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM Type; +}; + +// Map type VkQueueFamilyDataGraphProcessingEnginePropertiesARM to id +// VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkQueueFamilyDataGraphProcessingEnginePropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM> { + typedef VkQueueFamilyDataGraphProcessingEnginePropertiesARM Type; +}; + +// Map type VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM> { + typedef VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM Type; +}; + +// Map type VkQueueFamilyDataGraphTOSAPropertiesARM to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkQueueFamilyDataGraphTOSAPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM> { + typedef VkQueueFamilyDataGraphTOSAPropertiesARM Type; +}; + +// Map type VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM> { typedef VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM Type; }; -// Map type VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM to id VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM -template <> struct LvlTypeMap<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM> { +// Map type VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM to id +// VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM +template <> +struct LvlTypeMap<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM> { typedef VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM Type; }; -// Map type VkPhysicalDevicePerStageDescriptorSetFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDevicePerStageDescriptorSetFeaturesNV> { +// Map type VkPhysicalDevicePerStageDescriptorSetFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDevicePerStageDescriptorSetFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV> { typedef VkPhysicalDevicePerStageDescriptorSetFeaturesNV Type; }; // Map type VkPhysicalDeviceImageProcessing2FeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceImageProcessing2FeaturesQCOM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceImageProcessing2FeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM> { typedef VkPhysicalDeviceImageProcessing2FeaturesQCOM Type; }; -// Map type VkPhysicalDeviceImageProcessing2PropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceImageProcessing2PropertiesQCOM> { +// Map type VkPhysicalDeviceImageProcessing2PropertiesQCOM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceImageProcessing2PropertiesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM> { typedef VkPhysicalDeviceImageProcessing2PropertiesQCOM Type; }; // Map type VkSamplerBlockMatchWindowCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM -template <> struct LvlTypeMap<VkSamplerBlockMatchWindowCreateInfoQCOM> { +template <> +struct LvlTypeMap<VkSamplerBlockMatchWindowCreateInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM> { typedef VkSamplerBlockMatchWindowCreateInfoQCOM Type; }; // Map type VkPhysicalDeviceCubicWeightsFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceCubicWeightsFeaturesQCOM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCubicWeightsFeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM> { typedef VkPhysicalDeviceCubicWeightsFeaturesQCOM Type; }; // Map type VkSamplerCubicWeightsCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM -template <> struct LvlTypeMap<VkSamplerCubicWeightsCreateInfoQCOM> { +template <> +struct LvlTypeMap<VkSamplerCubicWeightsCreateInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM> { typedef VkSamplerCubicWeightsCreateInfoQCOM Type; }; // Map type VkBlitImageCubicWeightsInfoQCOM to id VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM -template <> struct LvlTypeMap<VkBlitImageCubicWeightsInfoQCOM> { +template <> +struct LvlTypeMap<VkBlitImageCubicWeightsInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM> { typedef VkBlitImageCubicWeightsInfoQCOM Type; }; // Map type VkPhysicalDeviceYcbcrDegammaFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM> { typedef VkPhysicalDeviceYcbcrDegammaFeaturesQCOM Type; }; -// Map type VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM -template <> struct LvlTypeMap<VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM> { +// Map type VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM to id +// VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM +template <> +struct LvlTypeMap<VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM> { typedef VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM Type; }; // Map type VkPhysicalDeviceCubicClampFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM -template <> struct LvlTypeMap<VkPhysicalDeviceCubicClampFeaturesQCOM> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCubicClampFeaturesQCOM> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM> { typedef VkPhysicalDeviceCubicClampFeaturesQCOM Type; }; -// Map type VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT> { +// Map type VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT> { typedef VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT Type; }; #ifdef VK_USE_PLATFORM_SCREEN_QNX // Map type VkScreenBufferPropertiesQNX to id VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX -template <> struct LvlTypeMap<VkScreenBufferPropertiesQNX> { +template <> +struct LvlTypeMap<VkScreenBufferPropertiesQNX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX> { typedef VkScreenBufferPropertiesQNX Type; }; -#endif // VK_USE_PLATFORM_SCREEN_QNX +#endif // VK_USE_PLATFORM_SCREEN_QNX #ifdef VK_USE_PLATFORM_SCREEN_QNX // Map type VkScreenBufferFormatPropertiesQNX to id VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX -template <> struct LvlTypeMap<VkScreenBufferFormatPropertiesQNX> { +template <> +struct LvlTypeMap<VkScreenBufferFormatPropertiesQNX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX> { typedef VkScreenBufferFormatPropertiesQNX Type; }; -#endif // VK_USE_PLATFORM_SCREEN_QNX +#endif // VK_USE_PLATFORM_SCREEN_QNX #ifdef VK_USE_PLATFORM_SCREEN_QNX // Map type VkImportScreenBufferInfoQNX to id VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX -template <> struct LvlTypeMap<VkImportScreenBufferInfoQNX> { +template <> +struct LvlTypeMap<VkImportScreenBufferInfoQNX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX> { typedef VkImportScreenBufferInfoQNX Type; }; -#endif // VK_USE_PLATFORM_SCREEN_QNX +#endif // VK_USE_PLATFORM_SCREEN_QNX #ifdef VK_USE_PLATFORM_SCREEN_QNX // Map type VkExternalFormatQNX to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX -template <> struct LvlTypeMap<VkExternalFormatQNX> { +template <> +struct LvlTypeMap<VkExternalFormatQNX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX> { typedef VkExternalFormatQNX Type; }; -#endif // VK_USE_PLATFORM_SCREEN_QNX +#endif // VK_USE_PLATFORM_SCREEN_QNX #ifdef VK_USE_PLATFORM_SCREEN_QNX -// Map type VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX -template <> struct LvlTypeMap<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX> { +// Map type VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX> { typedef VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX Type; }; -#endif // VK_USE_PLATFORM_SCREEN_QNX +#endif // VK_USE_PLATFORM_SCREEN_QNX // Map type VkPhysicalDeviceLayeredDriverPropertiesMSFT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT -template <> struct LvlTypeMap<VkPhysicalDeviceLayeredDriverPropertiesMSFT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceLayeredDriverPropertiesMSFT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT> { typedef VkPhysicalDeviceLayeredDriverPropertiesMSFT Type; }; -// Map type VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV> { +// Map type VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV> { typedef VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV Type; }; +// Map type VkPhysicalDeviceTileMemoryHeapFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM> { + typedef VkPhysicalDeviceTileMemoryHeapFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceTileMemoryHeapPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM> { + typedef VkPhysicalDeviceTileMemoryHeapPropertiesQCOM Type; +}; + +// Map type VkTileMemoryRequirementsQCOM to id VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM +template <> +struct LvlTypeMap<VkTileMemoryRequirementsQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM> { + typedef VkTileMemoryRequirementsQCOM Type; +}; + +// Map type VkTileMemoryBindInfoQCOM to id VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM +template <> +struct LvlTypeMap<VkTileMemoryBindInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM> { + typedef VkTileMemoryBindInfoQCOM Type; +}; + +// Map type VkTileMemorySizeInfoQCOM to id VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM +template <> +struct LvlTypeMap<VkTileMemorySizeInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM> { + typedef VkTileMemorySizeInfoQCOM Type; +}; + +// Map type VkDecompressMemoryInfoEXT to id VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT +template <> +struct LvlTypeMap<VkDecompressMemoryInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT> { + typedef VkDecompressMemoryInfoEXT Type; +}; + // Map type VkDisplaySurfaceStereoCreateInfoNV to id VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV -template <> struct LvlTypeMap<VkDisplaySurfaceStereoCreateInfoNV> { +template <> +struct LvlTypeMap<VkDisplaySurfaceStereoCreateInfoNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV> { typedef VkDisplaySurfaceStereoCreateInfoNV Type; }; // Map type VkDisplayModeStereoPropertiesNV to id VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV -template <> struct LvlTypeMap<VkDisplayModeStereoPropertiesNV> { +template <> +struct LvlTypeMap<VkDisplayModeStereoPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV> { typedef VkDisplayModeStereoPropertiesNV Type; }; // Map type VkPhysicalDeviceRawAccessChainsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceRawAccessChainsFeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceRawAccessChainsFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV> { typedef VkPhysicalDeviceRawAccessChainsFeaturesNV Type; }; -// Map type VkPhysicalDeviceCommandBufferInheritanceFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV> { +// Map type VkExternalComputeQueueDeviceCreateInfoNV to id VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkExternalComputeQueueDeviceCreateInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV> { + typedef VkExternalComputeQueueDeviceCreateInfoNV Type; +}; + +// Map type VkExternalComputeQueueCreateInfoNV to id VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkExternalComputeQueueCreateInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV> { + typedef VkExternalComputeQueueCreateInfoNV Type; +}; + +// Map type VkExternalComputeQueueDataParamsNV to id VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV +template <> +struct LvlTypeMap<VkExternalComputeQueueDataParamsNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV> { + typedef VkExternalComputeQueueDataParamsNV Type; +}; + +// Map type VkPhysicalDeviceExternalComputeQueuePropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceExternalComputeQueuePropertiesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV> { + typedef VkPhysicalDeviceExternalComputeQueuePropertiesNV Type; +}; + +// Map type VkPhysicalDeviceCommandBufferInheritanceFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV> { typedef VkPhysicalDeviceCommandBufferInheritanceFeaturesNV Type; }; -// Map type VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV> { +// Map type VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV> { typedef VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV Type; }; -// Map type VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT> { +// Map type VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT> { typedef VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT Type; }; -// Map type VkPhysicalDeviceRayTracingValidationFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingValidationFeaturesNV> { +// Map type VkPhysicalDeviceShaderFloat8FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderFloat8FeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT> { + typedef VkPhysicalDeviceShaderFloat8FeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceRayTracingValidationFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingValidationFeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV> { typedef VkPhysicalDeviceRayTracingValidationFeaturesNV Type; }; -// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT> { +// Map type VkPhysicalDeviceClusterAccelerationStructureFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV> { + typedef VkPhysicalDeviceClusterAccelerationStructureFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceClusterAccelerationStructurePropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV> { + typedef VkPhysicalDeviceClusterAccelerationStructurePropertiesNV Type; +}; + +// Map type VkClusterAccelerationStructureClustersBottomLevelInputNV to id +// VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV +template <> +struct LvlTypeMap<VkClusterAccelerationStructureClustersBottomLevelInputNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV> { + typedef VkClusterAccelerationStructureClustersBottomLevelInputNV Type; +}; + +// Map type VkClusterAccelerationStructureTriangleClusterInputNV to id +// VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV +template <> +struct LvlTypeMap<VkClusterAccelerationStructureTriangleClusterInputNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV> { + typedef VkClusterAccelerationStructureTriangleClusterInputNV Type; +}; + +// Map type VkClusterAccelerationStructureMoveObjectsInputNV to id +// VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV +template <> +struct LvlTypeMap<VkClusterAccelerationStructureMoveObjectsInputNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV> { + typedef VkClusterAccelerationStructureMoveObjectsInputNV Type; +}; + +// Map type VkClusterAccelerationStructureInputInfoNV to id VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV +template <> +struct LvlTypeMap<VkClusterAccelerationStructureInputInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV> { + typedef VkClusterAccelerationStructureInputInfoNV Type; +}; + +// Map type VkClusterAccelerationStructureCommandsInfoNV to id VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV +template <> +struct LvlTypeMap<VkClusterAccelerationStructureCommandsInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV> { + typedef VkClusterAccelerationStructureCommandsInfoNV Type; +}; + +// Map type VkAccelerationStructureBuildSizesInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR +template <> +struct LvlTypeMap<VkAccelerationStructureBuildSizesInfoKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR> { + typedef VkAccelerationStructureBuildSizesInfoKHR Type; +}; + +// Map type VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV to id +// VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV +template <> +struct LvlTypeMap<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV> { + typedef VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV Type; +}; + +// Map type VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV> { + typedef VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV Type; +}; + +// Map type VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV> { + typedef VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV Type; +}; + +// Map type VkPartitionedAccelerationStructureFlagsNV to id VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV +template <> +struct LvlTypeMap<VkPartitionedAccelerationStructureFlagsNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV> { + typedef VkPartitionedAccelerationStructureFlagsNV Type; +}; + +// Map type VkWriteDescriptorSetPartitionedAccelerationStructureNV to id +// VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV +template <> +struct LvlTypeMap<VkWriteDescriptorSetPartitionedAccelerationStructureNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV> { + typedef VkWriteDescriptorSetPartitionedAccelerationStructureNV Type; +}; + +// Map type VkPartitionedAccelerationStructureInstancesInputNV to id +// VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV +template <> +struct LvlTypeMap<VkPartitionedAccelerationStructureInstancesInputNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV> { + typedef VkPartitionedAccelerationStructureInstancesInputNV Type; +}; + +// Map type VkBuildPartitionedAccelerationStructureInfoNV to id VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV +template <> +struct LvlTypeMap<VkBuildPartitionedAccelerationStructureInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV> { + typedef VkBuildPartitionedAccelerationStructureInfoNV Type; +}; + +// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT> { typedef VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT Type; }; -// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT> { +// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT> { typedef VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT Type; }; // Map type VkGeneratedCommandsMemoryRequirementsInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT -template <> struct LvlTypeMap<VkGeneratedCommandsMemoryRequirementsInfoEXT> { +template <> +struct LvlTypeMap<VkGeneratedCommandsMemoryRequirementsInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT> { typedef VkGeneratedCommandsMemoryRequirementsInfoEXT Type; }; // Map type VkIndirectExecutionSetPipelineInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT -template <> struct LvlTypeMap<VkIndirectExecutionSetPipelineInfoEXT> { +template <> +struct LvlTypeMap<VkIndirectExecutionSetPipelineInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT> { typedef VkIndirectExecutionSetPipelineInfoEXT Type; }; // Map type VkIndirectExecutionSetShaderLayoutInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT -template <> struct LvlTypeMap<VkIndirectExecutionSetShaderLayoutInfoEXT> { +template <> +struct LvlTypeMap<VkIndirectExecutionSetShaderLayoutInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT> { typedef VkIndirectExecutionSetShaderLayoutInfoEXT Type; }; // Map type VkIndirectExecutionSetShaderInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT -template <> struct LvlTypeMap<VkIndirectExecutionSetShaderInfoEXT> { +template <> +struct LvlTypeMap<VkIndirectExecutionSetShaderInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT> { typedef VkIndirectExecutionSetShaderInfoEXT Type; }; // Map type VkIndirectExecutionSetCreateInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkIndirectExecutionSetCreateInfoEXT> { +template <> +struct LvlTypeMap<VkIndirectExecutionSetCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT> { typedef VkIndirectExecutionSetCreateInfoEXT Type; }; // Map type VkGeneratedCommandsInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT -template <> struct LvlTypeMap<VkGeneratedCommandsInfoEXT> { +template <> +struct LvlTypeMap<VkGeneratedCommandsInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT> { typedef VkGeneratedCommandsInfoEXT Type; }; // Map type VkWriteIndirectExecutionSetPipelineEXT to id VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT -template <> struct LvlTypeMap<VkWriteIndirectExecutionSetPipelineEXT> { +template <> +struct LvlTypeMap<VkWriteIndirectExecutionSetPipelineEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT> { typedef VkWriteIndirectExecutionSetPipelineEXT Type; }; // Map type VkIndirectCommandsLayoutTokenEXT to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT -template <> struct LvlTypeMap<VkIndirectCommandsLayoutTokenEXT> { +template <> +struct LvlTypeMap<VkIndirectCommandsLayoutTokenEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT> { typedef VkIndirectCommandsLayoutTokenEXT Type; }; // Map type VkIndirectCommandsLayoutCreateInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkIndirectCommandsLayoutCreateInfoEXT> { +template <> +struct LvlTypeMap<VkIndirectCommandsLayoutCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT> { typedef VkIndirectCommandsLayoutCreateInfoEXT Type; }; // Map type VkGeneratedCommandsPipelineInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT -template <> struct LvlTypeMap<VkGeneratedCommandsPipelineInfoEXT> { +template <> +struct LvlTypeMap<VkGeneratedCommandsPipelineInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT> { typedef VkGeneratedCommandsPipelineInfoEXT Type; }; // Map type VkGeneratedCommandsShaderInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT -template <> struct LvlTypeMap<VkGeneratedCommandsShaderInfoEXT> { +template <> +struct LvlTypeMap<VkGeneratedCommandsShaderInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT> { typedef VkGeneratedCommandsShaderInfoEXT Type; }; // Map type VkWriteIndirectExecutionSetShaderEXT to id VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT -template <> struct LvlTypeMap<VkWriteIndirectExecutionSetShaderEXT> { +template <> +struct LvlTypeMap<VkWriteIndirectExecutionSetShaderEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT> { typedef VkWriteIndirectExecutionSetShaderEXT Type; }; -// Map type VkPhysicalDeviceImageAlignmentControlFeaturesMESA to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA -template <> struct LvlTypeMap<VkPhysicalDeviceImageAlignmentControlFeaturesMESA> { +// Map type VkPhysicalDeviceImageAlignmentControlFeaturesMESA to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA +template <> +struct LvlTypeMap<VkPhysicalDeviceImageAlignmentControlFeaturesMESA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA> { typedef VkPhysicalDeviceImageAlignmentControlFeaturesMESA Type; }; -// Map type VkPhysicalDeviceImageAlignmentControlPropertiesMESA to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA -template <> struct LvlTypeMap<VkPhysicalDeviceImageAlignmentControlPropertiesMESA> { +// Map type VkPhysicalDeviceImageAlignmentControlPropertiesMESA to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA +template <> +struct LvlTypeMap<VkPhysicalDeviceImageAlignmentControlPropertiesMESA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA> { typedef VkPhysicalDeviceImageAlignmentControlPropertiesMESA Type; }; // Map type VkImageAlignmentControlCreateInfoMESA to id VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA -template <> struct LvlTypeMap<VkImageAlignmentControlCreateInfoMESA> { +template <> +struct LvlTypeMap<VkImageAlignmentControlCreateInfoMESA> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA> { typedef VkImageAlignmentControlCreateInfoMESA Type; }; +// Map type VkPushConstantBankInfoNV to id VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV +template <> +struct LvlTypeMap<VkPushConstantBankInfoNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV> { + typedef VkPushConstantBankInfoNV Type; +}; + +// Map type VkPhysicalDevicePushConstantBankFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDevicePushConstantBankFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV> { + typedef VkPhysicalDevicePushConstantBankFeaturesNV Type; +}; + +// Map type VkPhysicalDevicePushConstantBankPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDevicePushConstantBankPropertiesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV> { + typedef VkPhysicalDevicePushConstantBankPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT> { + typedef VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT> { + typedef VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT Type; +}; + // Map type VkPhysicalDeviceDepthClampControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceDepthClampControlFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceDepthClampControlFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT> { typedef VkPhysicalDeviceDepthClampControlFeaturesEXT Type; }; -// Map type VkPipelineViewportDepthClampControlCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT -template <> struct LvlTypeMap<VkPipelineViewportDepthClampControlCreateInfoEXT> { +// Map type VkPipelineViewportDepthClampControlCreateInfoEXT to id +// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkPipelineViewportDepthClampControlCreateInfoEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT> { typedef VkPipelineViewportDepthClampControlCreateInfoEXT Type; }; +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkSurfaceCreateInfoOHOS to id VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS +template <> +struct LvlTypeMap<VkSurfaceCreateInfoOHOS> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS> { + typedef VkSurfaceCreateInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS // Map type VkPhysicalDeviceHdrVividFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI -template <> struct LvlTypeMap<VkPhysicalDeviceHdrVividFeaturesHUAWEI> { +template <> +struct LvlTypeMap<VkPhysicalDeviceHdrVividFeaturesHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI> { typedef VkPhysicalDeviceHdrVividFeaturesHUAWEI Type; }; // Map type VkHdrVividDynamicMetadataHUAWEI to id VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI -template <> struct LvlTypeMap<VkHdrVividDynamicMetadataHUAWEI> { +template <> +struct LvlTypeMap<VkHdrVividDynamicMetadataHUAWEI> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI> { typedef VkHdrVividDynamicMetadataHUAWEI Type; }; -// Map type VkCooperativeMatrixFlexibleDimensionsPropertiesNV to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV -template <> struct LvlTypeMap<VkCooperativeMatrixFlexibleDimensionsPropertiesNV> { +// Map type VkCooperativeMatrixFlexibleDimensionsPropertiesNV to id +// VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV +template <> +struct LvlTypeMap<VkCooperativeMatrixFlexibleDimensionsPropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV> { typedef VkCooperativeMatrixFlexibleDimensionsPropertiesNV Type; }; // Map type VkPhysicalDeviceCooperativeMatrix2FeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrix2FeaturesNV> { +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrix2FeaturesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV> { typedef VkPhysicalDeviceCooperativeMatrix2FeaturesNV Type; }; -// Map type VkPhysicalDeviceCooperativeMatrix2PropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV -template <> struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrix2PropertiesNV> { +// Map type VkPhysicalDeviceCooperativeMatrix2PropertiesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrix2PropertiesNV> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV> { typedef VkPhysicalDeviceCooperativeMatrix2PropertiesNV Type; }; -// Map type VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT> { +// Map type VkPhysicalDevicePipelineOpacityMicromapFeaturesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM> { + typedef VkPhysicalDevicePipelineOpacityMicromapFeaturesARM Type; +}; + +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkImportMemoryMetalHandleInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT +template <> +struct LvlTypeMap<VkImportMemoryMetalHandleInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT> { + typedef VkImportMemoryMetalHandleInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkMemoryMetalHandlePropertiesEXT to id VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkMemoryMetalHandlePropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT> { + typedef VkMemoryMetalHandlePropertiesEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkMemoryGetMetalHandleInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT +template <> +struct LvlTypeMap<VkMemoryGetMetalHandleInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT> { + typedef VkMemoryGetMetalHandleInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +// Map type VkPhysicalDevicePerformanceCountersByRegionFeaturesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDevicePerformanceCountersByRegionFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM> { + typedef VkPhysicalDevicePerformanceCountersByRegionFeaturesARM Type; +}; + +// Map type VkPhysicalDevicePerformanceCountersByRegionPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDevicePerformanceCountersByRegionPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM> { + typedef VkPhysicalDevicePerformanceCountersByRegionPropertiesARM Type; +}; + +// Map type VkPerformanceCounterARM to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM +template <> +struct LvlTypeMap<VkPerformanceCounterARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM> { + typedef VkPerformanceCounterARM Type; +}; + +// Map type VkPerformanceCounterDescriptionARM to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM +template <> +struct LvlTypeMap<VkPerformanceCounterDescriptionARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM> { + typedef VkPerformanceCounterDescriptionARM Type; +}; + +// Map type VkRenderPassPerformanceCountersByRegionBeginInfoARM to id +// VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM +template <> +struct LvlTypeMap<VkRenderPassPerformanceCountersByRegionBeginInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM> { + typedef VkRenderPassPerformanceCountersByRegionBeginInfoARM Type; +}; + +// Map type VkPhysicalDeviceShaderInstrumentationFeaturesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderInstrumentationFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM> { + typedef VkPhysicalDeviceShaderInstrumentationFeaturesARM Type; +}; + +// Map type VkPhysicalDeviceShaderInstrumentationPropertiesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderInstrumentationPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM> { + typedef VkPhysicalDeviceShaderInstrumentationPropertiesARM Type; +}; + +// Map type VkShaderInstrumentationCreateInfoARM to id VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkShaderInstrumentationCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM> { + typedef VkShaderInstrumentationCreateInfoARM Type; +}; + +// Map type VkShaderInstrumentationMetricDescriptionARM to id VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM +template <> +struct LvlTypeMap<VkShaderInstrumentationMetricDescriptionARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM> { + typedef VkShaderInstrumentationMetricDescriptionARM Type; +}; + +// Map type VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT> { typedef VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT Type; }; -// Map type VkAccelerationStructureGeometryTrianglesDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR -template <> struct LvlTypeMap<VkAccelerationStructureGeometryTrianglesDataKHR> { +// Map type VkPhysicalDeviceFormatPackFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceFormatPackFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM> { + typedef VkPhysicalDeviceFormatPackFeaturesARM Type; +}; + +// Map type VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE> { + typedef VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE Type; +}; + +// Map type VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE +template <> +struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE> { + typedef VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE Type; +}; + +// Map type VkPipelineFragmentDensityMapLayeredCreateInfoVALVE to id +// VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE +template <> +struct LvlTypeMap<VkPipelineFragmentDensityMapLayeredCreateInfoVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE> { + typedef VkPipelineFragmentDensityMapLayeredCreateInfoVALVE Type; +}; + +// Map type VkSetPresentConfigNV to id VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV +template <> +struct LvlTypeMap<VkSetPresentConfigNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV> { + typedef VkSetPresentConfigNV Type; +}; + +// Map type VkPhysicalDevicePresentMeteringFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDevicePresentMeteringFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV> { + typedef VkPhysicalDevicePresentMeteringFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT> { + typedef VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceShader64BitIndexingFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShader64BitIndexingFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT> { + typedef VkPhysicalDeviceShader64BitIndexingFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceCustomResolveFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceCustomResolveFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT> { + typedef VkPhysicalDeviceCustomResolveFeaturesEXT Type; +}; + +// Map type VkBeginCustomResolveInfoEXT to id VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT +template <> +struct LvlTypeMap<VkBeginCustomResolveInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT> { + typedef VkBeginCustomResolveInfoEXT Type; +}; + +// Map type VkCustomResolveCreateInfoEXT to id VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkCustomResolveCreateInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT> { + typedef VkCustomResolveCreateInfoEXT Type; +}; + +// Map type VkDataGraphPipelineBuiltinModelCreateInfoQCOM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM +template <> +struct LvlTypeMap<VkDataGraphPipelineBuiltinModelCreateInfoQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM> { + typedef VkDataGraphPipelineBuiltinModelCreateInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceDataGraphModelFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM +template <> +struct LvlTypeMap<VkPhysicalDeviceDataGraphModelFeaturesQCOM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM> { + typedef VkPhysicalDeviceDataGraphModelFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM> { + typedef VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM Type; +}; + +// Map type VkQueueFamilyDataGraphOpticalFlowPropertiesARM to id +// VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkQueueFamilyDataGraphOpticalFlowPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM> { + typedef VkQueueFamilyDataGraphOpticalFlowPropertiesARM Type; +}; + +// Map type VkDataGraphPipelineOpticalFlowCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineOpticalFlowCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineOpticalFlowCreateInfoARM Type; +}; + +// Map type VkDataGraphOpticalFlowImageFormatPropertiesARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM +template <> +struct LvlTypeMap<VkDataGraphOpticalFlowImageFormatPropertiesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM> { + typedef VkDataGraphOpticalFlowImageFormatPropertiesARM Type; +}; + +// Map type VkDataGraphOpticalFlowImageFormatInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphOpticalFlowImageFormatInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM> { + typedef VkDataGraphOpticalFlowImageFormatInfoARM Type; +}; + +// Map type VkDataGraphPipelineOpticalFlowDispatchInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineOpticalFlowDispatchInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM> { + typedef VkDataGraphPipelineOpticalFlowDispatchInfoARM Type; +}; + +// Map type VkDataGraphPipelineResourceInfoImageLayoutARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineResourceInfoImageLayoutARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM> { + typedef VkDataGraphPipelineResourceInfoImageLayoutARM Type; +}; + +// Map type VkDataGraphPipelineSingleNodeConnectionARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineSingleNodeConnectionARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM> { + typedef VkDataGraphPipelineSingleNodeConnectionARM Type; +}; + +// Map type VkDataGraphPipelineSingleNodeCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineSingleNodeCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineSingleNodeCreateInfoARM Type; +}; + +// Map type VkPhysicalDeviceShaderLongVectorFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderLongVectorFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT> { + typedef VkPhysicalDeviceShaderLongVectorFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceShaderLongVectorPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderLongVectorPropertiesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT> { + typedef VkPhysicalDeviceShaderLongVectorPropertiesEXT Type; +}; + +// Map type VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC> { + typedef VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC Type; +}; + +// Map type VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT> { + typedef VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT Type; +}; + +// Map type VkComputeOccupancyPriorityParametersNV to id VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV +template <> +struct LvlTypeMap<VkComputeOccupancyPriorityParametersNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV> { + typedef VkComputeOccupancyPriorityParametersNV Type; +}; + +// Map type VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV> { + typedef VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT> { + typedef VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT Type; +}; + +#ifdef VK_USE_PLATFORM_UBM_SEC +// Map type VkUbmSurfaceCreateInfoSEC to id VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC +template <> +struct LvlTypeMap<VkUbmSurfaceCreateInfoSEC> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC> { + typedef VkUbmSurfaceCreateInfoSEC Type; +}; + +#endif // VK_USE_PLATFORM_UBM_SEC +// Map type VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE +template <> +struct LvlTypeMap<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE> { + typedef VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE Type; +}; + +// Map type VkThrottleHintSubmitInfoSEC to id VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC +template <> +struct LvlTypeMap<VkThrottleHintSubmitInfoSEC> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC> { + typedef VkThrottleHintSubmitInfoSEC Type; +}; + +// Map type VkPhysicalDeviceThrottleHintFeaturesSEC to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC +template <> +struct LvlTypeMap<VkPhysicalDeviceThrottleHintFeaturesSEC> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC> { + typedef VkPhysicalDeviceThrottleHintFeaturesSEC Type; +}; + +// Map type VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM +template <> +struct LvlTypeMap<VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM> { + typedef VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM Type; +}; + +// Map type VkDataGraphPipelineNeuralStatisticsCreateInfoARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineNeuralStatisticsCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineNeuralStatisticsCreateInfoARM Type; +}; + +// Map type VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM to id +// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM +template <> +struct LvlTypeMap<VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM> { + typedef VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM Type; +}; + +// Map type VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT> { + typedef VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT Type; +}; + +// Map type VkAccelerationStructureGeometryTrianglesDataKHR to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR +template <> +struct LvlTypeMap<VkAccelerationStructureGeometryTrianglesDataKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR> { typedef VkAccelerationStructureGeometryTrianglesDataKHR Type; }; // Map type VkAccelerationStructureGeometryAabbsDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR -template <> struct LvlTypeMap<VkAccelerationStructureGeometryAabbsDataKHR> { +template <> +struct LvlTypeMap<VkAccelerationStructureGeometryAabbsDataKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR> { typedef VkAccelerationStructureGeometryAabbsDataKHR Type; }; -// Map type VkAccelerationStructureGeometryInstancesDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR -template <> struct LvlTypeMap<VkAccelerationStructureGeometryInstancesDataKHR> { +// Map type VkAccelerationStructureGeometryInstancesDataKHR to id +// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR +template <> +struct LvlTypeMap<VkAccelerationStructureGeometryInstancesDataKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR> { typedef VkAccelerationStructureGeometryInstancesDataKHR Type; }; // Map type VkAccelerationStructureGeometryKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR -template <> struct LvlTypeMap<VkAccelerationStructureGeometryKHR> { +template <> +struct LvlTypeMap<VkAccelerationStructureGeometryKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR> { typedef VkAccelerationStructureGeometryKHR Type; }; // Map type VkAccelerationStructureBuildGeometryInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR -template <> struct LvlTypeMap<VkAccelerationStructureBuildGeometryInfoKHR> { +template <> +struct LvlTypeMap<VkAccelerationStructureBuildGeometryInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR> { typedef VkAccelerationStructureBuildGeometryInfoKHR Type; }; // Map type VkAccelerationStructureCreateInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkAccelerationStructureCreateInfoKHR> { +template <> +struct LvlTypeMap<VkAccelerationStructureCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR> { typedef VkAccelerationStructureCreateInfoKHR Type; }; // Map type VkWriteDescriptorSetAccelerationStructureKHR to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR -template <> struct LvlTypeMap<VkWriteDescriptorSetAccelerationStructureKHR> { +template <> +struct LvlTypeMap<VkWriteDescriptorSetAccelerationStructureKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR> { typedef VkWriteDescriptorSetAccelerationStructureKHR Type; }; -// Map type VkPhysicalDeviceAccelerationStructureFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceAccelerationStructureFeaturesKHR> { +// Map type VkPhysicalDeviceAccelerationStructureFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceAccelerationStructureFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR> { typedef VkPhysicalDeviceAccelerationStructureFeaturesKHR Type; }; -// Map type VkPhysicalDeviceAccelerationStructurePropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceAccelerationStructurePropertiesKHR> { +// Map type VkPhysicalDeviceAccelerationStructurePropertiesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceAccelerationStructurePropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR> { typedef VkPhysicalDeviceAccelerationStructurePropertiesKHR Type; }; // Map type VkAccelerationStructureDeviceAddressInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR -template <> struct LvlTypeMap<VkAccelerationStructureDeviceAddressInfoKHR> { +template <> +struct LvlTypeMap<VkAccelerationStructureDeviceAddressInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR> { typedef VkAccelerationStructureDeviceAddressInfoKHR Type; }; // Map type VkAccelerationStructureVersionInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR -template <> struct LvlTypeMap<VkAccelerationStructureVersionInfoKHR> { +template <> +struct LvlTypeMap<VkAccelerationStructureVersionInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR> { typedef VkAccelerationStructureVersionInfoKHR Type; }; // Map type VkCopyAccelerationStructureToMemoryInfoKHR to id VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR -template <> struct LvlTypeMap<VkCopyAccelerationStructureToMemoryInfoKHR> { +template <> +struct LvlTypeMap<VkCopyAccelerationStructureToMemoryInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR> { typedef VkCopyAccelerationStructureToMemoryInfoKHR Type; }; // Map type VkCopyMemoryToAccelerationStructureInfoKHR to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR -template <> struct LvlTypeMap<VkCopyMemoryToAccelerationStructureInfoKHR> { +template <> +struct LvlTypeMap<VkCopyMemoryToAccelerationStructureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR> { typedef VkCopyMemoryToAccelerationStructureInfoKHR Type; }; // Map type VkCopyAccelerationStructureInfoKHR to id VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR -template <> struct LvlTypeMap<VkCopyAccelerationStructureInfoKHR> { +template <> +struct LvlTypeMap<VkCopyAccelerationStructureInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR> { typedef VkCopyAccelerationStructureInfoKHR Type; }; -// Map type VkAccelerationStructureBuildSizesInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR -template <> struct LvlTypeMap<VkAccelerationStructureBuildSizesInfoKHR> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; -}; - -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR> { - typedef VkAccelerationStructureBuildSizesInfoKHR Type; -}; - // Map type VkRayTracingShaderGroupCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkRayTracingShaderGroupCreateInfoKHR> { +template <> +struct LvlTypeMap<VkRayTracingShaderGroupCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR> { typedef VkRayTracingShaderGroupCreateInfoKHR Type; }; // Map type VkRayTracingPipelineInterfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkRayTracingPipelineInterfaceCreateInfoKHR> { +template <> +struct LvlTypeMap<VkRayTracingPipelineInterfaceCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR> { typedef VkRayTracingPipelineInterfaceCreateInfoKHR Type; }; // Map type VkRayTracingPipelineCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR -template <> struct LvlTypeMap<VkRayTracingPipelineCreateInfoKHR> { +template <> +struct LvlTypeMap<VkRayTracingPipelineCreateInfoKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR> { typedef VkRayTracingPipelineCreateInfoKHR Type; }; // Map type VkPhysicalDeviceRayTracingPipelineFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingPipelineFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingPipelineFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR> { typedef VkPhysicalDeviceRayTracingPipelineFeaturesKHR Type; }; -// Map type VkPhysicalDeviceRayTracingPipelinePropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceRayTracingPipelinePropertiesKHR> { +// Map type VkPhysicalDeviceRayTracingPipelinePropertiesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR +template <> +struct LvlTypeMap<VkPhysicalDeviceRayTracingPipelinePropertiesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR> { typedef VkPhysicalDeviceRayTracingPipelinePropertiesKHR Type; }; // Map type VkPhysicalDeviceRayQueryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR -template <> struct LvlTypeMap<VkPhysicalDeviceRayQueryFeaturesKHR> { +template <> +struct LvlTypeMap<VkPhysicalDeviceRayQueryFeaturesKHR> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR> { typedef VkPhysicalDeviceRayQueryFeaturesKHR Type; }; // Map type VkPhysicalDeviceMeshShaderFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMeshShaderFeaturesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMeshShaderFeaturesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT> { typedef VkPhysicalDeviceMeshShaderFeaturesEXT Type; }; // Map type VkPhysicalDeviceMeshShaderPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT -template <> struct LvlTypeMap<VkPhysicalDeviceMeshShaderPropertiesEXT> { +template <> +struct LvlTypeMap<VkPhysicalDeviceMeshShaderPropertiesEXT> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT> { +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT> { typedef VkPhysicalDeviceMeshShaderPropertiesEXT Type; }; // Header "base class" for pNext chain traversal struct LvlGenericHeader { - VkStructureType sType; - const LvlGenericHeader *pNext; + VkStructureType sType; + const LvlGenericHeader* pNext; }; struct LvlGenericModHeader { - VkStructureType sType; - LvlGenericModHeader *pNext; + VkStructureType sType; + LvlGenericModHeader* pNext; }; // Find an entry of the given type in the pNext chain -template <typename T> const T *lvl_find_in_chain(const void *next) { - const LvlGenericHeader *current = reinterpret_cast<const LvlGenericHeader *>(next); - const T *found = nullptr; +template <typename T> +const T* lvl_find_in_chain(const void* next) { + const LvlGenericHeader* current = reinterpret_cast<const LvlGenericHeader*>(next); + const T* found = nullptr; while (current) { if (LvlTypeMap<T>::kSType == current->sType) { found = reinterpret_cast<const T*>(current); @@ -8944,9 +13879,10 @@ return found; } // Find an entry of the given type in the pNext chain -template <typename T> T *lvl_find_mod_in_chain(void *next) { - LvlGenericModHeader *current = reinterpret_cast<LvlGenericModHeader *>(next); - T *found = nullptr; +template <typename T> +T* lvl_find_mod_in_chain(void* next) { + LvlGenericModHeader* current = reinterpret_cast<LvlGenericModHeader*>(next); + T* found = nullptr; while (current) { if (LvlTypeMap<T>::kSType == current->sType) { found = reinterpret_cast<T*>(current); @@ -8959,7 +13895,8 @@ } // Init the header of an sType struct with pNext -template <typename T> T lvl_init_struct(void *p_next) { +template <typename T> +T lvl_init_struct(void* p_next) { T out = {}; out.sType = LvlTypeMap<T>::kSType; out.pNext = p_next; @@ -8967,9 +13904,9 @@ } // Init the header of an sType struct -template <typename T> T lvl_init_struct() { +template <typename T> +T lvl_init_struct() { T out = {}; out.sType = LvlTypeMap<T>::kSType; return out; } -
diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt index 5fbe702..65c8bad 100644 --- a/scripts/CMakeLists.txt +++ b/scripts/CMakeLists.txt
@@ -121,9 +121,6 @@ if (VULKAN_HEADERS_INSTALL_DIR) list(APPEND CMAKE_PREFIX_PATH ${VULKAN_HEADERS_INSTALL_DIR}) endif() -if (VOLK_INSTALL_DIR) - list(APPEND CMAKE_PREFIX_PATH ${VOLK_INSTALL_DIR}) -endif() if (GOOGLETEST_INSTALL_DIR) list(APPEND CMAKE_PREFIX_PATH ${GOOGLETEST_INSTALL_DIR}) endif()
diff --git a/scripts/common_codegen.py b/scripts/common_codegen.py index 9539db2..d44cd64 100644 --- a/scripts/common_codegen.py +++ b/scripts/common_codegen.py
@@ -19,6 +19,8 @@ # Author: Mark Lobodzinski <mark@lunarg.com> import os +import sys +import subprocess # Copyright text prefixing all headers (list of strings). prefixStrings = [ @@ -61,6 +63,7 @@ 'directfb' : 'VK_USE_PLATFORM_DIRECTFB_EXT', 'screen' : 'VK_USE_PLATFORM_SCREEN_QNX', 'sci' : 'VK_USE_PLATFORM_SCI', + 'ohos' : 'VK_USE_PLATFORM_OHOS', } # @@ -68,11 +71,44 @@ def GetFeatureProtect(interface): """Get platform protection string""" platform = interface.get('platform') - protect = None if platform is not None: - protect = platform_dict[platform] - return protect + return platform_dict[platform] + + provisional = interface.get('provisional') + if provisional == 'true': + return platform_dict['provisional'] + +# Returns true if we are running in GitHub actions +# https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables +def IsGHA(): + if 'GITHUB_ACTION' in os.environ: + return True + return False + +# Points to the directory containing the top level CMakeLists.txt +PROJECT_SRC_DIR = os.path.abspath(os.path.join(os.path.split(os.path.abspath(__file__))[0], '..')) +if not os.path.isfile(f'{PROJECT_SRC_DIR}/CMakeLists.txt'): + print(f'PROJECT_SRC_DIR invalid! {PROJECT_SRC_DIR}') + sys.exit(1) # helper to define paths relative to the repo root -def repo_relative(path): +def RepoRelative(path): return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path)) + +# Runs a command in a directory and returns its return code. +# Directory is project root by default, or a relative path from project root +def RunShellCmd(command, start_dir = PROJECT_SRC_DIR, env=None, verbose=False): + # Flush stdout here. Helps when debugging on CI. + sys.stdout.flush() + + if start_dir != PROJECT_SRC_DIR: + start_dir = RepoRelative(start_dir) + cmd_list = command.split(" ") + + # Helps a lot when debugging CI issues + if IsGHA(): + verbose = True + + if verbose: + print(f'CICMD({cmd_list}, env={env})') + subprocess.check_call(cmd_list, cwd=start_dir, env=env) \ No newline at end of file
diff --git a/scripts/generate_source.py b/scripts/generate_source.py index 70e138d..5931453 100755 --- a/scripts/generate_source.py +++ b/scripts/generate_source.py
@@ -1,8 +1,9 @@ #!/usr/bin/env python3 -# Copyright (c) 2019-2023 The Khronos Group Inc. -# Copyright (c) 2019-2023 Valve Corporation -# Copyright (c) 2019-2023 LunarG, Inc. -# Copyright (c) 2019-2023 Google Inc. +# Copyright (c) 2019 The Khronos Group Inc. +# Copyright (c) 2019 Valve Corporation +# Copyright (c) 2019 LunarG, Inc. +# Copyright (c) 2019 Google Inc. +# Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # Copyright (c) 2023-2023 RasterGrid Kft. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -22,117 +23,218 @@ import argparse import filecmp import os -import json import shutil -import subprocess import sys +import re import tempfile - +import json import common_codegen -# files to exclude from --verify check -verify_exclude = ['.clang-format'] +from xml.etree import ElementTree + +# Because we have special logic to import the Registry from input arguments and the BaseGenerator comes from the registry, we have to delay defining it until *after* +# the Registry has been imported. Yes this is awkward, but it was the least awkward way to make --verify work. +generators = {} + +def RunGenerators(api: str, registry: str, video_registry: str, directory: str, styleFile: str, targetFilter: str, flatOutput: bool): + + try: + common_codegen.RunShellCmd(f'clang-format --version') + has_clang_format = True + except: + has_clang_format = False + if not has_clang_format: + print("WARNING: Unable to find clang-format!") + + # These live in the Vulkan-Docs repo, but are pulled in via the + # Vulkan-Headers/registry folder + # At runtime we inject python path to find these helper scripts + scripts = os.path.dirname(registry) + scripts_directory_path = os.path.dirname(os.path.abspath(__file__)) + registry_headers_path = os.path.join(scripts_directory_path, scripts) + sys.path.insert(0, registry_headers_path) + try: + from reg import Registry + except: + print("ModuleNotFoundError: No module named 'reg'") # normal python error message + print(f'{registry_headers_path} is not pointing to the Vulkan-Headers registry directory.') + print("Inside Vulkan-Headers there is a registry/reg.py file that is used.") + sys.exit(1) # Return without call stack so easy to spot error + + from base_generator import BaseGeneratorOptions + from generators.mock_icd_generator import MockICDOutputGenerator + from generators.vulkan_tools_helper_file_generator import HelperFileOutputGenerator + from generators.vulkaninfo_generator import VulkanInfoGenerator + + # These set fields that are needed by both OutputGenerator and BaseGenerator, + # but are uniform and don't need to be set at a per-generated file level + from base_generator import (SetTargetApiName, SetMergedApiNames) + SetTargetApiName(api) + + # Generated directory and dispatch table helper file name may be API specific (e.g. Vulkan SC) + mock_icd_generated_directory = 'icd/generated' + vulkaninfo_generated_directory = 'vulkaninfo/generated' + + generators.update({ + 'vk_typemap_helper.h': { + 'generator' : HelperFileOutputGenerator, + 'genCombined': False, + 'directory' : mock_icd_generated_directory, + }, + 'function_declarations.h': { + 'generator' : MockICDOutputGenerator, + 'genCombined': False, + 'directory' : mock_icd_generated_directory, + }, + 'function_definitions.h': { + 'generator' : MockICDOutputGenerator, + 'genCombined': False, + 'directory' : mock_icd_generated_directory, + }, + 'vulkaninfo.hpp': { + 'generator' : VulkanInfoGenerator, + 'genCombined': False, + 'directory' : vulkaninfo_generated_directory, + }, + }) + + unknownTargets = [x for x in (targetFilter if targetFilter else []) if x not in generators.keys()] + if unknownTargets: + print(f'ERROR: No generator options for unknown target(s): {", ".join(unknownTargets)}', file=sys.stderr) + return 1 + + # Filter if --target is passed in + targets = [x for x in generators.keys() if not targetFilter or x in targetFilter] + + for index, target in enumerate(targets, start=1): + print(f'[{index}|{len(targets)}] Generating {target}') + + # First grab a class constructor object and create an instance + generator = generators[target]['generator'] + gen = generator() + + # This code and the 'genCombined' generator metadata is used by downstream + # users to generate code with all Vulkan APIs merged into the target API variant + # (e.g. Vulkan SC) when needed. The constructed apiList is also used to filter + # out non-applicable extensions later below. + apiList = [api] + if api != 'vulkan' and generators[target]['genCombined']: + SetMergedApiNames('vulkan') + apiList.append('vulkan') + else: + SetMergedApiNames(None) + + # For people who want to generate all the files in a single director + if flatOutput: + outDirectory = os.path.abspath(os.path.join(directory)) + else: + outDirectory = os.path.abspath(os.path.join(directory, generators[target]['directory'])) + + options = BaseGeneratorOptions( + customFileName = target, + customDirectory = outDirectory) + + if not os.path.exists(outDirectory): + os.makedirs(outDirectory) + + # Create the registry object with the specified generator and generator + # options. The options are set before XML loading as they may affect it. + reg = Registry(gen, options) + + # Parse the specified registry XML into an ElementTree object + tree = ElementTree.parse(registry) + + # Load the XML tree into the registry object + reg.loadElementTree(tree) + + # Set the path to the video registry so that videoStd is available + reg.genOpts.videoXmlPath = video_registry + + # Finally, use the output generator to create the requested target + reg.apiGen() + + # Run clang-format on the file + if has_clang_format and styleFile: + common_codegen.RunShellCmd(f'clang-format -i --style=file:{styleFile} {os.path.join(outDirectory, target)}') + def main(argv): + + # files to exclude from --verify check + verify_exclude = ['.clang-format'] # None currently + parser = argparse.ArgumentParser(description='Generate source code for this repository') + parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory') parser.add_argument('--api', default='vulkan', choices=['vulkan', 'vulkansc'], help='Specify API name to generate') parser.add_argument('--generated-version', help='sets the header version used to generate the repo') - parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory') group = parser.add_mutually_exclusive_group() + group.add_argument('--target', nargs='+', help='only generate file names passed in') group.add_argument('-i', '--incremental', action='store_true', help='only update repo files that change') group.add_argument('-v', '--verify', action='store_true', help='verify repo files match generator output') + group.add_argument('-o', action='store', dest='directory', help='Create target and related files in specified directory') args = parser.parse_args(argv) - # output paths and the list of files in the path - files_to_gen = {str(os.path.join('icd','generated')) : ['vk_typemap_helper.h', - 'function_definitions.h', - 'function_declarations.h'], - str(os.path.join('vulkaninfo','generated')): ['vulkaninfo.hpp']} - - #base directory for the source repository - repo_dir = common_codegen.repo_relative('') - - # Update the api_version in the respective json files - if args.generated_version: - json_files = [] - json_files.append(common_codegen.repo_relative('icd/VkICD_mock_icd.json.in')) - for json_file in json_files: - with open(json_file) as f: - data = json.load(f) - - data["ICD"]["api_version"] = args.generated_version - - with open(json_file, mode='w', encoding='utf-8', newline='\n') as f: - f.write(json.dumps(data, indent=4)) - - # get directory where generators will run if needed - if args.verify or args.incremental: - # generate in temp directory so we can compare or copy later - temp_obj = tempfile.TemporaryDirectory(prefix='VulkanLoader_generated_source_') - temp_dir = temp_obj.name - for path in files_to_gen.keys(): - os.makedirs(os.path.join(temp_dir, path)) + repo_dir = common_codegen.RepoRelative('.') registry = os.path.abspath(os.path.join(args.registry, 'vk.xml')) - if not os.path.isfile(registry): + video_registry = os.path.abspath(os.path.join(args.registry, 'video.xml')) + if not os.path.isfile(registry) and not os.path.isfile(registry): registry = os.path.abspath(os.path.join(args.registry, 'Vulkan-Headers/registry/vk.xml')) if not os.path.isfile(registry): print(f'cannot find vk.xml in {args.registry}') return -1 + video_registry = os.path.abspath(os.path.join(args.registry, 'Vulkan-Headers/registry/video.xml')) + if not os.path.isfile(video_registry): + print(f'{video_registry} does not exist') + return -1 - # run each code generator - for path, filenames in files_to_gen.items(): - for filename in filenames: - if args.verify or args.incremental: - output_path = os.path.join(temp_dir, path) - else: - output_path = common_codegen.repo_relative(path) + # Need pass style file incase running with --verify and it can't find the file automatically in the temp directory + style_file = os.path.join(repo_dir, '.clang-format') - cmd = [common_codegen.repo_relative(os.path.join('scripts','kvt_genvk.py')), - '-api', args.api, - '-registry', registry, - '-quiet', '-directory', output_path, filename] - print(' '.join(cmd)) - try: - if args.verify or args.incremental: - subprocess.check_call([sys.executable] + cmd, cwd=temp_dir) - else: - subprocess.check_call([sys.executable] + cmd, cwd=repo_dir) + # get directory where generators will run + if args.verify or args.incremental: + # generate in temp directory so we can compare or copy later + temp_obj = tempfile.TemporaryDirectory(prefix='vulkan_tools_codegen_') + temp_dir = temp_obj.name + gen_dir = temp_dir + elif args.directory: + gen_dir = args.directory + else: + # generate directly in the repo + gen_dir = repo_dir - except Exception as e: - print('ERROR:', str(e)) - return 1 + RunGenerators(api=args.api,registry=registry, video_registry=video_registry, directory=gen_dir, styleFile=style_file, targetFilter=args.target, flatOutput=False) # optional post-generation steps if args.verify: # compare contents of temp dir and repo temp_files = {} - for path in files_to_gen.keys(): - temp_files[path] = set() - temp_files[path].update(set(os.listdir(os.path.join(temp_dir, path)))) - repo_files = {} - for path in files_to_gen.keys(): - repo_files[path] = set() - repo_files[path].update(set(os.listdir(os.path.join(repo_dir, path))) - set(verify_exclude)) + for details in generators.values(): + if details['directory'] not in temp_files: + temp_files[details['directory']] = set() + temp_files[details['directory']].update(set(os.listdir(os.path.join(temp_dir, details['directory'])))) + if details['directory'] not in repo_files: + repo_files[details['directory']] = set() + repo_files[details['directory']].update(set(os.listdir(os.path.join(repo_dir, details['directory']))) - set(verify_exclude)) + # compare contents of temp dir and repo files_match = True - for path in files_to_gen.keys(): - for filename in sorted((temp_files[path] | repo_files[path])): - if filename not in repo_files[path]: - print('ERROR: Missing repo file', filename) - files_match = False - elif filename not in temp_files[path]: - print('ERROR: Missing generator for', filename) - files_match = False - elif not filecmp.cmp(os.path.join(temp_dir, path, filename), - os.path.join(repo_dir, path, filename), - shallow=False): - print('ERROR: Repo files do not match generator output for', filename) - files_match = False + for filename, details in generators.items(): + if filename not in repo_files[details['directory']]: + print('ERROR: Missing repo file', filename) + files_match = False + elif filename not in temp_files[details['directory']]: + print('ERROR: Missing generator for', filename) + files_match = False + elif not filecmp.cmp(os.path.join(temp_dir, details['directory'], filename), + os.path.join(repo_dir, details['directory'], filename), + shallow=False): + print('ERROR: Repo files do not match generator output for', filename) + files_match = False # return code for test scripts if files_match: @@ -142,14 +244,33 @@ elif args.incremental: # copy missing or differing files from temp directory to repo - for path in files_to_gen.keys(): - for filename in os.listdir(os.path.join(temp_dir,path)): - temp_filename = os.path.join(temp_dir, path, filename) - repo_filename = os.path.join(repo_dir, path, filename) - if not os.path.exists(repo_filename) or \ - not filecmp.cmp(temp_filename, repo_filename, shallow=False): - print('update', repo_filename) - shutil.copyfile(temp_filename, repo_filename) + for filename, details in generators.items(): + temp_filename = os.path.join(temp_dir, details['directory'], filename) + repo_filename = os.path.join(repo_dir, details['directory'], filename) + if not os.path.exists(repo_filename) or \ + not filecmp.cmp(temp_filename, repo_filename, shallow=False): + print('update', repo_filename) + shutil.copyfile(temp_filename, repo_filename) + + # write out the header version used to generate the code to a checked in CMake file + if args.generated_version: + json_files = [] + json_files.append(common_codegen.RepoRelative('icd/VkICD_mock_icd.json.in')) + for json_file in json_files: + with open(json_file) as f: + data = json.load(f) + + data["ICD"]["api_version"] = args.generated_version + + with open(json_file, mode='w', encoding='utf-8', newline='\n') as f: + f.write(json.dumps(data, indent=4)) + + # Update the CMake project version + with open(common_codegen.RepoRelative('CMakeLists.txt'), "r+") as f: + data = f.read() + f.seek(0) + f.write(re.sub("project.*VERSION.*", f"project(Vulkan-Tools VERSION {args.generated_version})", data)) + f.truncate() return 0
diff --git a/scripts/generators/mock_icd_generator.py b/scripts/generators/mock_icd_generator.py new file mode 100644 index 0000000..b1d81c4 --- /dev/null +++ b/scripts/generators/mock_icd_generator.py
@@ -0,0 +1,1452 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2015-2025 The Khronos Group Inc. +# Copyright (c) 2015-2025 Valve Corporation +# Copyright (c) 2015-2025 LunarG, Inc. +# Copyright (c) 2015-2025 Google Inc. +# Copyright (c) 2023-2025 RasterGrid Kft. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Author: Tobin Ehlis <tobine@google.com> +# +# This script generates a Mock ICD that intercepts almost all Vulkan +# functions. That layer is not intended to be useful or even compilable +# in its initial state. Rather it's intended to be a starting point that +# can be copied and customized to assist in creation of a new layer. + +from base_generator import BaseGenerator + +CUSTOM_C_INTERCEPTS = { +'vkCreateInstance': ''' + // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with + // apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the + // ICD should behave as normal. + if (loader_interface_version <= 4) { + return VK_ERROR_INCOMPATIBLE_DRIVER; + } + *pInstance = (VkInstance)CreateDispObjHandle(); + for (auto& physical_device : physical_device_map[*pInstance]) + physical_device = (VkPhysicalDevice)CreateDispObjHandle(); + // TODO: If emulating specific device caps, will need to add intelligence here + return VK_SUCCESS; +''', +'vkDestroyInstance': ''' + if (instance) { + for (const auto physical_device : physical_device_map.at(instance)) { + display_map.erase(physical_device); + DestroyDispObjHandle((void*)physical_device); + } + physical_device_map.erase(instance); + DestroyDispObjHandle((void*)instance); + } +''', +'vkAllocateCommandBuffers': ''' + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) { + pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle(); + command_pool_buffer_map[pAllocateInfo->commandPool].push_back(pCommandBuffers[i]); + } + return VK_SUCCESS; +''', +'vkFreeCommandBuffers': ''' + unique_lock_t lock(global_lock); + for (auto i = 0u; i < commandBufferCount; ++i) { + if (!pCommandBuffers[i]) { + continue; + } + + for (auto& pair : command_pool_buffer_map) { + auto& cbs = pair.second; + auto it = std::find(cbs.begin(), cbs.end(), pCommandBuffers[i]); + if (it != cbs.end()) { + cbs.erase(it); + } + } + + DestroyDispObjHandle((void*) pCommandBuffers[i]); + } +''', +'vkCreateCommandPool': ''' + unique_lock_t lock(global_lock); + *pCommandPool = (VkCommandPool)global_unique_handle++; + command_pool_map[device].insert(*pCommandPool); + return VK_SUCCESS; +''', +'vkDestroyCommandPool': ''' + // destroy command buffers for this pool + unique_lock_t lock(global_lock); + auto it = command_pool_buffer_map.find(commandPool); + if (it != command_pool_buffer_map.end()) { + for (auto& cb : it->second) { + DestroyDispObjHandle((void*) cb); + } + command_pool_buffer_map.erase(it); + } + command_pool_map[device].erase(commandPool); +''', +'vkEnumeratePhysicalDevices': ''' + VkResult result_code = VK_SUCCESS; + if (pPhysicalDevices) { + const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count); + for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i]; + if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE; + *pPhysicalDeviceCount = return_count; + } else { + *pPhysicalDeviceCount = icd_physical_device_count; + } + return result_code; +''', +'vkCreateDevice': ''' + *pDevice = (VkDevice)CreateDispObjHandle(); + // TODO: If emulating specific device caps, will need to add intelligence here + return VK_SUCCESS; +''', +'vkDestroyDevice': ''' + unique_lock_t lock(global_lock); + // First destroy sub-device objects + // Destroy Queues + for (auto queue_family_map_pair : queue_map[device]) { + for (auto index_queue_pair : queue_map[device][queue_family_map_pair.first]) { + DestroyDispObjHandle((void*)index_queue_pair.second); + } + } + + for (auto& cp : command_pool_map[device]) { + for (auto& cb : command_pool_buffer_map[cp]) { + DestroyDispObjHandle((void*) cb); + } + command_pool_buffer_map.erase(cp); + } + command_pool_map[device].clear(); + + queue_map.erase(device); + buffer_map.erase(device); + image_memory_size_map.erase(device); + // Now destroy device + DestroyDispObjHandle((void*)device); + // TODO: If emulating specific device caps, will need to add intelligence here +''', +'vkGetDeviceQueue': ''' + unique_lock_t lock(global_lock); + auto queue = queue_map[device][queueFamilyIndex][queueIndex]; + if (queue) { + *pQueue = queue; + } else { + *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle(); + } + // TODO: If emulating specific device caps, will need to add intelligence here + return; +''', +'vkGetDeviceQueue2': ''' + GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); + // TODO: Add further support for GetDeviceQueue2 features +''', +'vkEnumerateInstanceLayerProperties': ''' + return VK_SUCCESS; +''', +'vkEnumerateInstanceVersion': ''' + *pApiVersion = VK_HEADER_VERSION_COMPLETE; + return VK_SUCCESS; +''', +'vkEnumerateDeviceLayerProperties': ''' + return VK_SUCCESS; +''', +'vkEnumerateInstanceExtensionProperties': ''' + // If requesting number of extensions, return that + if (!pLayerName) { + if (!pProperties) { + *pPropertyCount = (uint32_t)instance_extension_map.size(); + } else { + uint32_t i = 0; + for (const auto &name_ver_pair : instance_extension_map) { + if (i == *pPropertyCount) { + break; + } + std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); + pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; + pProperties[i].specVersion = name_ver_pair.second; + ++i; + } + if (i != instance_extension_map.size()) { + return VK_INCOMPLETE; + } + } + } + // If requesting extension properties, fill in data struct for number of extensions + return VK_SUCCESS; +''', +'vkEnumerateDeviceExtensionProperties': ''' + // If requesting number of extensions, return that + if (!pLayerName) { + if (!pProperties) { + *pPropertyCount = (uint32_t)device_extension_map.size(); + } else { + uint32_t i = 0; + for (const auto &name_ver_pair : device_extension_map) { + if (i == *pPropertyCount) { + break; + } + std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); + pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; + pProperties[i].specVersion = name_ver_pair.second; + ++i; + } + *pPropertyCount = i; + if (i != device_extension_map.size()) { + return VK_INCOMPLETE; + } + } + } + // If requesting extension properties, fill in data struct for number of extensions + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceSurfacePresentModesKHR': ''' + // Currently always say that all present modes are supported + if (!pPresentModes) { + *pPresentModeCount = 6; + } else { + if (*pPresentModeCount >= 6) pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR; + if (*pPresentModeCount >= 5) pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR; + if (*pPresentModeCount >= 4) pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR; + if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR; + if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR; + if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR; + *pPresentModeCount = *pPresentModeCount < 6 ? *pPresentModeCount : 6; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceSurfaceFormatsKHR': ''' + // Currently always say that RGBA8 & BGRA8 are supported + if (!pSurfaceFormats) { + *pSurfaceFormatCount = 2; + } else { + if (*pSurfaceFormatCount >= 2) { + pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM; + pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + if (*pSurfaceFormatCount >= 1) { + pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM; + pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceSurfaceFormats2KHR': ''' + // Currently always say that RGBA8 & BGRA8 are supported + if (!pSurfaceFormats) { + *pSurfaceFormatCount = 2; + } else { + if (*pSurfaceFormatCount >= 2) { + pSurfaceFormats[1].pNext = nullptr; + pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM; + pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + if (*pSurfaceFormatCount >= 1) { + pSurfaceFormats[1].pNext = nullptr; + pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM; + pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceSurfaceSupportKHR': ''' + // Currently say that all surface/queue combos are supported + *pSupported = VK_TRUE; + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceSurfaceCapabilitiesKHR': ''' + // In general just say max supported is available for requested surface + pSurfaceCapabilities->minImageCount = 1; + pSurfaceCapabilities->maxImageCount = 0; + pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF; + pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF; + pSurfaceCapabilities->minImageExtent.width = 1; + pSurfaceCapabilities->minImageExtent.height = 1; + pSurfaceCapabilities->maxImageExtent.width = 0xFFFF; + pSurfaceCapabilities->maxImageExtent.height = 0xFFFF; + pSurfaceCapabilities->maxImageArrayLayers = 128; + pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR | + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR | + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; + pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR | + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR | + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; + pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | + VK_IMAGE_USAGE_TRANSFER_DST_BIT | + VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_STORAGE_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceSurfaceCapabilities2KHR': ''' + GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities); + + auto *present_mode_compatibility = lvl_find_mod_in_chain<VkSurfacePresentModeCompatibilityEXT>(pSurfaceCapabilities->pNext); + if (present_mode_compatibility) { + if (!present_mode_compatibility->pPresentModes) { + present_mode_compatibility->presentModeCount = 3; + } else { + // arbitrary + present_mode_compatibility->pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR; + present_mode_compatibility->pPresentModes[1] = VK_PRESENT_MODE_FIFO_KHR; + present_mode_compatibility->pPresentModes[2] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR; + } + } + return VK_SUCCESS; +''', +'vkGetInstanceProcAddr': ''' + if (!negotiate_loader_icd_interface_called) { + loader_interface_version = 0; + } + const auto &item = name_to_funcptr_map.find(pName); + if (item != name_to_funcptr_map.end()) { + return reinterpret_cast<PFN_vkVoidFunction>(item->second); + } + // Mock should intercept all functions so if we get here just return null + return nullptr; +''', +'vkGetDeviceProcAddr': ''' + return GetInstanceProcAddr(nullptr, pName); +''', +'vkGetPhysicalDeviceMemoryProperties': ''' + pMemoryProperties->memoryTypeCount = 6; + // Host visible Coherent + pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + pMemoryProperties->memoryTypes[0].heapIndex = 0; + // Host visible Cached + pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; + pMemoryProperties->memoryTypes[1].heapIndex = 0; + // Device local and Host visible + pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + pMemoryProperties->memoryTypes[2].heapIndex = 1; + // Device local lazily + pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; + pMemoryProperties->memoryTypes[3].heapIndex = 1; + // Device local protected + pMemoryProperties->memoryTypes[4].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_PROTECTED_BIT; + pMemoryProperties->memoryTypes[4].heapIndex = 1; + // Device local only + pMemoryProperties->memoryTypes[5].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + pMemoryProperties->memoryTypes[5].heapIndex = 1; + pMemoryProperties->memoryHeapCount = 2; + pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT; + pMemoryProperties->memoryHeaps[0].size = 8000000000; + pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; + pMemoryProperties->memoryHeaps[1].size = 8000000000; +''', +'vkGetPhysicalDeviceMemoryProperties2KHR': ''' + GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties); +''', +'vkGetPhysicalDeviceQueueFamilyProperties': ''' + if (pQueueFamilyProperties) { + std::vector<VkQueueFamilyProperties2KHR> props2(*pQueueFamilyPropertyCount, { + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR}); + GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, props2.data()); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) { + pQueueFamilyProperties[i] = props2[i].queueFamilyProperties; + } + } else { + GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, nullptr); + } +''', +'vkGetPhysicalDeviceQueueFamilyProperties2KHR': ''' + if (pQueueFamilyProperties) { + if (*pQueueFamilyPropertyCount >= 1) { + auto props = &pQueueFamilyProperties[0].queueFamilyProperties; + props->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT + | VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_PROTECTED_BIT; + props->queueCount = 1; + props->timestampValidBits = 16; + props->minImageTransferGranularity = {1,1,1}; + } + if (*pQueueFamilyPropertyCount >= 2) { + auto props = &pQueueFamilyProperties[1].queueFamilyProperties; + props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_DECODE_BIT_KHR; + props->queueCount = 1; + props->timestampValidBits = 16; + props->minImageTransferGranularity = {1,1,1}; + + auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[1].pNext); + if (status_query_props) { + status_query_props->queryResultStatusSupport = VK_TRUE; + } + auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[1].pNext); + if (video_props) { + video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR + | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR + | VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR; + } + } + if (*pQueueFamilyPropertyCount >= 3) { + auto props = &pQueueFamilyProperties[2].queueFamilyProperties; + props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_ENCODE_BIT_KHR; + props->queueCount = 1; + props->timestampValidBits = 16; + props->minImageTransferGranularity = {1,1,1}; + + auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[2].pNext); + if (status_query_props) { + status_query_props->queryResultStatusSupport = VK_TRUE; + } + auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[2].pNext); + if (video_props) { + video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR + | VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR + | VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR; + } + } + if (*pQueueFamilyPropertyCount > 3) { + *pQueueFamilyPropertyCount = 3; + } + } else { + *pQueueFamilyPropertyCount = 3; + } +''', +'vkGetPhysicalDeviceFeatures': ''' + uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); + VkBool32 *bool_array = &pFeatures->robustBufferAccess; + SetBoolArrayTrue(bool_array, num_bools); +''', +'vkGetPhysicalDeviceFeatures2KHR': ''' + GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); + uint32_t num_bools = 0; // Count number of VkBool32s in extension structs + VkBool32* feat_bools = nullptr; + auto vk_1_1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Features>(pFeatures->pNext); + if (vk_1_1_features) { + vk_1_1_features->protectedMemory = VK_TRUE; + } + auto vk_1_3_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Features>(pFeatures->pNext); + if (vk_1_3_features) { + vk_1_3_features->synchronization2 = VK_TRUE; + } + auto prot_features = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryFeatures>(pFeatures->pNext); + if (prot_features) { + prot_features->protectedMemory = VK_TRUE; + } + auto sync2_features = lvl_find_mod_in_chain<VkPhysicalDeviceSynchronization2FeaturesKHR>(pFeatures->pNext); + if (sync2_features) { + sync2_features->synchronization2 = VK_TRUE; + } + auto video_maintenance1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>(pFeatures->pNext); + if (video_maintenance1_features) { + video_maintenance1_features->videoMaintenance1 = VK_TRUE; + } + const auto *desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext); + if (desc_idx_features) { + const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing); + num_bools = bool_size/sizeof(VkBool32); + feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing; + SetBoolArrayTrue(feat_bools, num_bools); + } + const auto *blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext); + if (blendop_features) { + const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations); + num_bools = bool_size/sizeof(VkBool32); + feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations; + SetBoolArrayTrue(feat_bools, num_bools); + } + const auto *host_image_copy_features = lvl_find_in_chain<VkPhysicalDeviceHostImageCopyFeaturesEXT>(pFeatures->pNext); + if (host_image_copy_features) { + feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy; + SetBoolArrayTrue(feat_bools, 1); + } +''', +'vkGetPhysicalDeviceFormatProperties': ''' + if (VK_FORMAT_UNDEFINED == format) { + *pFormatProperties = { 0x0, 0x0, 0x0 }; + } else { + // Default to a color format, skip DS bit + *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF }; + switch (format) { + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_S8_UINT: + case VK_FORMAT_D16_UNORM_S8_UINT: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + // Don't set color bits for DS formats + *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F }; + break; + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: + // Set decode/encode bits for these formats + *pFormatProperties = { 0x1EFFFDFF, 0x1EFFFDFF, 0x00FFFDFF }; + break; + default: + break; + } + } +''', +'vkGetPhysicalDeviceFormatProperties2KHR': ''' + GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties); + VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext); + if (props_3) { + props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures; + props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures; + props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures; + props_3->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT; + } +''', +'vkGetPhysicalDeviceImageFormatProperties': ''' + // A hardcoded unsupported format + if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) { + return VK_ERROR_FORMAT_NOT_SUPPORTED; + } + + // TODO: Just hard-coding some values for now + // TODO: If tiling is linear, limit the mips, levels, & sample count + if (VK_IMAGE_TILING_LINEAR == tiling) { + *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 }; + } else { + // We hard-code support for all sample counts except 64 bits. + *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 }; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceImageFormatProperties2KHR': ''' + auto *external_image_prop = lvl_find_mod_in_chain<VkExternalImageFormatProperties>(pImageFormatProperties->pNext); + auto *external_image_format = lvl_find_in_chain<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo->pNext); + if (external_image_prop && external_image_format) { + external_image_prop->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; + external_image_prop->externalMemoryProperties.compatibleHandleTypes = external_image_format->handleType; + } + + GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties); + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceSparseImageFormatProperties': ''' + if (!pProperties) { + *pPropertyCount = 1; + } else { + // arbitrary + pProperties->imageGranularity = {4, 4, 4}; + pProperties->flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; + switch (format) { + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_D32_SFLOAT: + pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; + break; + case VK_FORMAT_S8_UINT: + pProperties->aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; + break; + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D16_UNORM_S8_UINT: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; + break; + default: + pProperties->aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + break; + } + } +''', +'vkGetPhysicalDeviceSparseImageFormatProperties2KHR': ''' + if (pPropertyCount && pProperties) { + GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, &pProperties->properties); + } else { + GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr); + } +''', +'vkGetPhysicalDeviceProperties': ''' + pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE; + pProperties->driverVersion = 1; + pProperties->vendorID = 0xba5eba11; + pProperties->deviceID = 0xf005ba11; + pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; + //std::string devName = "Vulkan Mock Device"; + strcpy(pProperties->deviceName, "Vulkan Mock Device"); + pProperties->pipelineCacheUUID[0] = 18; + pProperties->limits = SetLimits(&pProperties->limits); + pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE }; +''', +'vkGetPhysicalDeviceProperties2KHR': ''' + // The only value that need to be set are those the Profile layer can't set + // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352 + // All values set are arbitrary + GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); + + auto *props_11 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Properties>(pProperties->pNext); + if (props_11) { + props_11->protectedNoFault = VK_FALSE; + } + + auto *props_12 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan12Properties>(pProperties->pNext); + if (props_12) { + props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + } + + auto *props_13 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Properties>(pProperties->pNext); + if (props_13) { + props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + props_13->storageTexelBufferOffsetAlignmentBytes = 16; + props_13->uniformTexelBufferOffsetAlignmentBytes = 16; + } + + auto *protected_memory_props = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryProperties>(pProperties->pNext); + if (protected_memory_props) { + protected_memory_props->protectedNoFault = VK_FALSE; + } + + auto *float_controls_props = lvl_find_mod_in_chain<VkPhysicalDeviceFloatControlsProperties>(pProperties->pNext); + if (float_controls_props) { + float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + } + + auto *conservative_raster_props = lvl_find_mod_in_chain<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(pProperties->pNext); + if (conservative_raster_props) { + conservative_raster_props->primitiveOverestimationSize = 0.00195313f; + conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE; + conservative_raster_props->degenerateTrianglesRasterized = VK_TRUE; + conservative_raster_props->degenerateLinesRasterized = VK_TRUE; + } + + auto *rt_pipeline_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(pProperties->pNext); + if (rt_pipeline_props) { + rt_pipeline_props->shaderGroupHandleSize = 32; + rt_pipeline_props->shaderGroupBaseAlignment = 64; + rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32; + } + + auto *rt_pipeline_nv_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPropertiesNV>(pProperties->pNext); + if (rt_pipeline_nv_props) { + rt_pipeline_nv_props->shaderGroupHandleSize = 32; + rt_pipeline_nv_props->shaderGroupBaseAlignment = 64; + } + + auto *texel_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceTexelBufferAlignmentProperties>(pProperties->pNext); + if (texel_buffer_props) { + texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + texel_buffer_props->storageTexelBufferOffsetAlignmentBytes = 16; + texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16; + } + + auto *descriptor_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(pProperties->pNext); + if (descriptor_buffer_props) { + descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE; + descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE; + descriptor_buffer_props->allowSamplerImageViewPostSubmitCreation = VK_TRUE; + descriptor_buffer_props->descriptorBufferOffsetAlignment = 4; + } + + auto *mesh_shader_props = lvl_find_mod_in_chain<VkPhysicalDeviceMeshShaderPropertiesEXT>(pProperties->pNext); + if (mesh_shader_props) { + mesh_shader_props->meshOutputPerVertexGranularity = 32; + mesh_shader_props->meshOutputPerPrimitiveGranularity = 32; + mesh_shader_props->prefersLocalInvocationVertexOutput = VK_TRUE; + mesh_shader_props->prefersLocalInvocationPrimitiveOutput = VK_TRUE; + mesh_shader_props->prefersCompactVertexOutput = VK_TRUE; + mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE; + } + + auto *fragment_density_map2_props = lvl_find_mod_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext); + if (fragment_density_map2_props) { + fragment_density_map2_props->subsampledLoads = VK_FALSE; + fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE; + fragment_density_map2_props->maxSubsampledArrayLayers = 2; + fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1; + } + + auto *maintenance3_props = lvl_find_mod_in_chain<VkPhysicalDeviceMaintenance3Properties>(pProperties->pNext); + if (maintenance3_props) { + maintenance3_props->maxMemoryAllocationSize = 1073741824; + maintenance3_props->maxPerSetDescriptors = 1024; + } + + const uint32_t num_copy_layouts = 5; + const VkImageLayout HostCopyLayouts[]{ + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_GENERAL, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + }; + + auto *host_image_copy_props = lvl_find_mod_in_chain<VkPhysicalDeviceHostImageCopyPropertiesEXT>(pProperties->pNext); + if (host_image_copy_props){ + if (host_image_copy_props->pCopyDstLayouts == nullptr) host_image_copy_props->copyDstLayoutCount = num_copy_layouts; + else { + uint32_t num_layouts = (std::min)(host_image_copy_props->copyDstLayoutCount, num_copy_layouts); + for (uint32_t i = 0; i < num_layouts; i++) { + host_image_copy_props->pCopyDstLayouts[i] = HostCopyLayouts[i]; + } + } + if (host_image_copy_props->pCopySrcLayouts == nullptr) host_image_copy_props->copySrcLayoutCount = num_copy_layouts; + else { + uint32_t num_layouts = (std::min)(host_image_copy_props->copySrcLayoutCount, num_copy_layouts); + for (uint32_t i = 0; i < num_layouts; i++) { + host_image_copy_props->pCopySrcLayouts[i] = HostCopyLayouts[i]; + } + } + } + + auto *driver_properties = lvl_find_mod_in_chain<VkPhysicalDeviceDriverProperties>(pProperties->pNext); + if (driver_properties) { + std::strncpy(driver_properties->driverName, "Vulkan Mock Device", VK_MAX_DRIVER_NAME_SIZE); +#if defined(GIT_BRANCH_NAME) && defined(GIT_TAG_INFO) + std::strncpy(driver_properties->driverInfo, "Branch: " GIT_BRANCH_NAME " Tag Info: " GIT_TAG_INFO, VK_MAX_DRIVER_INFO_SIZE); +#else + std::strncpy(driver_properties->driverInfo, "Branch: --unknown-- Tag Info: --unknown--", VK_MAX_DRIVER_INFO_SIZE); +#endif + } + + auto *layered_properties = lvl_find_mod_in_chain<VkPhysicalDeviceLayeredApiPropertiesListKHR>(pProperties->pNext); + if (layered_properties) { + layered_properties->layeredApiCount = 1; + if (layered_properties->pLayeredApis) { + layered_properties->pLayeredApis[0] = VkPhysicalDeviceLayeredApiPropertiesKHR{ + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR, + nullptr, + 0xba5eba11, + 0xf005ba11, + VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR + }; + std::strncpy(layered_properties->pLayeredApis[0].deviceName, "Fake Driver", VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + } + } +''', +'vkGetPhysicalDeviceExternalSemaphoreProperties':''' + // Hard code support for all handle types and features + pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F; + pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F; + pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3; +''', +'vkGetPhysicalDeviceExternalSemaphorePropertiesKHR':''' + GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +''', +'vkGetPhysicalDeviceExternalFenceProperties':''' + // Hard-code support for all handle types and features + pExternalFenceProperties->exportFromImportedHandleTypes = 0xF; + pExternalFenceProperties->compatibleHandleTypes = 0xF; + pExternalFenceProperties->externalFenceFeatures = 0x3; +''', +'vkGetPhysicalDeviceExternalFencePropertiesKHR':''' + GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +''', +'vkGetPhysicalDeviceExternalBufferProperties':''' + constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF; + if (pExternalBufferInfo->handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) { + // Can't have dedicated memory with AHB + pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; + pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = pExternalBufferInfo->handleType; + pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; + } else if (pExternalBufferInfo->handleType & supported_flags) { + pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7; + pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = supported_flags; + pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = supported_flags; + } else { + pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0; + pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0; + // According to spec, handle type is always compatible with itself. Even if export/import + // not supported, it's important to properly implement self-compatibility property since + // application's control flow can rely on this. + pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; + } +''', +'vkGetPhysicalDeviceExternalBufferPropertiesKHR':''' + GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +''', +'vkGetBufferMemoryRequirements': ''' + // TODO: Just hard-coding reqs for now + pMemoryRequirements->size = 4096; + pMemoryRequirements->alignment = 1; + pMemoryRequirements->memoryTypeBits = 0xFFFF; + // Return a better size based on the buffer size from the create info. + unique_lock_t lock(global_lock); + auto d_iter = buffer_map.find(device); + if (d_iter != buffer_map.end()) { + auto iter = d_iter->second.find(buffer); + if (iter != d_iter->second.end()) { + pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096; + } + } +''', +'vkGetBufferMemoryRequirements2KHR': ''' + GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); +''', +'vkGetDeviceBufferMemoryRequirements': ''' + // TODO: Just hard-coding reqs for now + pMemoryRequirements->memoryRequirements.alignment = 1; + pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; + + // Return a size based on the buffer size from the create info. + pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096; +''', +'vkGetDeviceBufferMemoryRequirementsKHR': ''' + GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +''', +'vkGetImageMemoryRequirements': ''' + pMemoryRequirements->size = 0; + pMemoryRequirements->alignment = 1; + + unique_lock_t lock(global_lock); + auto d_iter = image_memory_size_map.find(device); + if(d_iter != image_memory_size_map.end()){ + auto iter = d_iter->second.find(image); + if (iter != d_iter->second.end()) { + pMemoryRequirements->size = iter->second; + } + } + // Here we hard-code that the memory type at index 3 doesn't support this image. + pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3); +''', +'vkGetImageMemoryRequirements2KHR': ''' + GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements); +''', +'vkGetDeviceImageMemoryRequirements': ''' + pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo); + pMemoryRequirements->memoryRequirements.alignment = 1; + // Here we hard-code that the memory type at index 3 doesn't support this image. + pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3); +''', +'vkGetDeviceImageMemoryRequirementsKHR': ''' + GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +''', +'vkMapMemory': ''' + unique_lock_t lock(global_lock); + if (VK_WHOLE_SIZE == size) { + if (allocated_memory_size_map.count(memory) != 0) + size = allocated_memory_size_map[memory] - offset; + else + size = 0x10000; + } + void* map_addr = malloc((size_t)size); + mapped_memory_map[memory].push_back(map_addr); + *ppData = map_addr; + return VK_SUCCESS; +''', +'vkMapMemory2KHR': ''' + return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData); +''', +'vkUnmapMemory': ''' + unique_lock_t lock(global_lock); + for (auto map_addr : mapped_memory_map[memory]) { + free(map_addr); + } + mapped_memory_map.erase(memory); +''', +'vkUnmapMemory2KHR': ''' + UnmapMemory(device, pMemoryUnmapInfo->memory); + return VK_SUCCESS; +''', +'vkGetImageSubresourceLayout': ''' + // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. + *pLayout = VkSubresourceLayout(); // Default constructor zero values. +''', +'vkCreateSwapchainKHR': ''' + unique_lock_t lock(global_lock); + *pSwapchain = (VkSwapchainKHR)global_unique_handle++; + for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){ + swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++; + } + return VK_SUCCESS; +''', +'vkDestroySwapchainKHR': ''' + unique_lock_t lock(global_lock); + swapchain_image_map.clear(); +''', +'vkGetSwapchainImagesKHR': ''' + if (!pSwapchainImages) { + *pSwapchainImageCount = icd_swapchain_image_count; + } else { + unique_lock_t lock(global_lock); + for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){ + pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i]; + } + + if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE; + else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count; + } + return VK_SUCCESS; +''', +'vkAcquireNextImageKHR': ''' + *pImageIndex = 0; + return VK_SUCCESS; +''', +'vkAcquireNextImage2KHR': ''' + *pImageIndex = 0; + return VK_SUCCESS; +''', +'vkCreateBuffer': ''' + unique_lock_t lock(global_lock); + *pBuffer = (VkBuffer)global_unique_handle++; + buffer_map[device][*pBuffer] = { + pCreateInfo->size, + current_available_address + }; + current_available_address += pCreateInfo->size; + // Always align to next 64-bit pointer + const uint64_t alignment = current_available_address % 64; + if (alignment != 0) { + current_available_address += (64 - alignment); + } + return VK_SUCCESS; +''', +'vkDestroyBuffer': ''' + unique_lock_t lock(global_lock); + buffer_map[device].erase(buffer); +''', +'vkCreateImage': ''' + unique_lock_t lock(global_lock); + *pImage = (VkImage)global_unique_handle++; + image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo); + return VK_SUCCESS; +''', +'vkDestroyImage': ''' + unique_lock_t lock(global_lock); + image_memory_size_map[device].erase(image); +''', +'vkEnumeratePhysicalDeviceGroupsKHR': ''' + if (!pPhysicalDeviceGroupProperties) { + *pPhysicalDeviceGroupCount = 1; + } else { + // arbitrary + pPhysicalDeviceGroupProperties->physicalDeviceCount = 1; + pPhysicalDeviceGroupProperties->physicalDevices[0] = physical_device_map.at(instance)[0]; + pPhysicalDeviceGroupProperties->subsetAllocation = VK_FALSE; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceMultisamplePropertiesEXT': ''' + if (pMultisampleProperties) { + // arbitrary + pMultisampleProperties->maxSampleLocationGridSize = {32, 32}; + } +''', +'vkGetPhysicalDeviceFragmentShadingRatesKHR': ''' + if (!pFragmentShadingRates) { + *pFragmentShadingRateCount = 1; + } else { + // arbitrary + pFragmentShadingRates->sampleCounts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT; + pFragmentShadingRates->fragmentSize = {8, 8}; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceCalibrateableTimeDomainsEXT': ''' + if (!pTimeDomains) { + *pTimeDomainCount = 1; + } else { + // arbitrary + *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceCalibrateableTimeDomainsKHR': ''' + if (!pTimeDomains) { + *pTimeDomainCount = 1; + } else { + // arbitrary + *pTimeDomains = VK_TIME_DOMAIN_DEVICE_KHR; + } + return VK_SUCCESS; +''', +'vkGetFenceWin32HandleKHR': ''' + *pHandle = (HANDLE)0x12345678; + return VK_SUCCESS; +''', +'vkGetFenceFdKHR': ''' + *pFd = 0x42; + return VK_SUCCESS; +''', +'vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR': ''' + if (!pCounters) { + *pCounterCount = 3; + } else { + if (*pCounterCount == 0){ + return VK_INCOMPLETE; + } + // arbitrary + pCounters[0].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; + pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR; + pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; + pCounters[0].uuid[0] = 0x01; + if (*pCounterCount == 1){ + return VK_INCOMPLETE; + } + pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; + pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR; + pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; + pCounters[1].uuid[0] = 0x02; + if (*pCounterCount == 2){ + return VK_INCOMPLETE; + } + pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; + pCounters[2].scope = VK_QUERY_SCOPE_COMMAND_KHR; + pCounters[2].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; + pCounters[2].uuid[0] = 0x03; + *pCounterCount = 3; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR': ''' + if (pNumPasses) { + // arbitrary + *pNumPasses = 1; + } +''', +'vkGetShaderModuleIdentifierEXT': ''' + if (pIdentifier) { + // arbitrary + pIdentifier->identifierSize = 1; + pIdentifier->identifier[0] = 0x01; + } +''', +'vkGetImageSparseMemoryRequirements': ''' + if (!pSparseMemoryRequirements) { + *pSparseMemoryRequirementCount = 1; + } else { + // arbitrary + pSparseMemoryRequirements->imageMipTailFirstLod = 0; + pSparseMemoryRequirements->imageMipTailSize = 8; + pSparseMemoryRequirements->imageMipTailOffset = 0; + pSparseMemoryRequirements->imageMipTailStride = 4; + pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4}; + pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; + // Would need to track the VkImage to know format for better value here + pSparseMemoryRequirements->formatProperties.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; + } + +''', +'vkGetImageSparseMemoryRequirements2KHR': ''' + if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) { + GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements); + } else { + GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr); + } +''', +'vkGetBufferDeviceAddress': ''' + VkDeviceAddress address = 0; + auto d_iter = buffer_map.find(device); + if (d_iter != buffer_map.end()) { + auto iter = d_iter->second.find(pInfo->buffer); + if (iter != d_iter->second.end()) { + address = iter->second.address; + } + } + return address; +''', +'vkGetBufferDeviceAddressKHR': ''' + return GetBufferDeviceAddress(device, pInfo); +''', +'vkGetBufferDeviceAddressEXT': ''' + return GetBufferDeviceAddress(device, pInfo); +''', +'vkGetDescriptorSetLayoutSizeEXT': ''' + // Need to give something non-zero + *pLayoutSizeInBytes = 4; +''', +'vkGetAccelerationStructureBuildSizesKHR': ''' + // arbitrary + pSizeInfo->accelerationStructureSize = 4; + pSizeInfo->updateScratchSize = 4; + pSizeInfo->buildScratchSize = 4; +''', +'vkGetAccelerationStructureMemoryRequirementsNV': ''' + // arbitrary + pMemoryRequirements->memoryRequirements.size = 4096; + pMemoryRequirements->memoryRequirements.alignment = 1; + pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; +''', +'vkGetAccelerationStructureDeviceAddressKHR': ''' + // arbitrary - need to be aligned to 256 bytes + return 0x262144; +''', +'vkGetVideoSessionMemoryRequirementsKHR': ''' + if (!pMemoryRequirements) { + *pMemoryRequirementsCount = 1; + } else { + // arbitrary + pMemoryRequirements[0].memoryBindIndex = 0; + pMemoryRequirements[0].memoryRequirements.size = 4096; + pMemoryRequirements[0].memoryRequirements.alignment = 1; + pMemoryRequirements[0].memoryRequirements.memoryTypeBits = 0xFFFF; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR': ''' + if (!pProperties) { + *pPropertyCount = 2; + } else { + // arbitrary + pProperties[0].MSize = 16; + pProperties[0].NSize = 16; + pProperties[0].KSize = 16; + pProperties[0].AType = VK_COMPONENT_TYPE_UINT32_KHR; + pProperties[0].BType = VK_COMPONENT_TYPE_UINT32_KHR; + pProperties[0].CType = VK_COMPONENT_TYPE_UINT32_KHR; + pProperties[0].ResultType = VK_COMPONENT_TYPE_UINT32_KHR; + pProperties[0].saturatingAccumulation = VK_FALSE; + pProperties[0].scope = VK_SCOPE_SUBGROUP_KHR; + + pProperties[1] = pProperties[0]; + pProperties[1].scope = VK_SCOPE_DEVICE_KHR; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceVideoCapabilitiesKHR': ''' + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; +''', +'vkGetPhysicalDeviceVideoFormatPropertiesKHR': ''' + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; +''', +'vkGetDescriptorSetLayoutSupport':''' + if (pSupport) { + pSupport->supported = VK_TRUE; + } +''', +'vkGetDescriptorSetLayoutSupportKHR':''' + GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); +''', +'vkGetRenderAreaGranularity': ''' + pGranularity->width = 1; + pGranularity->height = 1; +''', +'vkGetMemoryFdKHR': ''' + *pFd = 1; + return VK_SUCCESS; +''', +'vkGetMemoryHostPointerPropertiesEXT': ''' + pMemoryHostPointerProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type + return VK_SUCCESS; +''', +'vkGetAndroidHardwareBufferPropertiesANDROID': ''' + pProperties->allocationSize = 65536; + pProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type + + auto *format_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties->pNext); + if (format_prop) { + // Likley using this format + format_prop->format = VK_FORMAT_R8G8B8A8_UNORM; + format_prop->externalFormat = 37; + } + + auto *format_resolve_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(pProperties->pNext); + if (format_resolve_prop) { + format_resolve_prop->colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM; + } + return VK_SUCCESS; +''', +'vkGetPhysicalDeviceDisplayPropertiesKHR': ''' + if (!pProperties) { + *pPropertyCount = 1; + } else { + unique_lock_t lock(global_lock); + pProperties[0].display = (VkDisplayKHR)global_unique_handle++; + display_map[physicalDevice].insert(pProperties[0].display); + } + return VK_SUCCESS; +''', +'vkRegisterDisplayEventEXT': ''' + unique_lock_t lock(global_lock); + *pFence = (VkFence)global_unique_handle++; + return VK_SUCCESS; +''', +'vkQueueSubmit': ''' + // Special way to cause DEVICE_LOST + // Picked VkExportFenceCreateInfo because needed some struct that wouldn't get cleared by validation Safe Struct + // ... TODO - It would be MUCH nicer to have a layer or other setting control when this occured + // For now this is used to allow Validation Layers test reacting to device losts + if (submitCount > 0 && pSubmits) { + auto pNext = reinterpret_cast<const VkBaseInStructure *>(pSubmits[0].pNext); + if (pNext && pNext->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO && pNext->pNext == nullptr) { + return VK_ERROR_DEVICE_LOST; + } + } + return VK_SUCCESS; +''', +'vkGetMemoryWin32HandlePropertiesKHR': ''' + pMemoryWin32HandleProperties->memoryTypeBits = 0xFFFF; + return VK_SUCCESS; +''', +'vkCreatePipelineBinariesKHR': ''' + unique_lock_t lock(global_lock); + if (pBinaries->pPipelineBinaries != nullptr) + { + for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) { + pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++; + } + } + else + { + // In this case, we need to return a return count, let's set it to 3 + pBinaries->pipelineBinaryCount = 3; + } + return VK_SUCCESS; +''', +'vkGetPipelineKeyKHR': ''' + if (pPipelineKey != nullptr) + { + pPipelineKey->keySize = 16; + std::memset(pPipelineKey->key, 0x12, pPipelineKey->keySize); + } + return VK_SUCCESS; +''', +'vkGetPipelineBinaryDataKHR': ''' + static uint32_t fake_size = 64; + if (pPipelineBinaryDataSize != nullptr) + { + if (pPipelineBinaryData == nullptr) + { + *pPipelineBinaryDataSize = fake_size; + } + else + { + std::memset(pPipelineBinaryData, 0xABCD, fake_size); + } + } + return VK_SUCCESS; +''' +} + +# MockICDOutputGenerator +# Generates a mock vulkan ICD. +# This is intended to be a minimal replacement for a vulkan device in order +# to enable testing of Vulkan applications and layers +# +class MockICDOutputGenerator(BaseGenerator): + def __init__(self): + BaseGenerator.__init__(self) + + # Ignore extensions that ICDs should not implement or are not safe to report + self.ignore_exts = ['VK_EXT_validation_cache', 'VK_KHR_portability_subset'] + + # Dispatchable handles + self.dispatchable_handles = ['VkInstance','VkPhysicalDevice', 'VkDevice', 'VkCommandBuffer', 'VkQueue'] + + def generate_function_declarations(self, out): + + out.append('#include <stdint.h>\n') + out.append('#include <cstring>\n') + out.append('#include <string>\n') + out.append('#include <unordered_map>\n') + out.append('#include <vulkan/vulkan.h>\n') + out.append('\n') + out.append('namespace vkmock {\n') + out.append('// Map of instance extension name to version\n') + out.append('static const std::unordered_map<std::string, uint32_t> instance_extension_map = {\n') + for ext in [x for x in self.vk.extensions.values() if x.instance and x.name not in self.ignore_exts]: + if ext.protect: + out.append(f'#ifdef {ext.protect}\n') + out.append(f' {{"{ext.name}", {ext.specVersion}}},\n') + if ext.protect: + out.append('#endif\n') + out.append('};\n') + out.append('// Map of device extension name to version\n') + out.append('static const std::unordered_map<std::string, uint32_t> device_extension_map = {\n') + for ext in [x for x in self.vk.extensions.values() if x.device and x.name not in self.ignore_exts]: + if ext.protect: + out.append(f'#ifdef {ext.protect}\n') + out.append(f' {{"{ext.name}", {ext.specVersion}}},\n') + if ext.protect: + out.append('#endif\n') + out.append('};\n') + + current_protect = None + for name, cmd in self.vk.commands.items(): + prepend_newline = '\n' + if cmd.protect != current_protect: + if current_protect is not None: + out.append(f'#endif /* {current_protect} */\n') + prepend_newline = '' + if current_protect is not None and cmd.protect is not None: + out.append('\n') + if cmd.protect is not None: + out.append(f'#ifdef {cmd.protect}\n') + current_protect = cmd.protect + out.append(f'{prepend_newline}static {cmd.cPrototype.replace(name, name[2:])}\n') + if current_protect is not None: + out.append('#endif\n') + + # record intercepted procedures + out.append('// Map of all APIs to be intercepted by this layer\n') + out.append('static const std::unordered_map<std::string, void*> name_to_funcptr_map = {\n') + for name, cmd in self.vk.commands.items(): + if cmd.protect: + out.append(f'#ifdef {cmd.protect}\n') + out.append(f' {{"{name}", (void*){name[2:]}}},\n') + if cmd.protect: + out.append('#endif\n') + out.append('};\n') + + def generate_function_definitions(self, out): + out.append('#include "mock_icd.h"\n') + out.append('#include "function_declarations.h"\n') + out.append('namespace vkmock {\n') + + manual_functions = [ + # Include functions here to be intercepted w/ manually implemented function bodies + 'vkGetDeviceProcAddr', + 'vkGetInstanceProcAddr', + 'vkCreateDevice', + 'vkDestroyDevice', + 'vkCreateInstance', + 'vkDestroyInstance', + 'vkFreeCommandBuffers', + 'vkAllocateCommandBuffers', + 'vkDestroyCommandPool', + #'vkCreateDebugReportCallbackEXT', + #'vkDestroyDebugReportCallbackEXT', + 'vkEnumerateInstanceLayerProperties', + 'vkEnumerateInstanceVersion', + 'vkEnumerateInstanceExtensionProperties', + 'vkEnumerateDeviceLayerProperties', + 'vkEnumerateDeviceExtensionProperties', + 'vkGetPipelineKeyKHR', + 'vkGetPipelineBinaryDataKHR', + ] + + current_protect = None + for name, cmd in self.vk.commands.items(): + if cmd.protect != current_protect: + if current_protect is not None: + out.append(f'#endif /* {current_protect} */\n') + if current_protect is not None and cmd.protect is not None: + out.append('\n') + if cmd.protect is not None: + out.append(f'#ifdef {cmd.protect}\n') + current_protect = cmd.protect + + if name in manual_functions: + if name not in CUSTOM_C_INTERCEPTS: + out.append(f'static {cmd.cPrototype.replace(name, name[2:])}\n') + out.append('// TODO: Implement custom intercept body\n') + else: + out.append(f'static {cmd.cPrototype[:-1].replace(name, name[2:])}\n') + out.append(f'{{{CUSTOM_C_INTERCEPTS[name]}}}\n') + continue + + out.append(f'static {cmd.cPrototype[:-1].replace(name, name[2:])}\n') + if name in CUSTOM_C_INTERCEPTS: + out.append(f'{{{CUSTOM_C_INTERCEPTS[name]}}}\n') + continue + + # if the name w/ KHR postfix is in the CUSTOM_C_INTERCEPTS + # Call the KHR custom version instead of generating separate code + khr_name = name + "KHR" + if khr_name in CUSTOM_C_INTERCEPTS: + return_string = '' + if cmd.returnType != 'void': + return_string = 'return ' + + param_names = [] + for param in cmd.params: + param_names.append(param.name) + out.append(f'{{\n {return_string}{khr_name[2:]}({", ".join(param_names)});\n}}\n') + continue + out.append('{\n') + + # GET THE TYPE OF FUNCTION + if any(name.startswith(ftxt) for ftxt in ('vkCreate', 'vkAllocate')): + # Get last param + last_param = cmd.params[-1] + lp_txt = last_param.name + lp_len = None + if last_param.length is not None: + lp_len = last_param.length + lp_len = lp_len.replace('::', '->') + lp_type = last_param.type + handle_type = 'dispatchable' + allocator_txt = 'CreateDispObjHandle()' + if lp_type not in self.dispatchable_handles: + handle_type = 'non-' + handle_type + allocator_txt = 'global_unique_handle++' + # Need to lock in both cases + out.append(' unique_lock_t lock(global_lock);\n') + if lp_len is not None: + #print("%s last params (%s) has len %s" % (handle_type, lp_txt, lp_len)) + out.append(f' for (uint32_t i = 0; i < {lp_len}; ++i) {{\n') + out.append(f' {lp_txt}[i] = ({lp_type}){allocator_txt};\n') + out.append(' }\n') + else: + #print("Single %s last param is '%s' w/ type '%s'" % (handle_type, lp_txt, lp_type)) + if 'AllocateMemory' in name: + # Store allocation size in case it's mapped + out.append(' allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize;\n') + out.append(f' *{lp_txt} = ({lp_type}){allocator_txt};\n') + elif True in [ftxt in name for ftxt in ['Destroy', 'Free']]: + out.append('//Destroy object\n') + if 'FreeMemory' in name: + # If the memory is mapped, unmap it + out.append(' UnmapMemory(device, memory);\n') + # Remove from allocation map + out.append(' unique_lock_t lock(global_lock);\n') + out.append(' allocated_memory_size_map.erase(memory);\n') + else: + out.append('//Not a CREATE or DESTROY function\n') + + # Return result variable, if any. + if cmd.returnType != 'void': + if name == 'vkGetEventStatus': + out.append(' return VK_EVENT_SET;\n') + else: + out.append(' return VK_SUCCESS;\n') + out.append('}\n') + if current_protect is not None: + out.append('#endif\n') + + def generate(self): + out = [] + out.append('''/* +** Copyright (c) 2015-2025 The Khronos Group Inc. +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + +#pragma once +''') + + if self.filename == "function_declarations.h": + self.generate_function_declarations(out) + else: + self.generate_function_definitions(out) + + out.append('\n') + out.append('} // namespace vkmock\n') + out.append('\n') + self.write(''.join(out))
diff --git a/scripts/generators/vulkan_tools_helper_file_generator.py b/scripts/generators/vulkan_tools_helper_file_generator.py new file mode 100644 index 0000000..baf3e81 --- /dev/null +++ b/scripts/generators/vulkan_tools_helper_file_generator.py
@@ -0,0 +1,163 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2015-2021 The Khronos Group Inc. +# Copyright (c) 2015-2021 Valve Corporation +# Copyright (c) 2015-2021 LunarG, Inc. +# Copyright (c) 2015-2021 Google Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Author: Mark Lobodzinski <mark@lunarg.com> +# Author: Tobin Ehlis <tobine@google.com> +# Author: John Zulauf <jzulauf@lunarg.com> + +from base_generator import BaseGenerator + +# HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files +class HelperFileOutputGenerator(BaseGenerator): + def __init__(self): + BaseGenerator.__init__(self) + + + def generate(self): + out = [] + + # File Comment + out.append('// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n') + out.append('// See vulkan_tools_helper_file_generator.py for modifications\n') + + # Copyright Notice + out.append(''' + +/*************************************************************************** + * + * Copyright (c) 2015-2017 The Khronos Group Inc. + * Copyright (c) 2015-2017 Valve Corporation + * Copyright (c) 2015-2017 LunarG, Inc. + * Copyright (c) 2015-2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Author: Mark Lobodzinski <mark@lunarg.com> + * Author: Courtney Goeltzenleuchter <courtneygo@google.com> + * Author: Tobin Ehlis <tobine@google.com> + * Author: Chris Forbes <chrisforbes@google.com> + * Author: John Zulauf<jzulauf@lunarg.com> + * + ****************************************************************************/ +''') + + # Generate header + out.append(''' +#pragma once +#include <vulkan/vulkan.h> + +// These empty generic templates are specialized for each type with sType +// members and for each sType -- providing a two way map between structure +// types and sTypes + +template <VkStructureType id> struct LvlSTypeMap {}; +template <typename T> struct LvlTypeMap {}; + +''') + + # Generate the specializations for each type and stype + for struct in self.vk.structs.values(): + if struct.sType is None: + continue + + if struct.protect is not None: + out.append(f'#ifdef {struct.protect}\n') + + out.append(f'// Map type {struct.name} to id {struct.sType}\n') + out.append(f'template <> struct LvlTypeMap<{struct.name}> {{\n') + out.append(f' static const VkStructureType kSType = {struct.sType};\n') + out.append('};\n\n') + + + out.append(f'template <> struct LvlSTypeMap<{struct.sType}> {{\n') + out.append(f' typedef {struct.name} Type;\n') + out.append('};\n\n') + + if struct.protect is not None: + out.append(f'#endif // {struct.protect}\n') + + # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file + + out.append('''// Header "base class" for pNext chain traversal +struct LvlGenericHeader { + VkStructureType sType; + const LvlGenericHeader *pNext; +}; +struct LvlGenericModHeader { + VkStructureType sType; + LvlGenericModHeader *pNext; +}; + +// Find an entry of the given type in the pNext chain +template <typename T> const T *lvl_find_in_chain(const void *next) { + const LvlGenericHeader *current = reinterpret_cast<const LvlGenericHeader *>(next); + const T *found = nullptr; + while (current) { + if (LvlTypeMap<T>::kSType == current->sType) { + found = reinterpret_cast<const T*>(current); + current = nullptr; + } else { + current = current->pNext; + } + } + return found; +} +// Find an entry of the given type in the pNext chain +template <typename T> T *lvl_find_mod_in_chain(void *next) { + LvlGenericModHeader *current = reinterpret_cast<LvlGenericModHeader *>(next); + T *found = nullptr; + while (current) { + if (LvlTypeMap<T>::kSType == current->sType) { + found = reinterpret_cast<T*>(current); + current = nullptr; + } else { + current = current->pNext; + } + } + return found; +} + +// Init the header of an sType struct with pNext +template <typename T> T lvl_init_struct(void *p_next) { + T out = {}; + out.sType = LvlTypeMap<T>::kSType; + out.pNext = p_next; + return out; +} + +// Init the header of an sType struct +template <typename T> T lvl_init_struct() { + T out = {}; + out.sType = LvlTypeMap<T>::kSType; + return out; +} +''') + + self.write(''.join(out)) +
diff --git a/scripts/generators/vulkaninfo_generator.py b/scripts/generators/vulkaninfo_generator.py new file mode 100644 index 0000000..472459a --- /dev/null +++ b/scripts/generators/vulkaninfo_generator.py
@@ -0,0 +1,1165 @@ +#!/usr/bin/python3 +# +# Copyright (c) 2019-2026 Valve Corporation +# Copyright (c) 2019-2026 LunarG, Inc. +# Copyright (c) 2019-2022 Google Inc. +# Copyright (c) 2023-2024 RasterGrid Kft. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Author: Charles Giessen <charles@lunarg.com> + +from base_generator import BaseGenerator + +from collections import OrderedDict + +LICENSE_HEADER = ''' +/* + * Copyright (c) 2019-2026 The Khronos Group Inc. + * Copyright (c) 2019-2026 Valve Corporation + * Copyright (c) 2019-2026 LunarG, Inc. + * Copyright (c) 2023-2024 RasterGrid Kft. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Author: Charles Giessen <charles@lunarg.com> + * + */ + +/* + * This file is generated from the Khronos Vulkan XML API Registry. + */ +''' + +CUSTOM_FORMATTERS = r''' +template <typename T> +std::string to_hex_str(const T i) { + std::stringstream stream; + stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i; + return stream.str(); +} + +template <typename T> +std::string to_hex_str(Printer &p, const T i) { + if (p.Type() == OutputType::json) + return std::to_string(i); + else if (p.Type() == OutputType::vkconfig_output) + return std::string("\"") + to_hex_str(i) + std::string("\""); + else + return to_hex_str(i); +} + +''' + + +# used in the .cpp code +STRUCTURES_TO_GEN = ['VkExtent3D', 'VkExtent2D', 'VkPhysicalDeviceLimits', 'VkPhysicalDeviceFeatures', 'VkPhysicalDeviceSparseProperties', + 'VkSurfaceCapabilitiesKHR', 'VkSurfaceFormatKHR', 'VkLayerProperties', 'VkPhysicalDeviceToolProperties', 'VkFormatProperties', + 'VkSurfacePresentScalingCapabilitiesKHR', 'VkSurfacePresentModeCompatibilityKHR', 'VkPhysicalDeviceHostImageCopyProperties', + 'VkVideoProfileInfoKHR', 'VkVideoCapabilitiesKHR', 'VkVideoFormatPropertiesKHR', 'VkCooperativeMatrixPropertiesKHR', + 'VkPhysicalDeviceFragmentShadingRateKHR', 'VkMultisamplePropertiesEXT', + 'VkDisplayPropertiesKHR', 'VkDisplayPlanePropertiesKHR', 'VkDisplayPlaneCapabilitiesKHR', 'VkDisplayModePropertiesKHR', + 'VkDisplayModeParametersKHR'] + +ENUMS_TO_GEN = ['VkResult', 'VkFormat', 'VkPresentModeKHR', + 'VkPhysicalDeviceType', 'VkImageTiling', 'VkTimeDomainKHR'] +FLAGS_TO_GEN = ['VkSurfaceTransformFlagsKHR', 'VkCompositeAlphaFlagsKHR', 'VkSurfaceCounterFlagsEXT', 'VkQueueFlags', + 'VkDeviceGroupPresentModeFlagsKHR', 'VkFormatFeatureFlags', 'VkFormatFeatureFlags2', 'VkMemoryPropertyFlags', 'VkMemoryHeapFlags'] +FLAG_STRINGS_TO_GEN = ['VkQueueFlags'] + +STRUCT_SHORT_VERSIONS_TO_GEN = ['VkExtent3D', 'VkExtent2D'] + +STRUCT_COMPARISONS_TO_GEN = ['VkSurfaceFormatKHR', 'VkSurfaceFormat2KHR', 'VkSurfaceCapabilitiesKHR', + 'VkSurfaceCapabilities2KHR', 'VkSurfaceCapabilities2EXT'] +# don't generate these structures +STRUCT_BLACKLIST = ['VkVideoProfileListInfoKHR', 'VkDrmFormatModifierPropertiesListEXT', 'VkDrmFormatModifierPropertiesEXT', 'VkDrmFormatModifierPropertiesList2EXT'] +# These structures are only used in version 1.1, otherwise they are included in the promoted structs +STRUCT_1_1_LIST = ['VkPhysicalDeviceProtectedMemoryFeatures', 'VkPhysicalDeviceShaderDrawParametersFeatures', 'VkPhysicalDeviceSubgroupProperties', 'VkPhysicalDeviceProtectedMemoryProperties'] + +# generate these structures such that they only print when not in json mode (as json wants them separate) +PORTABILITY_STRUCTS = ['VkPhysicalDevicePortabilitySubsetFeaturesKHR', 'VkPhysicalDevicePortabilitySubsetPropertiesKHR'] + +# iostream or custom outputter handles these types +PREDEFINED_TYPES = ['char', 'VkBool32', 'uint32_t', 'uint8_t', 'int32_t', + 'float', 'uint64_t', 'size_t', 'VkDeviceSize', 'int64_t'] + +NAMES_TO_IGNORE = ['sType', 'pNext', 'displayMode', 'display', 'currentDisplay'] + +EXTENSION_TYPE_INSTANCE = 'instance' +EXTENSION_TYPE_DEVICE = 'device' +EXTENSION_TYPE_BOTH = 'both' + +# Types that need pNext Chains built. 'extends' is the xml tag used in the structextends member. 'type' can be device, instance, or both +EXTENSION_CATEGORIES = OrderedDict(( + ('phys_device_props2', + {'extends': 'VkPhysicalDeviceProperties2', + 'type': EXTENSION_TYPE_BOTH, + 'print_iterator': True, + 'can_show_promoted_structs': True, + 'ignore_vendor_exclusion': False}), + ('phys_device_mem_props2', + {'extends': 'VkPhysicalDeviceMemoryProperties2', + 'type': EXTENSION_TYPE_DEVICE, + 'print_iterator': False, + 'can_show_promoted_structs': False, + 'ignore_vendor_exclusion': False}), + ('phys_device_features2', + {'extends': 'VkPhysicalDeviceFeatures2', + 'type': EXTENSION_TYPE_DEVICE, + 'print_iterator': True, + 'can_show_promoted_structs': True, + 'ignore_vendor_exclusion': False}), + ('surface_capabilities2', + {'extends': 'VkSurfaceCapabilities2KHR', + 'type': EXTENSION_TYPE_BOTH, + 'print_iterator': True, + 'can_show_promoted_structs': False, + 'ignore_vendor_exclusion': False, + 'exclude': ['VkSurfacePresentScalingCapabilitiesKHR', 'VkSurfacePresentModeCompatibilityKHR']}), + ('format_properties2', + {'extends': 'VkFormatProperties2', + 'type': EXTENSION_TYPE_DEVICE, + 'print_iterator': True, + 'can_show_promoted_structs': False, + 'ignore_vendor_exclusion': False}), + ('queue_properties2', + {'extends': 'VkQueueFamilyProperties2', + 'type': EXTENSION_TYPE_DEVICE, + 'print_iterator': True, + 'can_show_promoted_structs': False, + 'ignore_vendor_exclusion': False}), + ('video_profile_info', + {'extends': 'VkVideoProfileInfoKHR', + 'type': EXTENSION_TYPE_DEVICE, + 'print_iterator': True, + 'can_show_promoted_structs': False, + 'ignore_vendor_exclusion': True}), + ('video_capabilities', + {'extends': 'VkVideoCapabilitiesKHR', + 'type': EXTENSION_TYPE_DEVICE, + 'print_iterator': True, + 'can_show_promoted_structs': False, + 'ignore_vendor_exclusion': True,}), + ('video_format_properties', + {'extends': 'VkVideoFormatPropertiesKHR', + 'type': EXTENSION_TYPE_DEVICE, + 'print_iterator': True, + 'can_show_promoted_structs': False, + 'ignore_vendor_exclusion': True}) + )) +class VulkanInfoGenerator(BaseGenerator): + def __init__(self): + BaseGenerator.__init__(self) + self.format_ranges = [] + + def generate(self): + self.findFormatRanges() + + # gather the types that are needed to generate + types_to_gen = set() + types_to_gen.update(ENUMS_TO_GEN) + types_to_gen.update(FLAGS_TO_GEN) + types_to_gen.update(STRUCTURES_TO_GEN) + + extension_types = {} + for key, ext_info in EXTENSION_CATEGORIES.items(): + extension_types[key] = [] + + for extended_struct in self.vk.structs[ext_info.get('extends')].extendedBy: + if ext_info.get('exclude') is not None and extended_struct in ext_info.get('exclude'): + continue + elif ext_info.get('ignore_vendor_exclusion'): + extension_types[key].append(extended_struct) + continue + vendor_tags = [] + for extension in self.vk.structs[extended_struct].extensions: + vendor_tags.append(extension.split('_')[1]) + if len(vendor_tags) == 0 or 'KHR' in vendor_tags or 'EXT' in vendor_tags: + extension_types[key].append(extended_struct) + extension_types[key] = sorted(extension_types[key]) + types_to_gen.update(extension_types[key]) + + # find all the types that need + types_to_gen.update(self.findAllTypesToGen(types_to_gen)) + + types_to_gen = sorted(types_to_gen) + + comparison_types_to_gen = set() + comparison_types_to_gen.update(STRUCT_COMPARISONS_TO_GEN) + comparison_types_to_gen.update(self.findAllTypesToGen(comparison_types_to_gen)) + comparison_types_to_gen = sorted(comparison_types_to_gen) + + + # print the types gathered + out = [] + out.append(LICENSE_HEADER + '\n') + out.append('#include "vulkaninfo.h"\n') + out.append('#include "outputprinter.h"\n') + out.append(CUSTOM_FORMATTERS) + + out.extend(self.genVideoEnums()) + + for enum in (e for e in types_to_gen if e in self.vk.enums): + out.extend(self.PrintEnumToString(self.vk.enums[enum])) + out.extend(self.PrintEnum(self.vk.enums[enum])) + + # Need to go through all flags to find if they or their associated bitmask needs printing + # This is because both bitmask and flag types are generated in PrintBitMask + for name in (x for x in sorted(self.vk.flags.keys()) if x in types_to_gen or self.vk.flags[x].bitmaskName in types_to_gen): + bitmask = self.vk.bitmasks[self.vk.flags[name].bitmaskName] + + out.extend(self.PrintBitMask(bitmask, bitmask.flagName)) + + if bitmask.flagName in FLAG_STRINGS_TO_GEN: + out.extend(self.PrintBitMaskToString(bitmask, bitmask.flagName)) + # make sure dump functions for nested structures are declared before use + for s in (x for x in types_to_gen if x in self.vk.structs and x not in STRUCT_BLACKLIST): + out.extend(self.PrintStructure(self.vk.structs[s], True)) + for s in (x for x in types_to_gen if x in self.vk.structs and x not in STRUCT_BLACKLIST): + out.extend(self.PrintStructure(self.vk.structs[s], False)) + + for key, value in EXTENSION_CATEGORIES.items(): + out.extend(self.PrintChainStruct(key, extension_types[key], value)) + + for s in (x for x in comparison_types_to_gen if x in self.vk.structs): + out.extend(self.PrintStructComparisonForwardDecl(self.vk.structs[s])) + for s in (x for x in comparison_types_to_gen if x in self.vk.structs): + out.extend(self.PrintStructComparison(self.vk.structs[s])) + for s in (x for x in types_to_gen if x in self.vk.structs and x in STRUCT_SHORT_VERSIONS_TO_GEN): + out.extend(self.PrintStructShort(self.vk.structs[s])) + + out.append('auto format_ranges = std::array{\n') + for f in self.format_ranges: + out.append(f' FormatRange{{{f.minimum_instance_version}, {self.vk.extensions[f.extensions[0]].nameString if len(f.extensions) > 0 else "nullptr"}, ') + out.append(f'static_cast<VkFormat>({f.first_format}), static_cast<VkFormat>({f.last_format})}},\n') + out.append('};\n') + + out.extend(self.genVideoProfileUtils()) + + self.write(''.join(out)) + + + def genVideoEnums(self): + out = [] + for enum in self.vk.videoStd.enums.values(): + out.append(f'std::string {enum.name}String({enum.name} value) {{\n') + out.append(' switch (value) {\n') + for field in enum.fields: + # Ignore aliases + if field.value is not None: + out.append(f' case {field.name}: return "{field.name}";\n') + out.append(f' default: return std::string("UNKNOWN_{enum.name}_value") + std::to_string(value);\n') + out.append(' }\n}\n') + out.append(f'void Dump{enum.name}(Printer &p, std::string name, {enum.name} value) {{\n') + out.append(f' p.PrintKeyString(name, {enum.name}String(value));\n}}\n') + return out + + + # Utility to get the extension / version precondition of a list of type names + def GetTypesPrecondition(self, typelist, indent): + indent = ' ' * indent + out = [] + extEnables = [] + for typename in typelist: + extEnables.extend(self.vk.structs[typename].extensions) + + version = None + for typename in typelist: + for v in self.vk.versions.values(): + if typename in v.name: + if version is not None and (v.major > version.major or (v.major == version.major and v.minor > version.minor)): + version = v + + + has_version = version is not None + has_extNameStr = len(extEnables) > 0 + if has_version or has_extNameStr: + out.append(f'{indent}if (') + has_printed_condition = False + if has_extNameStr: + for ext in extEnables: + if has_printed_condition: + out.append(f'\n{indent} || ') + else: + has_printed_condition = True + if has_version: + out.append('(') + if self.vk.extensions[ext].device: + out.append(f'gpu.CheckPhysicalDeviceExtensionIncluded({self.vk.extensions[ext].nameString})') + else: + assert False, 'Should never get here' + if has_version: + if has_printed_condition: + out.append(f'\n{indent} || (gpu.api_version >= {version.nameApi})') + else: + out.append(f'gpu.api_version >= {version.nameApi}') + out.append(') {\n') + else: + out = f'{indent}{{\n' + return out + + # Utility to construct a capability prerequisite condition evaluation expression + def GetRequiredCapsCondition(self, structName, memberName, memberRef, value): + condition = '' + requiredCapStructDef = self.vk.structs[structName] + for member in requiredCapStructDef.members: + if member.name == memberName: + if member.type in self.vk.flags: + # Check that the flags contain all the required values + def genExpressionFromValue(value): + return value if value == "" else f"({memberRef} & {value}) != 0" + + for char in condition: + if char in ['(', ')', '+', ',']: + condition += genExpressionFromValue(value) + value = "" + if char == '+': + # '+' means AND + condition += ' && ' + elif char == ',': + # ',' means OR + condition += ' || ' + else: + condition += char + else: + value += char + condition += genExpressionFromValue(value) + else: + condition = f'{memberRef} == {value}' + if condition == '': + return 'true' + else: + return f'({condition})' + + def genVideoProfileUtils(self): + out = [] + + # Generate video format properties comparator + out.append(''' +bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b) { + auto a = reinterpret_cast<const VkBaseInStructure*>(&format_a); + auto b = reinterpret_cast<const VkBaseInStructure*>(&format_b); + bool same = true; + while (same && a != nullptr && b != nullptr) { + if (a->sType != b->sType) { + // Structure type mismatch (extension structures are expected to be chained in the same order) + same = false; + } else { + switch (a->sType) {''') + + if 'VkVideoFormatPropertiesKHR' in self.registry.validextensionstructs: + for extstruct in ['VkVideoFormatPropertiesKHR'] + self.registry.validextensionstructs['VkVideoFormatPropertiesKHR']: + extstructDef = self.vk.structs[extstruct] + out.append(f''' + case {extstructDef.sType}: + same = same && memcmp(reinterpret_cast<const char*>(a) + sizeof(VkBaseInStructure), + reinterpret_cast<const char*>(b) + sizeof(VkBaseInStructure), + sizeof({extstruct}) - sizeof(VkBaseInStructure)) == 0; + break;''') + + out.append(''' + default: + // Unexpected structure type + same = false; + break; + } + } + a = a->pNext; + b = b->pNext; + } + return same; +} +''') + + # Generate video profile info capture utilities + out.append(''' +std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu) { + std::vector<std::unique_ptr<AppVideoProfile>> result{}; + + struct ChromaSubsamplingInfo { + VkVideoChromaSubsamplingFlagsKHR value; + const char* name; + }; + const std::vector<ChromaSubsamplingInfo> chroma_subsampling_list = { + {VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, "4:2:0"}, + {VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, "4:2:2"}, + {VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, "4:4:4"}, + {VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, "monochrome"} + }; + + struct BitDepthInfo { + VkVideoComponentBitDepthFlagsKHR value; + const char* name; + }; + const std::vector<BitDepthInfo> bit_depth_list = { + {VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, "8"}, + {VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, "10"}, + {VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR, "12"} + }; + + auto find_caps_struct = [](const VkVideoCapabilitiesKHR &capabilities, VkStructureType stype) -> const VkBaseInStructure* { + auto p = reinterpret_cast<const VkBaseInStructure*>(&capabilities); + while (p != nullptr) { + if (p->sType == stype) { + return p; + } + p = p->pNext; + } + return nullptr; + }; + + auto base_format = [] + (const ChromaSubsamplingInfo &chroma_subsampling, const BitDepthInfo &luma_bit_depth, const BitDepthInfo &chroma_bit_depth) { + std::string result{}; + result += " ("; + result += chroma_subsampling.name; + result += " "; + result += luma_bit_depth.name; + if (luma_bit_depth.value != chroma_bit_depth.value) { + result += ":"; + result += chroma_bit_depth.name; + } + result += "-bit)"; + return result; + }; + + auto add_profile = [&]( + const std::string &name, + const VkVideoProfileInfoKHR &profile_info, + AppVideoProfile::CreateProfileInfoChainCb create_profile_info_chain, + AppVideoProfile::CreateCapabilitiesChainCb create_capabilities_chain, + const AppVideoProfile::CreateFormatPropertiesChainCbList &create_format_properties_chain_list, + AppVideoProfile::InitProfileCb init_profile) { + auto profile = std::make_unique<AppVideoProfile>(gpu, gpu.phys_device, + name, profile_info, + create_profile_info_chain, + create_capabilities_chain, + create_format_properties_chain_list, + init_profile); + if (profile->supported) { + result.push_back(std::move(profile)); + } + }; +''') + + # Generate individual video profiles from the video codec metadata + for videoCodec in self.vk.videoCodecs.values(): + # Ignore video codec categories + if videoCodec.value is None: + continue + + out.append('\n') + out.extend(self.GetTypesPrecondition(videoCodec.profiles.keys(), 4)) + out.append(f'{" " * 8}const std::string codec_name = "{videoCodec.name}";\n') + + out.append(''' + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); +''') + + # Setup video profile info + out.append(f'{" " * 20}VkVideoProfileInfoKHR profile_info{{\n') + out.append(f'{" " * 20} VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,\n') + out.append(f'{" " * 20} nullptr,\n') + out.append(f'{" " * 20} {videoCodec.value},\n') + out.append(f'{" " * 20} chroma_subsampling.value,\n') + out.append(f'{" " * 20} luma_bit_depth.value,\n') + out.append(f'{" " * 20} chroma_bit_depth.value\n') + out.append(f'{" " * 20}}};\n\n') + + # Setup video profile info chain creation callback + out.append(f'{" " * 20}auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {{\n') + out.append(f'{" " * 20} auto profile_info_chain = std::make_unique<video_profile_info_chain>();\n') + for profileStruct in videoCodec.profiles: + structDef = self.vk.structs[profileStruct] + out.append(self.AddGuardHeader(structDef)) + out.append(f'{" " * 24}if (profile_info_chain != nullptr) {{\n') + out.append(f'{" " * 28}profile_info_chain->{profileStruct[2:]}.sType = {structDef.sType};\n') + out.append(f'{" " * 28}profile_info_chain->{profileStruct[2:]}.pNext = nullptr;\n') + out.append(f'{" " * 28}*ppnext = &profile_info_chain->{profileStruct[2:]};\n') + out.append(f'{" " * 28}ppnext = &profile_info_chain->{profileStruct[2:]}.pNext;\n') + out.append(f'{" " * 24}}}\n') + if structDef.protect: + out.append(f'#else\n{" " * 20}profile_info_chain = nullptr;\n') + out.append(self.AddGuardFooter(structDef)) + out.append(f'{" " * 20} return profile_info_chain;\n') + out.append(f'{" " * 20}}};\n\n') + + # Setup video capabilities chain creation callback + out.append(f'{" " * 20}auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {{\n') + out.append(f'{" " * 20} auto capabilities_chain = std::make_unique<video_capabilities_chain>();\n') + for capabilities in videoCodec.capabilities: + structDef = self.vk.structs[capabilities] + out.append(self.AddGuardHeader(structDef)) + out.append(f'{" " * 24}if (capabilities_chain != nullptr) {{\n') + out.extend(self.GetTypesPrecondition([capabilities], 28)) + out.append(f'{" " * 32}capabilities_chain->{capabilities[2:]}.sType = {structDef.sType};\n') + out.append(f'{" " * 32}capabilities_chain->{capabilities[2:]}.pNext = nullptr;\n') + out.append(f'{" " * 32}*ppnext = &capabilities_chain->{capabilities[2:]};\n') + out.append(f'{" " * 32}ppnext = &capabilities_chain->{capabilities[2:]}.pNext;\n') + out.append(f'{" " * 28}}}\n') + out.append(f'{" " * 24}}}\n') + out.append(self.AddGuardFooter(structDef)) + out.append(f'{" " * 20} return capabilities_chain;\n') + out.append(f'{" " * 20}}};\n\n') + + # Setup video format properties chain creation callbacks + out.append(f'{" " * 20}const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {{\n') + for format in videoCodec.formats.values(): + out.append(f'{" " * 24}AppVideoProfile::CreateFormatPropertiesChainCb {{\n') + out.append(f'{" " * 28}"{format.name}",\n') + out.append(f'{" " * 28}{format.usage.replace("+", " | ")},\n') + + # Callback to check required capabilities + out.append(f'{" " * 28}[&](const VkVideoCapabilitiesKHR &capabilities) -> bool {{\n') + out.append(f'{" " * 28} bool supported = true;\n') + for requiredCap in format.requiredCaps: + structDef = self.vk.structs[requiredCap.struct] + out.append(self.AddGuardHeader(structDef)) + out.extend(self.GetTypesPrecondition([requiredCap.struct], 32)) + out.append(f'{" " * 32} auto caps = reinterpret_cast<const {requiredCap.struct}*>(find_caps_struct(capabilities, {structDef.sType}));\n') + out.append(f'{" " * 32} if (caps != nullptr) {{\n') + out.append(f'{" " * 32} supported = supported && {self.GetRequiredCapsCondition(requiredCap.struct, requiredCap.member, f"caps->{requiredCap.member}", requiredCap.value)};\n') + out.append(f'{" " * 32} }} else {{\n') + out.append(f'{" " * 32} supported = false;\n') + out.append(f'{" " * 32} }}\n') + out.append(f'{" " * 32}}} else {{\n') + out.append(f'{" " * 32} supported = false;\n') + out.append(f'{" " * 32}}}\n') + if structDef.protect: + out.append(f'#else\n{" " * 32}supported = false;\n') + out.append(self.AddGuardFooter(structDef)) + out.append(f'{" " * 28} return supported;\n') + out.append(f'{" " * 28}}},\n') + + # Callback to create video format properties chain + out.append(f'{" " * 28}[&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {{\n') + out.append(f'{" " * 28} auto format_properties_chain = std::make_unique<video_format_properties_chain>();\n') + for formatProps in format.properties: + structDef = self.vk.structs[formatProps] + out.append(self.AddGuardHeader(structDef)) + out.append(f'{" " * 32}if (format_properties_chain != nullptr) {{\n') + out.extend(self.GetTypesPrecondition([formatProps], 36)) + out.append(f'{" " * 40}format_properties_chain->{formatProps[2:]}.sType = {structDef.sType};\n') + out.append(f'{" " * 40}format_properties_chain->{formatProps[2:]}.pNext = nullptr;\n') + out.append(f'{" " * 40}*ppnext = &format_properties_chain->{formatProps[2:]};\n') + out.append(f'{" " * 40}ppnext = &format_properties_chain->{formatProps[2:]}.pNext;\n') + out.append(f'{" " * 36}}}\n') + out.append(f'{" " * 32}}}\n') + out.append(self.AddGuardFooter(structDef)) + out.append(f'{" " * 28} return format_properties_chain;\n') + out.append(f'{" " * 28}}},\n') + + out.append(f'{" " * 24}}},\n') + out.append(f'{" " * 20}}};\n\n') + + # Permute profiles for each profile struct member value + profiles = {'': []} + for profileStruct in videoCodec.profiles.values(): + for profileStructMember in profileStruct.members.values(): + newProfiles = {} + for profileStructMemberValue, profileStructMemberName in profileStructMember.values.items(): + for profileName, profile in profiles.items(): + # Only add video profile name suffix to the full descriptive name if not empty to avoid excess whitespace + newProfileName = profileName if profileStructMemberName == '' else f'{profileName} {profileStructMemberName}' + newProfiles[newProfileName] = profile + [{ + "struct": profileStruct.name, + "member": profileStructMember.name, + "value": profileStructMemberValue + }] + profiles = newProfiles + + for profileName, profile in profiles.items(): + out.append(f'{" " * 20}add_profile(profile_base_name + "{profileName}", profile_info,\n') + out.append(f'{" " * 20} create_profile_info_chain, create_capabilities_chain,\n') + out.append(f'{" " * 20} create_format_properties_chain_list,\n') + out.append(f'{" " * 20} [](AppVideoProfile& profile) {{\n') + for profileStruct in videoCodec.profiles: + structDef = self.vk.structs[profileStruct] + out.append(self.AddGuardHeader(structDef)) + for elem in profile: + if elem['struct'] == profileStruct: + out.append(f'{" " * 24}profile.profile_info_chain->{elem["struct"][2:]}.{elem["member"]} = {elem["value"]};\n') + out.append(self.AddGuardFooter(structDef)) + out.append(f'{" " * 20}}});\n') + + out.append(f'{" " * 16}}}\n') + out.append(f'{" " * 12}}}\n') + out.append(f'{" " * 8}}}\n') + out.append(f'{" " * 4}}}\n') + + out.append(' return result;\n') + out.append('}\n\n') + + return out + + + # finds all the ranges of formats from core (1.0), core versions (1.1+), and extensions + def findFormatRanges(self): + min_val = 2**32 + prev_field = None + max_val = 0 + for f in self.vk.enums['VkFormat'].fields: + if f.value is None: + continue + if prev_field is not None and f.value != prev_field.value + 1: + for ext in prev_field.extensions: + if self.vk.extensions[ext].promotedTo is not None: + self.format_ranges.append(VulkanFormatRange(self.vk.extensions[ext].promotedTo.replace("VK_", "VK_API_"), [], min_val, max_val)) + break + # only bother with the first extension + self.format_ranges.append(VulkanFormatRange(0, prev_field.extensions, min_val, max_val)) + min_val = 2**32 + max_val = 0 + min_val = min(min_val, f.value) + max_val = max(max_val, f.value) + + prev_field = f + + for ext in prev_field.extensions: + if self.vk.extensions[ext].promotedTo is not None: + self.format_ranges.append(VulkanFormatRange(self.vk.extensions[ext].promotedTo.replace("VK_", "VK_API_"), [], min_val, max_val)) + break + + self.format_ranges.append(VulkanFormatRange(0, prev_field.extensions, min_val, max_val)) + + def findAllTypesToGen(self, initial_type_set): + out_set = set() + current_set = initial_type_set + while len(current_set) > 0: + out_set.update(current_set) + next_set = set() + + for current_item in current_set: + if current_item in self.vk.structs: + for member in self.vk.structs[current_item].members: + if member.type not in out_set and member.name not in NAMES_TO_IGNORE: + next_set.add(member.type) + + current_set = next_set + return out_set + + def AddGuardHeader(self,obj): + if obj is not None and obj.protect is not None: + return f'#ifdef {obj.protect}\n' + else: + return '' + + + def AddGuardFooter(self,obj): + if obj is not None and obj.protect is not None: + return f'#endif // {obj.protect}\n' + else: + return '' + + def PrintEnumToString(self,enum): + out = [] + out.append(self.AddGuardHeader(enum)) + out.append(f'std::string {enum.name}String({enum.name} value) {{\n') + out.append(' switch (value) {\n') + for v in enum.fields: + out.append(f' case ({v.name}): return "{v.name[3:]}";\n') + out.append(f' default: return std::string("UNKNOWN_{enum.name}_value") + std::to_string(value);\n') + out.append(' }\n}\n') + out.append(self.AddGuardFooter(enum)) + return out + + + def PrintEnum(self,enum): + out = [] + out.append(self.AddGuardHeader(enum)) + out.append(f'''void Dump{enum.name}(Printer &p, std::string name, {enum.name} value) {{ + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + {enum.name}String(value)); + else + p.PrintKeyString(name, {enum.name}String(value)); +}} +''') + out.append(self.AddGuardFooter(enum)) + return out + + + def PrintGetFlagStrings(self,name, bitmask): + out = [] + out.append(f'std::vector<const char *> {name}GetStrings({name} value) {{\n') + out.append(' std::vector<const char *> strings;\n') + # If a bitmask contains a field whose value is zero, we want to support printing the correct bitflag + # Otherwise, use "None" for when there are not bits set in the bitmask + if bitmask.flags[0].value != 0: + out.append(' if (value == 0) { strings.push_back("None"); return strings; }\n') + else: + out.append(f' if (value == 0) {{ strings.push_back("{bitmask.flags[0].name[3:]}"); return strings; }}\n') + for v in bitmask.flags: + # only check single-bit flags + if v.value != 0 and (v.value & (v.value - 1)) == 0: + out.append(f' if ({v.name} & value) strings.push_back("{v.name[3:]}");\n') + out.append(' return strings;\n}\n') + return out + + + def PrintFlags(self, bitmask, name): + out = [] + out.append(f'void Dump{name}(Printer &p, std::string name, {name} value) {{\n') + out.append(f''' if (static_cast<{bitmask.name}>(value) == 0) {{ + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) + p.SetAsType().PrintString("None"); + return; + }} + auto strings = {bitmask.name}GetStrings(static_cast<{bitmask.name}>(value)); + ArrayWrapper arr(p, name, strings.size()); + for(auto& str : strings){{ + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + }} +}} +''') + return out + + + def PrintFlagBits(self, bitmask): + return [f'''void Dump{bitmask.name}(Printer &p, std::string name, {bitmask.name} value) {{ + auto strings = {bitmask.name}GetStrings(value); + if (strings.size() > 0) {{ + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + }} +}} +'''] + + + def PrintBitMask(self,bitmask, name): + out = [] + out.extend(self.PrintGetFlagStrings(bitmask.name, bitmask)) + out.append(self.AddGuardHeader(bitmask)) + out.extend(self.PrintFlags(bitmask, name)) + out.extend(self.PrintFlagBits(bitmask)) + out.append(self.AddGuardFooter(bitmask)) + out.append('\n') + return out + + + def PrintBitMaskToString(self, bitmask, name): + out = [] + out.append(self.AddGuardHeader(bitmask)) + out.append(f'std::string {name}String({name} value) {{\n') + out.append(' std::string out;\n') + out.append(' bool is_first = true;\n') + for v in bitmask.flags: + out.append(f' if ({v.name} & value) {{\n') + out.append(' if (is_first) { is_first = false; } else { out += " | "; }\n') + out.append(f' out += "{str(v.name)[3:]}";\n') + out.append(' }\n') + out.append(' return out;\n') + out.append('}\n') + out.append(self.AddGuardFooter(bitmask)) + return out + + + def PrintStructure(self,struct, declare_only): + if len(struct.members) == 0: + return [] + out = [] + out.append(self.AddGuardHeader(struct)) + max_key_len = 0 + for v in struct.members: + if (v.type in PREDEFINED_TYPES or v.type in STRUCT_BLACKLIST) and (v.length is None or v.type in ['char'] or v.fixedSizeArray[0] in ['VK_UUID_SIZE', 'VK_LUID_SIZE']): + max_key_len = max(max_key_len, len(v.name)) + out.append(f'void Dump{struct.name}(Printer &p, std::string name, const {struct.name} &obj)') + if declare_only: + out.append(';\n') + out.append(self.AddGuardFooter(struct)) + return out + out.append(' {\n') + if struct.name == 'VkPhysicalDeviceLimits': + out.append(' if (p.Type() == OutputType::json)\n') + out.append(' p.ObjectStart("limits");\n') + out.append(' else\n') + out.append(' p.SetSubHeader().ObjectStart(name);\n') + elif struct.name == 'VkPhysicalDeviceSparseProperties': + out.append(' if (p.Type() == OutputType::json)\n') + out.append(' p.ObjectStart("sparseProperties");\n') + out.append(' else\n') + out.append(' p.SetSubHeader().ObjectStart(name);\n') + else: + out.append(' ObjectWrapper object{p, name};\n') + if max_key_len > 0: + out.append(f' p.SetMinKeyWidth({max_key_len});\n') + for v in struct.members: + # strings + if v.type == 'char': + if v.pointer == True: + out.append(f' if (obj.{v.name} == nullptr) {{') + out.append(f' p.PrintKeyString("{v.name}", "NULL");\n') + out.append(' } else {') + out.append(f' p.PrintKeyString("{v.name}", obj.{v.name});\n') + if v.pointer == True: + out.append(' }') + # arrays + elif v.length is not None: + # uuid's + if v.type == 'uint8_t' and (v.fixedSizeArray[0] == 'VK_LUID_SIZE' or v.fixedSizeArray[0] == 'VK_UUID_SIZE'): # VK_UUID_SIZE + if v.fixedSizeArray[0] == 'VK_LUID_SIZE': + out.append(' if (obj.deviceLUIDValid) { // special case\n') + out.append(f' p.PrintKeyValue("{v.name}", obj.{v.name});\n') + if v.fixedSizeArray[0] == 'VK_LUID_SIZE': + out.append(' }\n') + elif struct.name == 'VkQueueFamilyGlobalPriorityProperties' and v.name == 'priorities': + out.append(f' ArrayWrapper arr(p,"{v.name}", obj.priorityCount);\n') + out.append(' for (uint32_t i = 0; i < obj.priorityCount; i++) {\n') + out.append(' if (p.Type() == OutputType::json)\n') + out.append(' p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i]));\n') + out.append(' else\n') + out.append(' p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i]));\n') + out.append(' }\n') + elif len(v.fixedSizeArray) == 2: + out.append(f' {{\n ArrayWrapper arr(p,"{v.name}", ' + v.fixedSizeArray[0] + ');\n') + out.append(f' for (uint32_t i = 0; i < {v.fixedSizeArray[0]}; i++) {{\n') + out.append(f' for (uint32_t j = 0; j < {v.fixedSizeArray[1]}; j++) {{\n') + out.append(f' p.PrintElement(obj.{v.name}[i][j]); }} }}\n') + out.append(' }\n') + elif len(v.fixedSizeArray) == 1: + out.append(f' {{\n ArrayWrapper arr(p,"{v.name}", ' + v.fixedSizeArray[0] + ');\n') + out.append(f' for (uint32_t i = 0; i < {v.fixedSizeArray[0]}; i++) {{ p.PrintElement(obj.{v.name}[i]); }}\n') + out.append(' }\n') + else: # dynamic array length based on other member + out.append(f' if (obj.{v.length} == 0 || obj.{v.name} == nullptr) {{\n') + out.append(f' p.PrintKeyString("{v.name}", "NULL");\n') + out.append(' } else {\n') + out.append(f' ArrayWrapper arr(p,"{v.name}", obj.{v.length});\n') + out.append(f' for (uint32_t i = 0; i < obj.{v.length}; i++) {{\n') + out.append(f' Dump{v.type}(p, std::to_string(i), obj.{v.name}[i]);\n') + out.append(' }\n') + out.append(' }\n') + elif v.type == 'VkBool32': + out.append(f' p.PrintKeyBool("{v.name}", static_cast<bool>(obj.{v.name}));\n') + elif v.type == 'uint8_t': + out.append(f' p.PrintKeyValue("{v.name}", static_cast<uint32_t>(obj.{v.name}));\n') + elif v.type == 'VkDeviceSize' or (v.type == 'uint32_t' and v.name in ['vendorID', 'deviceID']): + out.append(f' p.PrintKeyValue("{v.name}", to_hex_str(p, obj.{v.name}));\n') + elif v.type in PREDEFINED_TYPES: + out.append(f' p.PrintKeyValue("{v.name}", obj.{v.name});\n') + elif v.name not in NAMES_TO_IGNORE: + # if it is an enum/flag/bitmask + if v.type in ['VkFormatFeatureFlags', 'VkFormatFeatureFlags2']: + out.append(' p.SetOpenDetails();\n') # special case so that feature flags are open in html output + out.append(f' Dump{v.type}(p, "{v.name}", obj.{v.name});\n') + + if struct.name in ['VkPhysicalDeviceLimits', 'VkPhysicalDeviceSparseProperties']: + out.append(' p.ObjectEnd();\n') + out.append('}\n') + + out.append(self.AddGuardFooter(struct)) + return out + + + def PrintStructShort(self,struct): + out = [] + out.append(self.AddGuardHeader(struct)) + out.append(f'std::ostream &operator<<(std::ostream &o, {struct.name} &obj) {{\n') + out.append(' return o << "(" << ') + + first = True + for v in struct.members: + if first: + first = False + out.append(f'obj.{v.name} << ') + else: + out.append(f'\',\' << obj.{v.name} << ') + out.append('")";\n') + out.append('}\n') + out.append(self.AddGuardFooter(struct)) + return out + + def PrintChainStruct(self, listName, structs_to_print, chain_details): + version_desc = '' + if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: + version_desc = 'gpu.api_version' + else: + version_desc = 'inst.instance_version' + + out = [] + + # use default constructor and delete copy & move operators + out.append(f'''struct {listName}_chain {{ + {listName}_chain() = default; + {listName}_chain(const {listName}_chain &) = delete; + {listName}_chain& operator=(const {listName}_chain &) = delete; + {listName}_chain({listName}_chain &&) = delete; + {listName}_chain& operator=({listName}_chain &&) = delete; +''') + + out.append(' void* start_of_chain = nullptr;\n') + for s in structs_to_print: + if s in STRUCT_BLACKLIST: + continue + struct = self.vk.structs[s] + out.append(self.AddGuardHeader(struct)) + if struct.sType is not None: + out.append(f' {struct.name} {struct.name[2:]}{{}};\n') + # Specific versions of drivers have an incorrect definition of the size of these structs. + # We need to artificially pad the structure it just so the driver doesn't write out of bounds and + # into other structures that are adjacent. This bug comes from the in-development version of + # the extension having a larger size than the final version, so older drivers try to write to + # members which don't exist. + if struct.name in ['VkPhysicalDeviceShaderIntegerDotProductFeatures', 'VkPhysicalDeviceHostImageCopyFeaturesEXT']: + out.append(f' char {struct.name}_padding[64];\n') + for member in struct.members: + if member.length is not None and len(member.fixedSizeArray) == 0: + out.append(f' std::vector<{member.type}> {struct.name}_{member.name};\n') + out.append(self.AddGuardFooter(struct)) + out.append(' void initialize_chain(') + args = [] + if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]: + args.append('AppInstance &inst') + if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: + args.append('AppGpu &gpu') + if chain_details.get('can_show_promoted_structs'): + args.append('bool show_promoted_structs') + out.append(f'{", ".join(args)}) noexcept {{\n') + for s in structs_to_print: + if s in STRUCT_BLACKLIST: + continue + struct = self.vk.structs[s] + + out.append(self.AddGuardHeader(struct)) + out.append(f' {struct.name[2:]}.sType = {struct.sType};\n') + out.append(self.AddGuardFooter(struct)) + + out.append(' std::vector<VkBaseOutStructure*> chain_members{};\n') + for s in structs_to_print: + if s in STRUCT_BLACKLIST: + continue + struct = self.vk.structs[s] + out.append(self.AddGuardHeader(struct)) + + has_version = struct.version is not None + has_extNameStr = len(struct.extensions) > 0 or len(struct.aliases) > 0 + if has_version or has_extNameStr: + out.append(' if (') + has_printed_condition = False + if has_extNameStr: + for ext in struct.extensions: + if has_printed_condition: + out.append('\n || ') + else: + has_printed_condition = True + if has_version: + out.append('(') + if self.vk.extensions[ext].device: + out.append(f'gpu.CheckPhysicalDeviceExtensionIncluded({self.vk.extensions[ext].nameString})') + elif self.vk.extensions[ext].instance: + out.append(f'inst.CheckExtensionEnabled({self.vk.extensions[ext].nameString})') + else: + assert False, 'Should never get here' + if has_version: + str_show_promoted_structs = '|| show_promoted_structs' if chain_details.get('can_show_promoted_structs') else '' + if struct.name in STRUCT_1_1_LIST: + out.append(f'{version_desc} == {struct.version.nameApi} {str_show_promoted_structs}') + elif has_printed_condition: + out.append(f')\n && ({version_desc} < {struct.version.nameApi} {str_show_promoted_structs})') + else: + out.append(f'({version_desc} >= {struct.version.nameApi})') + out.append(')\n ') + else: + out.append(' ') + out.append(f'chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&{struct.name[2:]}));\n') + out.append(self.AddGuardFooter(struct)) + chain_param_list = [] + chain_arg_list = [] + if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]: + chain_param_list.append('AppInstance &inst') + chain_arg_list.append('inst') + if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: + chain_param_list.append('AppGpu &gpu') + chain_arg_list.append('gpu') + if chain_details.get('can_show_promoted_structs'): + chain_param_list.append('bool show_promoted_structs') + chain_arg_list.append('show_promoted_structs') + + out.append(f''' + if (!chain_members.empty()) {{ + for(size_t i = 0; i < chain_members.size() - 1; i++){{ + chain_members[i]->pNext = chain_members[i + 1]; + }} + start_of_chain = chain_members[0]; + }} + }} +}}; +void setup_{listName}_chain({chain_details['extends']}& start, std::unique_ptr<{listName}_chain>& chain, {','.join(chain_param_list)}){{ + chain = std::unique_ptr<{listName}_chain>(new {listName}_chain()); + chain->initialize_chain({','.join(chain_arg_list)}); + start.pNext = chain->start_of_chain; +}}; +''') + if chain_details.get('print_iterator'): + out.append('\n') + out.append(f'void chain_iterator_{listName}(') + args = ['Printer &p'] + if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]: + args.append('AppInstance &inst') + if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: + args.append('AppGpu &gpu') + if chain_details.get('can_show_promoted_structs'): + args.append('bool show_promoted_structs') + args.append('const void * place') + out.append(f'{", ".join(args)}) {{\n') + out.append(' while (place) {\n') + out.append(' const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;\n') + out.append(' p.SetSubHeader();\n') + + for s in structs_to_print: + if s in STRUCT_BLACKLIST: + continue + struct = self.vk.structs[s] + + out.append(self.AddGuardHeader(struct)) + out.append(f' if (structure->sType == {struct.sType}') + if struct.name in PORTABILITY_STRUCTS: + out.append(' && p.Type() != OutputType::json') + out.append(') {\n') + out.append(f' const {struct.name}* props = (const {struct.name}*)structure;\n') + out.extend(self.PrintStructNameDecisionLogic(struct, version_desc, chain_details.get('can_show_promoted_structs'))) + out.append(' p.AddNewline();\n') + out.append(' }\n') + out.append(self.AddGuardFooter(struct)) + out.append(' place = structure->pNext;\n') + out.append(' }\n') + out.append('}\n') + + out.append('\n') + out.append(f'bool prepare_{listName}_twocall_chain_vectors(std::unique_ptr<{listName}_chain>& chain) {{\n') + out.append(' (void)chain;\n') + is_twocall = False + for s in structs_to_print: + if s in STRUCT_BLACKLIST: + continue + struct = self.vk.structs[s] + has_length = False + for member in struct.members: + if member.length is not None and len(member.fixedSizeArray) == 0: + has_length = True + if not has_length: + continue + out.append(self.AddGuardHeader(struct)) + for member in struct.members: + if member.length is not None and len(member.fixedSizeArray) == 0: + out.append(f' chain->{struct.name}_{member.name}.resize(chain->{struct.name[2:]}.{member.length});\n') + out.append(f' chain->{struct.name[2:]}.{member.name} = chain->{struct.name}_{member.name}.data();\n') + out.append(self.AddGuardFooter(struct)) + is_twocall = True + out.append(f' return {"true" if is_twocall else "false"};\n') + out.append('}\n') + + return out + + def GetStructCheckStringForMatchingExtension(self, struct, structName): + for ext_name in struct.extensions: + ext = self.vk.extensions[ext_name] + vendor = ext.name.split('_')[1] + if structName.endswith(vendor): + if ext.device: + return f'gpu.CheckPhysicalDeviceExtensionIncluded({ext.nameString})' + elif ext.instance: + return f'inst.CheckExtensionEnabled({ext.nameString})' + return None + + # Function is complex because it has to do the following: + # Always print the struct with the most appropriate name given the gpu api version & enabled instance/device extensions + # Print struct aliases when --show-promoted-structs is set + # Not let alias printing duplicate the most appropriate name + def PrintStructNameDecisionLogic(self, struct, version_desc, can_show_promoted_structs): + out = [] + out.append(f'{" " * 12}const char* name = ') + # Get a list of all the conditions to check and the type name to use + check_list = [] + if struct.version is not None: + check_list.append([f'{version_desc} >= {struct.version.nameApi}', struct.name]) + else: + check_list.append([f'{self.GetStructCheckStringForMatchingExtension(struct, struct.name)}', struct.name]) + + for alias in struct.aliases: + ext_str = self.GetStructCheckStringForMatchingExtension(struct, alias) + if ext_str is not None: + check_list.append([f'{self.GetStructCheckStringForMatchingExtension(struct, alias)}', alias]) + end_parens = '' + # Turn the conditions into a nested ternary condition - + for check in check_list: + if check == check_list[-1]: + out.append( f'"{check[1]}"') + else: + out.append( f'{check[0]} ? "{check[1]}" : (') + end_parens += ')' + out.append(f'{end_parens};\n') + out.append(f'{" " * 12}Dump{struct.name}(p, name, *props);\n') + if not can_show_promoted_structs: + return out + for alias in struct.aliases: + ext_str = self.GetStructCheckStringForMatchingExtension(struct, alias) + if ext_str is not None: + out.append(f'{" " * 12}if (show_promoted_structs && strcmp(name, "{alias}") != 0 && {ext_str}) {{\n') + out.append(f'{" " * 16}p.AddNewline();\n') + out.append(f'{" " * 16}p.SetSubHeader();\n') + out.append(f'{" " * 16}Dump{struct.name}(p, "{alias}", *props);\n') + out.append(f'{" " * 12}}}\n') + return out + + def PrintStructComparisonForwardDecl(self,structure): + out = [] + out.append(f'bool operator==(const {structure.name} & a, const {structure.name} b);\n') + return out + + + def PrintStructComparison(self,structure): + out = [] + out.append(f'bool operator==(const {structure.name} & a, const {structure.name} b) {{\n') + out.append(' return ') + is_first = True + for m in structure.members: + if m.name not in NAMES_TO_IGNORE: + if not is_first: + out.append('\n && ') + else: + is_first = False + out.append(f'a.{m.name} == b.{m.name}') + out.append(';\n') + out.append('}\n') + return out + +class VulkanFormatRange: + def __init__(self, min_inst_version, extensions, first, last): + self.minimum_instance_version = min_inst_version + self.extensions = extensions + self.first_format = first + self.last_format = last
diff --git a/scripts/known_good.json b/scripts/known_good.json index ab4960f..c0838fa 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json
@@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.4.304" + "commit": "v1.4.350" }, { "name": "MoltenVK", @@ -15,7 +15,7 @@ "sub_dir": "MoltenVK", "build_dir": "MoltenVK", "install_dir": "MoltenVK", - "commit": "v1.2.11", + "commit": "v1.4.1", "custom_build": [ "./fetchDependencies --macos", "xcodebuild -project MoltenVKPackaging.xcodeproj GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS MVK_CONFIG_LOG_LEVEL=1' -scheme \"MoltenVK Package (macOS only)\" build" @@ -26,24 +26,6 @@ ] }, { - "name": "volk", - "api": "vulkan", - "url": "https://github.com/zeux/volk", - "sub_dir": "volk", - "build_dir": "volk/build", - "install_dir": "volk/build/install", - "cmake_options": [ - "-DVOLK_INSTALL=ON" - ], - "commit": "vulkan-sdk-1.4.304", - "deps": [ - { - "var_name": "VULKAN_HEADERS_INSTALL_DIR", - "repo_name": "Vulkan-Headers" - } - ] - }, - { "name": "googletest", "url": "https://github.com/google/googletest.git", "sub_dir": "googletest", @@ -74,7 +56,7 @@ "cmake_options": [ "-DLOADER_USE_UNSAFE_FILE_SEARCH=ON" ], - "commit": "v1.4.304", + "commit": "v1.4.350", "build_platforms": [ "windows", "linux", @@ -90,7 +72,6 @@ ], "install_names": { "Vulkan-Headers": "VULKAN_HEADERS_INSTALL_DIR", - "volk": "VOLK_INSTALL_DIR", "MoltenVK": "MOLTENVK_REPO_ROOT", "googletest": "GOOGLETEST_INSTALL_DIR", "Vulkan-Loader": "VULKAN_LOADER_INSTALL_DIR"
diff --git a/scripts/kvt_genvk.py b/scripts/kvt_genvk.py index 8f6b6ee..868cc3f 100644 --- a/scripts/kvt_genvk.py +++ b/scripts/kvt_genvk.py
@@ -1,7 +1,7 @@ #!/usr/bin/python3 # -# Copyright (c) 2013-2024 The Khronos Group Inc. -# Copyright (c) 2023-2024 RasterGrid Kft. +# Copyright (c) 2013-2025 The Khronos Group Inc. +# Copyright (c) 2023-2025 RasterGrid Kft. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -16,9 +16,7 @@ # limitations under the License. import argparse -import cProfile import pdb -import string import sys import time import os @@ -104,7 +102,7 @@ # Copyright text prefixing all headers (list of strings). prefixStrings = [ '/*', - '** Copyright (c) 2015-2024 The Khronos Group Inc.', + '** Copyright (c) 2015-2025 The Khronos Group Inc.', '**', '** Licensed under the Apache License, Version 2.0 (the "License");', '** you may not use this file except in compliance with the License.', @@ -236,7 +234,8 @@ apientry='VKAPI_CALL ', apientryp='VKAPI_PTR *', alignFuncParam=48, - expandEnumerants=False) + expandEnumerants=False, + registryFile=args.registry) ] @@ -360,9 +359,9 @@ from cgenerator import CGeneratorOptions, COutputGenerator # Generator Modifications - from mock_icd_generator import MockICDGeneratorOptions, MockICDOutputGenerator - from vulkan_tools_helper_file_generator import HelperFileOutputGenerator, HelperFileOutputGeneratorOptions - from vulkaninfo_generator import VulkanInfoGenerator, VulkanInfoGeneratorOptions + from generators.mock_icd_generator import MockICDGeneratorOptions, MockICDOutputGenerator + from generators.vulkan_tools_helper_file_generator import HelperFileOutputGenerator, HelperFileOutputGeneratorOptions + from generators.vulkaninfo_generator import VulkanInfoGenerator, VulkanInfoGeneratorOptions # Temporary workaround for vkconventions python2 compatibility import abc abc.ABC = abc.ABCMeta('ABC', (object,), {})
diff --git a/scripts/mock_icd_generator.py b/scripts/mock_icd_generator.py deleted file mode 100644 index c788e71..0000000 --- a/scripts/mock_icd_generator.py +++ /dev/null
@@ -1,2464 +0,0 @@ -#!/usr/bin/python3 -i -# -# Copyright (c) 2015-2023 The Khronos Group Inc. -# Copyright (c) 2015-2023 Valve Corporation -# Copyright (c) 2015-2023 LunarG, Inc. -# Copyright (c) 2015-2023 Google Inc. -# Copyright (c) 2023-2023 RasterGrid Kft. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Author: Tobin Ehlis <tobine@google.com> -# -# This script generates a Mock ICD that intercepts almost all Vulkan -# functions. That layer is not intended to be useful or even compilable -# in its initial state. Rather it's intended to be a starting point that -# can be copied and customized to assist in creation of a new layer. - -import os,re,sys -from generator import * -from common_codegen import * - -CUSTOM_C_INTERCEPTS = { -'vkCreateInstance': ''' - // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with - // apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the - // ICD should behave as normal. - if (loader_interface_version <= 4) { - return VK_ERROR_INCOMPATIBLE_DRIVER; - } - *pInstance = (VkInstance)CreateDispObjHandle(); - for (auto& physical_device : physical_device_map[*pInstance]) - physical_device = (VkPhysicalDevice)CreateDispObjHandle(); - // TODO: If emulating specific device caps, will need to add intelligence here - return VK_SUCCESS; -''', -'vkDestroyInstance': ''' - if (instance) { - for (const auto physical_device : physical_device_map.at(instance)) { - display_map.erase(physical_device); - DestroyDispObjHandle((void*)physical_device); - } - physical_device_map.erase(instance); - DestroyDispObjHandle((void*)instance); - } -''', -'vkAllocateCommandBuffers': ''' - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) { - pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle(); - command_pool_buffer_map[pAllocateInfo->commandPool].push_back(pCommandBuffers[i]); - } - return VK_SUCCESS; -''', -'vkFreeCommandBuffers': ''' - unique_lock_t lock(global_lock); - for (auto i = 0u; i < commandBufferCount; ++i) { - if (!pCommandBuffers[i]) { - continue; - } - - for (auto& pair : command_pool_buffer_map) { - auto& cbs = pair.second; - auto it = std::find(cbs.begin(), cbs.end(), pCommandBuffers[i]); - if (it != cbs.end()) { - cbs.erase(it); - } - } - - DestroyDispObjHandle((void*) pCommandBuffers[i]); - } -''', -'vkCreateCommandPool': ''' - unique_lock_t lock(global_lock); - *pCommandPool = (VkCommandPool)global_unique_handle++; - command_pool_map[device].insert(*pCommandPool); - return VK_SUCCESS; -''', -'vkDestroyCommandPool': ''' - // destroy command buffers for this pool - unique_lock_t lock(global_lock); - auto it = command_pool_buffer_map.find(commandPool); - if (it != command_pool_buffer_map.end()) { - for (auto& cb : it->second) { - DestroyDispObjHandle((void*) cb); - } - command_pool_buffer_map.erase(it); - } - command_pool_map[device].erase(commandPool); -''', -'vkEnumeratePhysicalDevices': ''' - VkResult result_code = VK_SUCCESS; - if (pPhysicalDevices) { - const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count); - for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i]; - if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE; - *pPhysicalDeviceCount = return_count; - } else { - *pPhysicalDeviceCount = icd_physical_device_count; - } - return result_code; -''', -'vkCreateDevice': ''' - *pDevice = (VkDevice)CreateDispObjHandle(); - // TODO: If emulating specific device caps, will need to add intelligence here - return VK_SUCCESS; -''', -'vkDestroyDevice': ''' - unique_lock_t lock(global_lock); - // First destroy sub-device objects - // Destroy Queues - for (auto queue_family_map_pair : queue_map[device]) { - for (auto index_queue_pair : queue_map[device][queue_family_map_pair.first]) { - DestroyDispObjHandle((void*)index_queue_pair.second); - } - } - - for (auto& cp : command_pool_map[device]) { - for (auto& cb : command_pool_buffer_map[cp]) { - DestroyDispObjHandle((void*) cb); - } - command_pool_buffer_map.erase(cp); - } - command_pool_map[device].clear(); - - queue_map.erase(device); - buffer_map.erase(device); - image_memory_size_map.erase(device); - // Now destroy device - DestroyDispObjHandle((void*)device); - // TODO: If emulating specific device caps, will need to add intelligence here -''', -'vkGetDeviceQueue': ''' - unique_lock_t lock(global_lock); - auto queue = queue_map[device][queueFamilyIndex][queueIndex]; - if (queue) { - *pQueue = queue; - } else { - *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle(); - } - // TODO: If emulating specific device caps, will need to add intelligence here - return; -''', -'vkGetDeviceQueue2': ''' - GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); - // TODO: Add further support for GetDeviceQueue2 features -''', -'vkEnumerateInstanceLayerProperties': ''' - return VK_SUCCESS; -''', -'vkEnumerateInstanceVersion': ''' - *pApiVersion = VK_HEADER_VERSION_COMPLETE; - return VK_SUCCESS; -''', -'vkEnumerateDeviceLayerProperties': ''' - return VK_SUCCESS; -''', -'vkEnumerateInstanceExtensionProperties': ''' - // If requesting number of extensions, return that - if (!pLayerName) { - if (!pProperties) { - *pPropertyCount = (uint32_t)instance_extension_map.size(); - } else { - uint32_t i = 0; - for (const auto &name_ver_pair : instance_extension_map) { - if (i == *pPropertyCount) { - break; - } - std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); - pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; - pProperties[i].specVersion = name_ver_pair.second; - ++i; - } - if (i != instance_extension_map.size()) { - return VK_INCOMPLETE; - } - } - } - // If requesting extension properties, fill in data struct for number of extensions - return VK_SUCCESS; -''', -'vkEnumerateDeviceExtensionProperties': ''' - // If requesting number of extensions, return that - if (!pLayerName) { - if (!pProperties) { - *pPropertyCount = (uint32_t)device_extension_map.size(); - } else { - uint32_t i = 0; - for (const auto &name_ver_pair : device_extension_map) { - if (i == *pPropertyCount) { - break; - } - std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); - pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; - pProperties[i].specVersion = name_ver_pair.second; - ++i; - } - if (i != device_extension_map.size()) { - return VK_INCOMPLETE; - } - } - } - // If requesting extension properties, fill in data struct for number of extensions - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceSurfacePresentModesKHR': ''' - // Currently always say that all present modes are supported - if (!pPresentModes) { - *pPresentModeCount = 6; - } else { - if (*pPresentModeCount >= 6) pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR; - if (*pPresentModeCount >= 5) pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR; - if (*pPresentModeCount >= 4) pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR; - if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR; - if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR; - if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceSurfaceFormatsKHR': ''' - // Currently always say that RGBA8 & BGRA8 are supported - if (!pSurfaceFormats) { - *pSurfaceFormatCount = 2; - } else { - if (*pSurfaceFormatCount >= 2) { - pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM; - pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - if (*pSurfaceFormatCount >= 1) { - pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM; - pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceSurfaceFormats2KHR': ''' - // Currently always say that RGBA8 & BGRA8 are supported - if (!pSurfaceFormats) { - *pSurfaceFormatCount = 2; - } else { - if (*pSurfaceFormatCount >= 2) { - pSurfaceFormats[1].pNext = nullptr; - pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM; - pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - if (*pSurfaceFormatCount >= 1) { - pSurfaceFormats[1].pNext = nullptr; - pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM; - pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceSurfaceSupportKHR': ''' - // Currently say that all surface/queue combos are supported - *pSupported = VK_TRUE; - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceSurfaceCapabilitiesKHR': ''' - // In general just say max supported is available for requested surface - pSurfaceCapabilities->minImageCount = 1; - pSurfaceCapabilities->maxImageCount = 0; - pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF; - pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF; - pSurfaceCapabilities->minImageExtent.width = 1; - pSurfaceCapabilities->minImageExtent.height = 1; - pSurfaceCapabilities->maxImageExtent.width = 0xFFFF; - pSurfaceCapabilities->maxImageExtent.height = 0xFFFF; - pSurfaceCapabilities->maxImageArrayLayers = 128; - pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR | - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; - pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; - pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR | - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR | - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; - pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | - VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | - VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceSurfaceCapabilities2KHR': ''' - GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities); - - auto *present_mode_compatibility = lvl_find_mod_in_chain<VkSurfacePresentModeCompatibilityEXT>(pSurfaceCapabilities->pNext); - if (present_mode_compatibility) { - if (!present_mode_compatibility->pPresentModes) { - present_mode_compatibility->presentModeCount = 3; - } else { - // arbitrary - present_mode_compatibility->pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR; - present_mode_compatibility->pPresentModes[1] = VK_PRESENT_MODE_FIFO_KHR; - present_mode_compatibility->pPresentModes[2] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR; - } - } - return VK_SUCCESS; -''', -'vkGetInstanceProcAddr': ''' - if (!negotiate_loader_icd_interface_called) { - loader_interface_version = 0; - } - const auto &item = name_to_funcptr_map.find(pName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast<PFN_vkVoidFunction>(item->second); - } - // Mock should intercept all functions so if we get here just return null - return nullptr; -''', -'vkGetDeviceProcAddr': ''' - return GetInstanceProcAddr(nullptr, pName); -''', -'vkGetPhysicalDeviceMemoryProperties': ''' - pMemoryProperties->memoryTypeCount = 6; - // Host visible Coherent - pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - pMemoryProperties->memoryTypes[0].heapIndex = 0; - // Host visible Cached - pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; - pMemoryProperties->memoryTypes[1].heapIndex = 0; - // Device local and Host visible - pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - pMemoryProperties->memoryTypes[2].heapIndex = 1; - // Device local lazily - pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; - pMemoryProperties->memoryTypes[3].heapIndex = 1; - // Device local protected - pMemoryProperties->memoryTypes[4].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_PROTECTED_BIT; - pMemoryProperties->memoryTypes[4].heapIndex = 1; - // Device local only - pMemoryProperties->memoryTypes[5].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - pMemoryProperties->memoryTypes[5].heapIndex = 1; - pMemoryProperties->memoryHeapCount = 2; - pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT; - pMemoryProperties->memoryHeaps[0].size = 8000000000; - pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; - pMemoryProperties->memoryHeaps[1].size = 8000000000; -''', -'vkGetPhysicalDeviceMemoryProperties2KHR': ''' - GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties); -''', -'vkGetPhysicalDeviceQueueFamilyProperties': ''' - if (pQueueFamilyProperties) { - std::vector<VkQueueFamilyProperties2KHR> props2(*pQueueFamilyPropertyCount, { - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR}); - GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, props2.data()); - for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) { - pQueueFamilyProperties[i] = props2[i].queueFamilyProperties; - } - } else { - GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, nullptr); - } -''', -'vkGetPhysicalDeviceQueueFamilyProperties2KHR': ''' - if (pQueueFamilyProperties) { - if (*pQueueFamilyPropertyCount >= 1) { - auto props = &pQueueFamilyProperties[0].queueFamilyProperties; - props->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT - | VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_PROTECTED_BIT; - props->queueCount = 1; - props->timestampValidBits = 16; - props->minImageTransferGranularity = {1,1,1}; - } - if (*pQueueFamilyPropertyCount >= 2) { - auto props = &pQueueFamilyProperties[1].queueFamilyProperties; - props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_DECODE_BIT_KHR; - props->queueCount = 1; - props->timestampValidBits = 16; - props->minImageTransferGranularity = {1,1,1}; - - auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[1].pNext); - if (status_query_props) { - status_query_props->queryResultStatusSupport = VK_TRUE; - } - auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[1].pNext); - if (video_props) { - video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR; - } - } - if (*pQueueFamilyPropertyCount >= 3) { - auto props = &pQueueFamilyProperties[2].queueFamilyProperties; - props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_ENCODE_BIT_KHR; - props->queueCount = 1; - props->timestampValidBits = 16; - props->minImageTransferGranularity = {1,1,1}; - - auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[2].pNext); - if (status_query_props) { - status_query_props->queryResultStatusSupport = VK_TRUE; - } - auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[2].pNext); - if (video_props) { - video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR - | VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR; - } - } - if (*pQueueFamilyPropertyCount > 3) { - *pQueueFamilyPropertyCount = 3; - } - } else { - *pQueueFamilyPropertyCount = 3; - } -''', -'vkGetPhysicalDeviceFeatures': ''' - uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); - VkBool32 *bool_array = &pFeatures->robustBufferAccess; - SetBoolArrayTrue(bool_array, num_bools); -''', -'vkGetPhysicalDeviceFeatures2KHR': ''' - GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); - uint32_t num_bools = 0; // Count number of VkBool32s in extension structs - VkBool32* feat_bools = nullptr; - auto vk_1_1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Features>(pFeatures->pNext); - if (vk_1_1_features) { - vk_1_1_features->protectedMemory = VK_TRUE; - } - auto vk_1_3_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Features>(pFeatures->pNext); - if (vk_1_3_features) { - vk_1_3_features->synchronization2 = VK_TRUE; - } - auto prot_features = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryFeatures>(pFeatures->pNext); - if (prot_features) { - prot_features->protectedMemory = VK_TRUE; - } - auto sync2_features = lvl_find_mod_in_chain<VkPhysicalDeviceSynchronization2FeaturesKHR>(pFeatures->pNext); - if (sync2_features) { - sync2_features->synchronization2 = VK_TRUE; - } - auto video_maintenance1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>(pFeatures->pNext); - if (video_maintenance1_features) { - video_maintenance1_features->videoMaintenance1 = VK_TRUE; - } - const auto *desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext); - if (desc_idx_features) { - const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing); - num_bools = bool_size/sizeof(VkBool32); - feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing; - SetBoolArrayTrue(feat_bools, num_bools); - } - const auto *blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext); - if (blendop_features) { - const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations); - num_bools = bool_size/sizeof(VkBool32); - feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations; - SetBoolArrayTrue(feat_bools, num_bools); - } - const auto *host_image_copy_features = lvl_find_in_chain<VkPhysicalDeviceHostImageCopyFeaturesEXT>(pFeatures->pNext); - if (host_image_copy_features) { - feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy; - SetBoolArrayTrue(feat_bools, 1); - } -''', -'vkGetPhysicalDeviceFormatProperties': ''' - if (VK_FORMAT_UNDEFINED == format) { - *pFormatProperties = { 0x0, 0x0, 0x0 }; - } else { - // Default to a color format, skip DS bit - *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF }; - switch (format) { - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D32_SFLOAT: - case VK_FORMAT_S8_UINT: - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - // Don't set color bits for DS formats - *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F }; - break; - case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: - case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: - case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: - case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: - case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: - // Set decode/encode bits for these formats - *pFormatProperties = { 0x1EFFFDFF, 0x1EFFFDFF, 0x00FFFDFF }; - break; - default: - break; - } - } -''', -'vkGetPhysicalDeviceFormatProperties2KHR': ''' - GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties); - VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext); - if (props_3) { - props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures; - props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures; - props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures; - props_3->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT; - } -''', -'vkGetPhysicalDeviceImageFormatProperties': ''' - // A hardcoded unsupported format - if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) { - return VK_ERROR_FORMAT_NOT_SUPPORTED; - } - - // TODO: Just hard-coding some values for now - // TODO: If tiling is linear, limit the mips, levels, & sample count - if (VK_IMAGE_TILING_LINEAR == tiling) { - *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 }; - } else { - // We hard-code support for all sample counts except 64 bits. - *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 }; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceImageFormatProperties2KHR': ''' - auto *external_image_prop = lvl_find_mod_in_chain<VkExternalImageFormatProperties>(pImageFormatProperties->pNext); - auto *external_image_format = lvl_find_in_chain<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo->pNext); - if (external_image_prop && external_image_format) { - external_image_prop->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; - external_image_prop->externalMemoryProperties.compatibleHandleTypes = external_image_format->handleType; - } - - GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties); - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceSparseImageFormatProperties': ''' - if (!pProperties) { - *pPropertyCount = 1; - } else { - // arbitrary - pProperties->imageGranularity = {4, 4, 4}; - pProperties->flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; - switch (format) { - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_D32_SFLOAT: - pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; - break; - case VK_FORMAT_S8_UINT: - pProperties->aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; - break; - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; - break; - default: - pProperties->aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - break; - } - } -''', -'vkGetPhysicalDeviceSparseImageFormatProperties2KHR': ''' - if (pPropertyCount && pProperties) { - GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, &pProperties->properties); - } else { - GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr); - } -''', -'vkGetPhysicalDeviceProperties': ''' - pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE; - pProperties->driverVersion = 1; - pProperties->vendorID = 0xba5eba11; - pProperties->deviceID = 0xf005ba11; - pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; - //std::string devName = "Vulkan Mock Device"; - strcpy(pProperties->deviceName, "Vulkan Mock Device"); - pProperties->pipelineCacheUUID[0] = 18; - pProperties->limits = SetLimits(&pProperties->limits); - pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE }; -''', -'vkGetPhysicalDeviceProperties2KHR': ''' - // The only value that need to be set are those the Profile layer can't set - // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352 - // All values set are arbitrary - GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); - - auto *props_11 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Properties>(pProperties->pNext); - if (props_11) { - props_11->protectedNoFault = VK_FALSE; - } - - auto *props_12 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan12Properties>(pProperties->pNext); - if (props_12) { - props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - } - - auto *props_13 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Properties>(pProperties->pNext); - if (props_13) { - props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - props_13->storageTexelBufferOffsetAlignmentBytes = 16; - props_13->uniformTexelBufferOffsetAlignmentBytes = 16; - } - - auto *protected_memory_props = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryProperties>(pProperties->pNext); - if (protected_memory_props) { - protected_memory_props->protectedNoFault = VK_FALSE; - } - - auto *float_controls_props = lvl_find_mod_in_chain<VkPhysicalDeviceFloatControlsProperties>(pProperties->pNext); - if (float_controls_props) { - float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - } - - auto *conservative_raster_props = lvl_find_mod_in_chain<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(pProperties->pNext); - if (conservative_raster_props) { - conservative_raster_props->primitiveOverestimationSize = 0.00195313f; - conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE; - conservative_raster_props->degenerateTrianglesRasterized = VK_TRUE; - conservative_raster_props->degenerateLinesRasterized = VK_TRUE; - } - - auto *rt_pipeline_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(pProperties->pNext); - if (rt_pipeline_props) { - rt_pipeline_props->shaderGroupHandleSize = 32; - rt_pipeline_props->shaderGroupBaseAlignment = 64; - rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32; - } - - auto *rt_pipeline_nv_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPropertiesNV>(pProperties->pNext); - if (rt_pipeline_nv_props) { - rt_pipeline_nv_props->shaderGroupHandleSize = 32; - rt_pipeline_nv_props->shaderGroupBaseAlignment = 64; - } - - auto *texel_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceTexelBufferAlignmentProperties>(pProperties->pNext); - if (texel_buffer_props) { - texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - texel_buffer_props->storageTexelBufferOffsetAlignmentBytes = 16; - texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16; - } - - auto *descriptor_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(pProperties->pNext); - if (descriptor_buffer_props) { - descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE; - descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE; - descriptor_buffer_props->allowSamplerImageViewPostSubmitCreation = VK_TRUE; - descriptor_buffer_props->descriptorBufferOffsetAlignment = 4; - } - - auto *mesh_shader_props = lvl_find_mod_in_chain<VkPhysicalDeviceMeshShaderPropertiesEXT>(pProperties->pNext); - if (mesh_shader_props) { - mesh_shader_props->meshOutputPerVertexGranularity = 32; - mesh_shader_props->meshOutputPerPrimitiveGranularity = 32; - mesh_shader_props->prefersLocalInvocationVertexOutput = VK_TRUE; - mesh_shader_props->prefersLocalInvocationPrimitiveOutput = VK_TRUE; - mesh_shader_props->prefersCompactVertexOutput = VK_TRUE; - mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE; - } - - auto *fragment_density_map2_props = lvl_find_mod_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext); - if (fragment_density_map2_props) { - fragment_density_map2_props->subsampledLoads = VK_FALSE; - fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE; - fragment_density_map2_props->maxSubsampledArrayLayers = 2; - fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1; - } - - const uint32_t num_copy_layouts = 5; - const VkImageLayout HostCopyLayouts[]{ - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_GENERAL, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, - }; - - auto *host_image_copy_props = lvl_find_mod_in_chain<VkPhysicalDeviceHostImageCopyPropertiesEXT>(pProperties->pNext); - if (host_image_copy_props){ - if (host_image_copy_props->pCopyDstLayouts == nullptr) host_image_copy_props->copyDstLayoutCount = num_copy_layouts; - else { - uint32_t num_layouts = (std::min)(host_image_copy_props->copyDstLayoutCount, num_copy_layouts); - for (uint32_t i = 0; i < num_layouts; i++) { - host_image_copy_props->pCopyDstLayouts[i] = HostCopyLayouts[i]; - } - } - if (host_image_copy_props->pCopySrcLayouts == nullptr) host_image_copy_props->copySrcLayoutCount = num_copy_layouts; - else { - uint32_t num_layouts = (std::min)(host_image_copy_props->copySrcLayoutCount, num_copy_layouts); - for (uint32_t i = 0; i < num_layouts; i++) { - host_image_copy_props->pCopySrcLayouts[i] = HostCopyLayouts[i]; - } - } - } - - auto *driver_properties = lvl_find_mod_in_chain<VkPhysicalDeviceDriverProperties>(pProperties->pNext); - if (driver_properties) { - std::strncpy(driver_properties->driverName, "Vulkan Mock Device", VK_MAX_DRIVER_NAME_SIZE); -#if defined(GIT_BRANCH_NAME) && defined(GIT_TAG_INFO) - std::strncpy(driver_properties->driverInfo, "Branch: " GIT_BRANCH_NAME " Tag Info: " GIT_TAG_INFO, VK_MAX_DRIVER_INFO_SIZE); -#else - std::strncpy(driver_properties->driverInfo, "Branch: --unknown-- Tag Info: --unknown--", VK_MAX_DRIVER_INFO_SIZE); -#endif - } -''', -'vkGetPhysicalDeviceExternalSemaphoreProperties':''' - // Hard code support for all handle types and features - pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F; - pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F; - pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3; -''', -'vkGetPhysicalDeviceExternalSemaphorePropertiesKHR':''' - GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); -''', -'vkGetPhysicalDeviceExternalFenceProperties':''' - // Hard-code support for all handle types and features - pExternalFenceProperties->exportFromImportedHandleTypes = 0xF; - pExternalFenceProperties->compatibleHandleTypes = 0xF; - pExternalFenceProperties->externalFenceFeatures = 0x3; -''', -'vkGetPhysicalDeviceExternalFencePropertiesKHR':''' - GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); -''', -'vkGetPhysicalDeviceExternalBufferProperties':''' - constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF; - if (pExternalBufferInfo->handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) { - // Can't have dedicated memory with AHB - pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT; - pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = pExternalBufferInfo->handleType; - pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; - } else if (pExternalBufferInfo->handleType & supported_flags) { - pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7; - pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = supported_flags; - pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = supported_flags; - } else { - pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0; - pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0; - // According to spec, handle type is always compatible with itself. Even if export/import - // not supported, it's important to properly implement self-compatibility property since - // application's control flow can rely on this. - pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; - } -''', -'vkGetPhysicalDeviceExternalBufferPropertiesKHR':''' - GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); -''', -'vkGetBufferMemoryRequirements': ''' - // TODO: Just hard-coding reqs for now - pMemoryRequirements->size = 4096; - pMemoryRequirements->alignment = 1; - pMemoryRequirements->memoryTypeBits = 0xFFFF; - // Return a better size based on the buffer size from the create info. - unique_lock_t lock(global_lock); - auto d_iter = buffer_map.find(device); - if (d_iter != buffer_map.end()) { - auto iter = d_iter->second.find(buffer); - if (iter != d_iter->second.end()) { - pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096; - } - } -''', -'vkGetBufferMemoryRequirements2KHR': ''' - GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); -''', -'vkGetDeviceBufferMemoryRequirements': ''' - // TODO: Just hard-coding reqs for now - pMemoryRequirements->memoryRequirements.alignment = 1; - pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; - - // Return a size based on the buffer size from the create info. - pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096; -''', -'vkGetDeviceBufferMemoryRequirementsKHR': ''' - GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); -''', -'vkGetImageMemoryRequirements': ''' - pMemoryRequirements->size = 0; - pMemoryRequirements->alignment = 1; - - unique_lock_t lock(global_lock); - auto d_iter = image_memory_size_map.find(device); - if(d_iter != image_memory_size_map.end()){ - auto iter = d_iter->second.find(image); - if (iter != d_iter->second.end()) { - pMemoryRequirements->size = iter->second; - } - } - // Here we hard-code that the memory type at index 3 doesn't support this image. - pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3); -''', -'vkGetImageMemoryRequirements2KHR': ''' - GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements); -''', -'vkGetDeviceImageMemoryRequirements': ''' - pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo); - pMemoryRequirements->memoryRequirements.alignment = 1; - // Here we hard-code that the memory type at index 3 doesn't support this image. - pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3); -''', -'vkGetDeviceImageMemoryRequirementsKHR': ''' - GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); -''', -'vkMapMemory': ''' - unique_lock_t lock(global_lock); - if (VK_WHOLE_SIZE == size) { - if (allocated_memory_size_map.count(memory) != 0) - size = allocated_memory_size_map[memory] - offset; - else - size = 0x10000; - } - void* map_addr = malloc((size_t)size); - mapped_memory_map[memory].push_back(map_addr); - *ppData = map_addr; - return VK_SUCCESS; -''', -'vkMapMemory2KHR': ''' - return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData); -''', -'vkUnmapMemory': ''' - unique_lock_t lock(global_lock); - for (auto map_addr : mapped_memory_map[memory]) { - free(map_addr); - } - mapped_memory_map.erase(memory); -''', -'vkUnmapMemory2KHR': ''' - UnmapMemory(device, pMemoryUnmapInfo->memory); - return VK_SUCCESS; -''', -'vkGetImageSubresourceLayout': ''' - // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. - *pLayout = VkSubresourceLayout(); // Default constructor zero values. -''', -'vkCreateSwapchainKHR': ''' - unique_lock_t lock(global_lock); - *pSwapchain = (VkSwapchainKHR)global_unique_handle++; - for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){ - swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++; - } - return VK_SUCCESS; -''', -'vkDestroySwapchainKHR': ''' - unique_lock_t lock(global_lock); - swapchain_image_map.clear(); -''', -'vkGetSwapchainImagesKHR': ''' - if (!pSwapchainImages) { - *pSwapchainImageCount = icd_swapchain_image_count; - } else { - unique_lock_t lock(global_lock); - for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){ - pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i]; - } - - if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE; - else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count; - } - return VK_SUCCESS; -''', -'vkAcquireNextImageKHR': ''' - *pImageIndex = 0; - return VK_SUCCESS; -''', -'vkAcquireNextImage2KHR': ''' - *pImageIndex = 0; - return VK_SUCCESS; -''', -'vkCreateBuffer': ''' - unique_lock_t lock(global_lock); - *pBuffer = (VkBuffer)global_unique_handle++; - buffer_map[device][*pBuffer] = { - pCreateInfo->size, - current_available_address - }; - current_available_address += pCreateInfo->size; - // Always align to next 64-bit pointer - const uint64_t alignment = current_available_address % 64; - if (alignment != 0) { - current_available_address += (64 - alignment); - } - return VK_SUCCESS; -''', -'vkDestroyBuffer': ''' - unique_lock_t lock(global_lock); - buffer_map[device].erase(buffer); -''', -'vkCreateImage': ''' - unique_lock_t lock(global_lock); - *pImage = (VkImage)global_unique_handle++; - image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo); - return VK_SUCCESS; -''', -'vkDestroyImage': ''' - unique_lock_t lock(global_lock); - image_memory_size_map[device].erase(image); -''', -'vkEnumeratePhysicalDeviceGroupsKHR': ''' - if (!pPhysicalDeviceGroupProperties) { - *pPhysicalDeviceGroupCount = 1; - } else { - // arbitrary - pPhysicalDeviceGroupProperties->physicalDeviceCount = 1; - pPhysicalDeviceGroupProperties->physicalDevices[0] = physical_device_map.at(instance)[0]; - pPhysicalDeviceGroupProperties->subsetAllocation = VK_FALSE; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceMultisamplePropertiesEXT': ''' - if (pMultisampleProperties) { - // arbitrary - pMultisampleProperties->maxSampleLocationGridSize = {32, 32}; - } -''', -'vkGetPhysicalDeviceFragmentShadingRatesKHR': ''' - if (!pFragmentShadingRates) { - *pFragmentShadingRateCount = 1; - } else { - // arbitrary - pFragmentShadingRates->sampleCounts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT; - pFragmentShadingRates->fragmentSize = {8, 8}; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceCalibrateableTimeDomainsEXT': ''' - if (!pTimeDomains) { - *pTimeDomainCount = 1; - } else { - // arbitrary - *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceCalibrateableTimeDomainsKHR': ''' - if (!pTimeDomains) { - *pTimeDomainCount = 1; - } else { - // arbitrary - *pTimeDomains = VK_TIME_DOMAIN_DEVICE_KHR; - } - return VK_SUCCESS; -''', -'vkGetFenceWin32HandleKHR': ''' - *pHandle = (HANDLE)0x12345678; - return VK_SUCCESS; -''', -'vkGetFenceFdKHR': ''' - *pFd = 0x42; - return VK_SUCCESS; -''', -'vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR': ''' - if (!pCounters) { - *pCounterCount = 3; - } else { - if (*pCounterCount == 0){ - return VK_INCOMPLETE; - } - // arbitrary - pCounters[0].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; - pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR; - pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; - pCounters[0].uuid[0] = 0x01; - if (*pCounterCount == 1){ - return VK_INCOMPLETE; - } - pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; - pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR; - pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; - pCounters[1].uuid[0] = 0x02; - if (*pCounterCount == 2){ - return VK_INCOMPLETE; - } - pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; - pCounters[2].scope = VK_QUERY_SCOPE_COMMAND_KHR; - pCounters[2].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; - pCounters[2].uuid[0] = 0x03; - *pCounterCount = 3; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR': ''' - if (pNumPasses) { - // arbitrary - *pNumPasses = 1; - } -''', -'vkGetShaderModuleIdentifierEXT': ''' - if (pIdentifier) { - // arbitrary - pIdentifier->identifierSize = 1; - pIdentifier->identifier[0] = 0x01; - } -''', -'vkGetImageSparseMemoryRequirements': ''' - if (!pSparseMemoryRequirements) { - *pSparseMemoryRequirementCount = 1; - } else { - // arbitrary - pSparseMemoryRequirements->imageMipTailFirstLod = 0; - pSparseMemoryRequirements->imageMipTailSize = 8; - pSparseMemoryRequirements->imageMipTailOffset = 0; - pSparseMemoryRequirements->imageMipTailStride = 4; - pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4}; - pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; - // Would need to track the VkImage to know format for better value here - pSparseMemoryRequirements->formatProperties.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; - } - -''', -'vkGetImageSparseMemoryRequirements2KHR': ''' - if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) { - GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements); - } else { - GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr); - } -''', -'vkGetBufferDeviceAddress': ''' - VkDeviceAddress address = 0; - auto d_iter = buffer_map.find(device); - if (d_iter != buffer_map.end()) { - auto iter = d_iter->second.find(pInfo->buffer); - if (iter != d_iter->second.end()) { - address = iter->second.address; - } - } - return address; -''', -'vkGetBufferDeviceAddressKHR': ''' - return GetBufferDeviceAddress(device, pInfo); -''', -'vkGetBufferDeviceAddressEXT': ''' - return GetBufferDeviceAddress(device, pInfo); -''', -'vkGetDescriptorSetLayoutSizeEXT': ''' - // Need to give something non-zero - *pLayoutSizeInBytes = 4; -''', -'vkGetAccelerationStructureBuildSizesKHR': ''' - // arbitrary - pSizeInfo->accelerationStructureSize = 4; - pSizeInfo->updateScratchSize = 4; - pSizeInfo->buildScratchSize = 4; -''', -'vkGetAccelerationStructureMemoryRequirementsNV': ''' - // arbitrary - pMemoryRequirements->memoryRequirements.size = 4096; - pMemoryRequirements->memoryRequirements.alignment = 1; - pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; -''', -'vkGetAccelerationStructureDeviceAddressKHR': ''' - // arbitrary - need to be aligned to 256 bytes - return 0x262144; -''', -'vkGetVideoSessionMemoryRequirementsKHR': ''' - if (!pMemoryRequirements) { - *pMemoryRequirementsCount = 1; - } else { - // arbitrary - pMemoryRequirements[0].memoryBindIndex = 0; - pMemoryRequirements[0].memoryRequirements.size = 4096; - pMemoryRequirements[0].memoryRequirements.alignment = 1; - pMemoryRequirements[0].memoryRequirements.memoryTypeBits = 0xFFFF; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR': ''' - if (!pProperties) { - *pPropertyCount = 2; - } else { - // arbitrary - pProperties[0].MSize = 16; - pProperties[0].NSize = 16; - pProperties[0].KSize = 16; - pProperties[0].AType = VK_COMPONENT_TYPE_UINT32_KHR; - pProperties[0].BType = VK_COMPONENT_TYPE_UINT32_KHR; - pProperties[0].CType = VK_COMPONENT_TYPE_UINT32_KHR; - pProperties[0].ResultType = VK_COMPONENT_TYPE_UINT32_KHR; - pProperties[0].saturatingAccumulation = VK_FALSE; - pProperties[0].scope = VK_SCOPE_SUBGROUP_KHR; - - pProperties[1] = pProperties[0]; - pProperties[1].scope = VK_SCOPE_DEVICE_KHR; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceVideoCapabilitiesKHR': ''' - // We include some reasonable set of capability combinations to cover a wide range of use cases - auto caps = pCapabilities; - auto caps_decode = lvl_find_mod_in_chain<VkVideoDecodeCapabilitiesKHR>(pCapabilities->pNext); - auto caps_decode_h264 = lvl_find_mod_in_chain<VkVideoDecodeH264CapabilitiesKHR>(pCapabilities->pNext); - auto caps_decode_h265 = lvl_find_mod_in_chain<VkVideoDecodeH265CapabilitiesKHR>(pCapabilities->pNext); - auto caps_decode_av1 = lvl_find_mod_in_chain<VkVideoDecodeAV1CapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode = lvl_find_mod_in_chain<VkVideoEncodeCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeQuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h264_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeH264QuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h265_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeH265QuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_av1_quantization_map = - lvl_find_mod_in_chain<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h264 = lvl_find_mod_in_chain<VkVideoEncodeH264CapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_h265 = lvl_find_mod_in_chain<VkVideoEncodeH265CapabilitiesKHR>(pCapabilities->pNext); - auto caps_encode_av1 = lvl_find_mod_in_chain<VkVideoEncodeAV1CapabilitiesKHR>(pCapabilities->pNext); - - switch (pVideoProfile->videoCodecOperation) { - case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoDecodeH264ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_BASELINE && - profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 256; - caps->minBitstreamBufferSizeAlignment = 256; - caps->pictureAccessGranularity = {16,16}; - caps->minCodedExtent = {16,16}; - caps->maxCodedExtent = {1920,1080}; - caps->maxDpbSlots = 33; - caps->maxActiveReferencePictures = 32; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; - caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_2; - caps_decode_h264->fieldOffsetGranularity = {0,0}; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR && - profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_5_0; - caps_decode_h264->fieldOffsetGranularity = {0,16}; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR && - profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR - | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_3_2; - caps_decode_h264->fieldOffsetGranularity = {0,1}; - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoDecodeH265ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 64; - caps->minBitstreamBufferSizeAlignment = 64; - caps->pictureAccessGranularity = {32,32}; - caps->minCodedExtent = {48,48}; - caps->maxCodedExtent = {3840,2160}; - caps->maxDpbSlots = 16; - caps->maxActiveReferencePictures = 15; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; - caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_0; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_5_2; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR - | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_4_1; - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoDecodeAV1ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfile != STD_VIDEO_AV1_PROFILE_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 256; - caps->minBitstreamBufferSizeAlignment = 256; - caps->pictureAccessGranularity = {16,16}; - caps->minCodedExtent = {16,16}; - caps->maxCodedExtent = {1920,1080}; - caps->maxDpbSlots = 8; - caps->maxActiveReferencePictures = 7; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; - caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_6_2; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - if (profile->filmGrainSupport) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_5_0; - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR - | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_3_2; - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoEncodeH264ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_BASELINE) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 4096; - caps->minBitstreamBufferSizeAlignment = 4096; - caps->pictureAccessGranularity = {16,16}; - caps->minCodedExtent = {160,128}; - caps->maxCodedExtent = {1920,1080}; - caps->maxDpbSlots = 10; - caps->maxActiveReferencePictures = 4; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME, - sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 4; - caps_encode->maxBitrate = 800000000; - caps_encode->maxQualityLevels = 4; - caps_encode->encodeInputPictureGranularity = {16,16}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; - caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR; - caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_2; - caps_encode_h264->maxSliceCount = 8; - caps_encode_h264->maxPPictureL0ReferenceCount = 4; - caps_encode_h264->maxBPictureL0ReferenceCount = 3; - caps_encode_h264->maxL1ReferenceCount = 2; - caps_encode_h264->maxTemporalLayerCount = 4; - caps_encode_h264->expectDyadicTemporalLayerPattern = VK_FALSE; - caps_encode_h264->minQp = 0; - caps_encode_h264->maxQp = 51; - caps_encode_h264->prefersGopRemainingFrames = VK_FALSE; - caps_encode_h264->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 15) / 16, - (caps->maxCodedExtent.height + 15) / 16}; - } - - if (caps_encode_h264_quantization_map) { - caps_encode_h264_quantization_map->minQpDelta = -26; - caps_encode_h264_quantization_map->maxQpDelta = +25; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 480000000; - caps_encode->maxQualityLevels = 3; - caps_encode->encodeInputPictureGranularity = {32,32}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR; - caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_1; - caps_encode_h264->maxSliceCount = 4; - caps_encode_h264->maxPPictureL0ReferenceCount = 4; - caps_encode_h264->maxBPictureL0ReferenceCount = 0; - caps_encode_h264->maxL1ReferenceCount = 0; - caps_encode_h264->maxTemporalLayerCount = 4; - caps_encode_h264->expectDyadicTemporalLayerPattern = VK_TRUE; - caps_encode_h264->minQp = 0; - caps_encode_h264->maxQp = 30; - caps_encode_h264->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h264->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 15) / 16, - (caps->maxCodedExtent.height + 15) / 16}; - } - - if (caps_encode_h264_quantization_map) { - caps_encode_h264_quantization_map->minQpDelta = 0; - caps_encode_h264_quantization_map->maxQpDelta = 0; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_encode->flags = 0; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 240000000; - caps_encode->maxQualityLevels = 1; - caps_encode->encodeInputPictureGranularity = {1,1}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR; - caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_5_1; - caps_encode_h264->maxSliceCount = 1; - caps_encode_h264->maxPPictureL0ReferenceCount = 0; - caps_encode_h264->maxBPictureL0ReferenceCount = 2; - caps_encode_h264->maxL1ReferenceCount = 2; - caps_encode_h264->maxTemporalLayerCount = 1; - caps_encode_h264->expectDyadicTemporalLayerPattern = VK_FALSE; - caps_encode_h264->minQp = 5; - caps_encode_h264->maxQp = 40; - caps_encode_h264->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h264->requiresGopRemainingFrames = VK_TRUE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {0, 0}; - } - - if (caps_encode_h264_quantization_map) { - caps_encode_h264_quantization_map->minQpDelta = 0; - caps_encode_h264_quantization_map->maxQpDelta = 0; - } - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoEncodeH265ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 1; - caps->minBitstreamBufferSizeAlignment = 1; - caps->pictureAccessGranularity = {8,8}; - caps->minCodedExtent = {64,48}; - caps->maxCodedExtent = {4096,2560}; - caps->maxDpbSlots = 8; - caps->maxActiveReferencePictures = 2; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME, sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 800000000; - caps_encode->maxQualityLevels = 1; - caps_encode->encodeInputPictureGranularity = {64,64}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR; - caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_2; - caps_encode_h265->maxSliceSegmentCount = 8; - caps_encode_h265->maxTiles = {1,1}; - caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR - | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; - caps_encode_h265->maxPPictureL0ReferenceCount = 4; - caps_encode_h265->maxBPictureL0ReferenceCount = 3; - caps_encode_h265->maxL1ReferenceCount = 2; - caps_encode_h265->maxSubLayerCount = 1; - caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_FALSE; - caps_encode_h265->minQp = 16; - caps_encode_h265->maxQp = 32; - caps_encode_h265->prefersGopRemainingFrames = VK_FALSE; - caps_encode_h265->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 3) / 4, - (caps->maxCodedExtent.height + 3) / 4}; - } - - if (caps_encode_h265_quantization_map) { - caps_encode_h265_quantization_map->minQpDelta = -16; - caps_encode_h265_quantization_map->maxQpDelta = +15; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR; - caps_encode->maxRateControlLayers = 0; - caps_encode->maxBitrate = 480000000; - caps_encode->maxQualityLevels = 2; - caps_encode->encodeInputPictureGranularity = {32,32}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR; - caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_1; - caps_encode_h265->maxSliceSegmentCount = 4; - caps_encode_h265->maxTiles = {2,2}; - caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR - | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR - | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; - caps_encode_h265->maxPPictureL0ReferenceCount = 4; - caps_encode_h265->maxBPictureL0ReferenceCount = 0; - caps_encode_h265->maxL1ReferenceCount = 0; - caps_encode_h265->maxSubLayerCount = 1; - caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_FALSE; - caps_encode_h265->minQp = 0; - caps_encode_h265->maxQp = 51; - caps_encode_h265->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h265->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 31) / 32, - (caps->maxCodedExtent.height + 31) / 32}; - } - - if (caps_encode_h265_quantization_map) { - caps_encode_h265_quantization_map->minQpDelta = 0; - caps_encode_h265_quantization_map->maxQpDelta = 0; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 2; - caps_encode->maxBitrate = 240000000; - caps_encode->maxQualityLevels = 3; - caps_encode->encodeInputPictureGranularity = {16,16}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; - caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR - | VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR; - caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_5_1; - caps_encode_h265->maxSliceSegmentCount = 1; - caps_encode_h265->maxTiles = {2,2}; - caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR; - caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; - caps_encode_h265->maxPPictureL0ReferenceCount = 0; - caps_encode_h265->maxBPictureL0ReferenceCount = 2; - caps_encode_h265->maxL1ReferenceCount = 2; - caps_encode_h265->maxSubLayerCount = 4; - caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_TRUE; - caps_encode_h265->minQp = 16; - caps_encode_h265->maxQp = 51; - caps_encode_h265->prefersGopRemainingFrames = VK_TRUE; - caps_encode_h265->requiresGopRemainingFrames = VK_TRUE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {0, 0}; - } - - if (caps_encode_h265_quantization_map) { - caps_encode_h265_quantization_map->minQpDelta = 0; - caps_encode_h265_quantization_map->maxQpDelta = 0; - } - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: { - auto profile = lvl_find_in_chain<VkVideoEncodeAV1ProfileInfoKHR>(pVideoProfile->pNext); - if (profile->stdProfile != STD_VIDEO_AV1_PROFILE_MAIN) { - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - - caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; - caps->minBitstreamBufferOffsetAlignment = 1; - caps->minBitstreamBufferSizeAlignment = 1; - caps->pictureAccessGranularity = {8,8}; - caps->minCodedExtent = {192,128}; - caps->maxCodedExtent = {4096,2560}; - caps->maxDpbSlots = 8; - caps->maxActiveReferencePictures = 2; - std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME, sizeof(caps->stdHeaderVersion.extensionName)); - caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION; - - switch (pVideoProfile->chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; - caps_encode->maxRateControlLayers = 1; - caps_encode->maxBitrate = 800000000; - caps_encode->maxQualityLevels = 1; - caps_encode->encodeInputPictureGranularity = {64,64}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_av1->flags = VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR; - caps_encode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_6_2; - caps_encode_av1->maxTiles = {1,1}; - caps_encode_av1->minTileSize = {64,64}; - caps_encode_av1->maxTileSize = {4096,2560}; - caps_encode_av1->superblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - caps_encode_av1->maxSingleReferenceCount = 1; - caps_encode_av1->singleReferenceNameMask = 0x7B; - caps_encode_av1->maxUnidirectionalCompoundReferenceCount = 0; - caps_encode_av1->maxUnidirectionalCompoundGroup1ReferenceCount = 0; - caps_encode_av1->unidirectionalCompoundReferenceNameMask = 0x00; - caps_encode_av1->maxBidirectionalCompoundReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup1ReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup2ReferenceCount = 0; - caps_encode_av1->bidirectionalCompoundReferenceNameMask = 0x00; - caps_encode_av1->maxTemporalLayerCount = 1; - caps_encode_av1->maxSpatialLayerCount = 1; - caps_encode_av1->maxOperatingPoints = 1; - caps_encode_av1->minQIndex = 32; - caps_encode_av1->maxQIndex = 128; - caps_encode_av1->prefersGopRemainingFrames = VK_FALSE; - caps_encode_av1->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 7) / 8, - (caps->maxCodedExtent.height + 7) / 8}; - } - - if (caps_encode_av1_quantization_map) { - caps_encode_av1_quantization_map->minQIndexDelta = -64; - caps_encode_av1_quantization_map->maxQIndexDelta = +64; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR; - caps_encode->maxRateControlLayers = 0; - caps_encode->maxBitrate = 480000000; - caps_encode->maxQualityLevels = 2; - caps_encode->encodeInputPictureGranularity = {32,32}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; - caps_encode_av1->flags = VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR; - caps_encode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_6_1; - caps_encode_av1->maxTiles = {2,2}; - caps_encode_av1->minTileSize = {128,128}; - caps_encode_av1->maxTileSize = {4096,2048}; - caps_encode_av1->superblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR - | VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - caps_encode_av1->maxSingleReferenceCount = 0; - caps_encode_av1->singleReferenceNameMask = 0x00; - caps_encode_av1->maxUnidirectionalCompoundReferenceCount = 2; - caps_encode_av1->maxUnidirectionalCompoundGroup1ReferenceCount = 2; - caps_encode_av1->unidirectionalCompoundReferenceNameMask = 0x5F; - caps_encode_av1->maxBidirectionalCompoundReferenceCount = 2; - caps_encode_av1->maxBidirectionalCompoundGroup1ReferenceCount = 2; - caps_encode_av1->maxBidirectionalCompoundGroup2ReferenceCount = 2; - caps_encode_av1->bidirectionalCompoundReferenceNameMask = 0x5F; - caps_encode_av1->maxTemporalLayerCount = 4; - caps_encode_av1->maxSpatialLayerCount = 1; - caps_encode_av1->maxOperatingPoints = 4; - caps_encode_av1->minQIndex = 0; - caps_encode_av1->maxQIndex = 255; - caps_encode_av1->prefersGopRemainingFrames = VK_TRUE; - caps_encode_av1->requiresGopRemainingFrames = VK_FALSE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 63) / 64, - (caps->maxCodedExtent.height + 63) / 64}; - } - - if (caps_encode_av1_quantization_map) { - caps_encode_av1_quantization_map->minQIndexDelta = -255; - caps_encode_av1_quantization_map->maxQIndexDelta = +255; - } - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR - | VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR; - caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR - | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; - caps_encode->maxRateControlLayers = 2; - caps_encode->maxBitrate = 240000000; - caps_encode->maxQualityLevels = 3; - caps_encode->encodeInputPictureGranularity = {16,16}; - caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR - | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; - caps_encode_av1->flags = VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR - | VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR; - caps_encode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_5_1; - caps_encode_av1->maxTiles = {4,4}; - caps_encode_av1->minTileSize = {128,128}; - caps_encode_av1->maxTileSize = {2048,2048}; - caps_encode_av1->superblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - caps_encode_av1->maxSingleReferenceCount = 1; - caps_encode_av1->singleReferenceNameMask = 0x5F; - caps_encode_av1->maxUnidirectionalCompoundReferenceCount = 4; - caps_encode_av1->maxUnidirectionalCompoundGroup1ReferenceCount = 4; - caps_encode_av1->unidirectionalCompoundReferenceNameMask = 0x5B; - caps_encode_av1->maxBidirectionalCompoundReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup1ReferenceCount = 0; - caps_encode_av1->maxBidirectionalCompoundGroup2ReferenceCount = 0; - caps_encode_av1->bidirectionalCompoundReferenceNameMask = 0x00; - caps_encode_av1->maxTemporalLayerCount = 4; - caps_encode_av1->maxSpatialLayerCount = 2; - caps_encode_av1->maxOperatingPoints = 2; - caps_encode_av1->minQIndex = 16; - caps_encode_av1->maxQIndex = 96; - caps_encode_av1->prefersGopRemainingFrames = VK_TRUE; - caps_encode_av1->requiresGopRemainingFrames = VK_TRUE; - - if (caps_encode_quantization_map) { - caps_encode_quantization_map->maxQuantizationMapExtent = {(caps->maxCodedExtent.width + 127) / 128, - (caps->maxCodedExtent.height + 127) / 128}; - } - - if (caps_encode_av1_quantization_map) { - caps_encode_av1_quantization_map->minQIndexDelta = -64; - caps_encode_av1_quantization_map->maxQIndexDelta = +63; - } - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - } - default: - break; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceVideoFormatPropertiesKHR': ''' - // We include some reasonable set of format combinations to cover a wide range of use cases - auto profile_list = lvl_find_in_chain<VkVideoProfileListInfoKHR>(pVideoFormatInfo->pNext); - if (profile_list->profileCount != 1) { - return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR; - } - - struct VideoFormatProperties { - VkVideoFormatPropertiesKHR props; - VkVideoFormatQuantizationMapPropertiesKHR props_quantization_map; - VkVideoFormatH265QuantizationMapPropertiesKHR props_h265_quantization_map; - VkVideoFormatAV1QuantizationMapPropertiesKHR props_av1_quantization_map; - }; - - std::vector<VideoFormatProperties> format_props{}; - - VideoFormatProperties fmt = {}; - fmt.props.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; - fmt.props.imageCreateFlags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_ALIAS_BIT | - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT | VK_IMAGE_CREATE_PROTECTED_BIT | VK_IMAGE_CREATE_DISJOINT_BIT; - fmt.props.imageType = VK_IMAGE_TYPE_2D; - fmt.props.imageTiling = VK_IMAGE_TILING_OPTIMAL; - fmt.props_quantization_map.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; - fmt.props_h265_quantization_map.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; - fmt.props_av1_quantization_map.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; - - // Populate DPB and input/output formats - switch (profile_list->pProfiles[0].videoCodecOperation) { - case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: - case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - fmt.props.format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM; - fmt.props.imageUsageFlags = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; - format_props.push_back(fmt); - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; - format_props.push_back(fmt); - break; - default: - return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; - } - break; - - default: - break; - } - - // Populate quantization map formats - fmt.props.imageCreateFlags = VK_IMAGE_CREATE_PROTECTED_BIT; - fmt.props.imageTiling = VK_IMAGE_TILING_LINEAR; - switch (profile_list->pProfiles[0].videoCodecOperation) { - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {16, 16}; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {16, 16}; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - break; - default: - break; - } - break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {4, 4}; - fmt.props_h265_quantization_map.compatibleCtbSizes = - VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {8, 8}; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {32, 32}; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_h265_quantization_map.compatibleCtbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {32, 32}; - fmt.props_h265_quantization_map.compatibleCtbSizes = - VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_h265_quantization_map.compatibleCtbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - break; - default: - break; - } - break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: - switch (profile_list->pProfiles[0].chromaSubsampling) { - case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {8, 8}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: - fmt.props.format = VK_FORMAT_R32_SINT; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {64, 64}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR; - format_props.push_back(fmt); - fmt.props_quantization_map.quantizationMapTexelSize = {128, 128}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - format_props.push_back(fmt); - break; - case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: - fmt.props.format = VK_FORMAT_R8_UNORM; - fmt.props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR; - fmt.props_quantization_map.quantizationMapTexelSize = {128, 128}; - fmt.props_av1_quantization_map.compatibleSuperblockSizes = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR; - format_props.push_back(fmt); - break; - default: - break; - } - break; - - default: - break; - } - - std::vector<VideoFormatProperties> filtered; - for (const auto& format : format_props) { - if ((pVideoFormatInfo->imageUsage & format.props.imageUsageFlags) == pVideoFormatInfo->imageUsage) { - filtered.push_back(format); - } - } - - if (pVideoFormatProperties != nullptr) { - for (uint32_t i = 0; i < (std::min)(*pVideoFormatPropertyCount, (uint32_t)filtered.size()); ++i) { - void* saved_pNext = pVideoFormatProperties[i].pNext; - pVideoFormatProperties[i] = filtered[i].props; - pVideoFormatProperties[i].pNext = saved_pNext; - - auto* props_quantization_map = lvl_find_mod_in_chain<VkVideoFormatQuantizationMapPropertiesKHR>(saved_pNext); - auto* props_h265_quantization_map = lvl_find_mod_in_chain<VkVideoFormatH265QuantizationMapPropertiesKHR>(saved_pNext); - auto* props_av1_quantization_map = lvl_find_mod_in_chain<VkVideoFormatAV1QuantizationMapPropertiesKHR>(saved_pNext); - - if (props_quantization_map != nullptr) { - saved_pNext = props_quantization_map->pNext; - *props_quantization_map = filtered[i].props_quantization_map; - props_quantization_map->pNext = saved_pNext; - } - - if (props_h265_quantization_map != nullptr) { - saved_pNext = props_h265_quantization_map->pNext; - *props_h265_quantization_map = filtered[i].props_h265_quantization_map; - props_h265_quantization_map->pNext = saved_pNext; - } - - if (props_av1_quantization_map != nullptr) { - saved_pNext = props_av1_quantization_map->pNext; - *props_av1_quantization_map = filtered[i].props_av1_quantization_map; - props_av1_quantization_map->pNext = saved_pNext; - } - } - } - *pVideoFormatPropertyCount = (uint32_t)filtered.size(); - return VK_SUCCESS; -''', -'vkGetDescriptorSetLayoutSupport':''' - if (pSupport) { - pSupport->supported = VK_TRUE; - } -''', -'vkGetDescriptorSetLayoutSupportKHR':''' - GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); -''', -'vkGetRenderAreaGranularity': ''' - pGranularity->width = 1; - pGranularity->height = 1; -''', -'vkGetMemoryFdKHR': ''' - *pFd = 1; - return VK_SUCCESS; -''', -'vkGetMemoryHostPointerPropertiesEXT': ''' - pMemoryHostPointerProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type - return VK_SUCCESS; -''', -'vkGetAndroidHardwareBufferPropertiesANDROID': ''' - pProperties->allocationSize = 65536; - pProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type - - auto *format_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties->pNext); - if (format_prop) { - // Likley using this format - format_prop->format = VK_FORMAT_R8G8B8A8_UNORM; - format_prop->externalFormat = 37; - } - - auto *format_resolve_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(pProperties->pNext); - if (format_resolve_prop) { - format_resolve_prop->colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM; - } - return VK_SUCCESS; -''', -'vkGetPhysicalDeviceDisplayPropertiesKHR': ''' - if (!pProperties) { - *pPropertyCount = 1; - } else { - unique_lock_t lock(global_lock); - pProperties[0].display = (VkDisplayKHR)global_unique_handle++; - display_map[physicalDevice].insert(pProperties[0].display); - } - return VK_SUCCESS; -''', -'vkRegisterDisplayEventEXT': ''' - unique_lock_t lock(global_lock); - *pFence = (VkFence)global_unique_handle++; - return VK_SUCCESS; -''', -'vkQueueSubmit': ''' - // Special way to cause DEVICE_LOST - // Picked VkExportFenceCreateInfo because needed some struct that wouldn't get cleared by validation Safe Struct - // ... TODO - It would be MUCH nicer to have a layer or other setting control when this occured - // For now this is used to allow Validation Layers test reacting to device losts - if (submitCount > 0 && pSubmits) { - auto pNext = reinterpret_cast<const VkBaseInStructure *>(pSubmits[0].pNext); - if (pNext && pNext->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO && pNext->pNext == nullptr) { - return VK_ERROR_DEVICE_LOST; - } - } - return VK_SUCCESS; -''', -'vkGetMemoryWin32HandlePropertiesKHR': ''' - pMemoryWin32HandleProperties->memoryTypeBits = 0xFFFF; - return VK_SUCCESS; -''', -'vkCreatePipelineBinariesKHR': ''' - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) { - pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++; - } - return VK_SUCCESS; -''' -} - -# MockICDGeneratorOptions - subclass of GeneratorOptions. -# -# Adds options used by MockICDOutputGenerator objects during Mock -# ICD generation. -# -# Additional members -# prefixText - list of strings to prefix generated header with -# (usually a copyright statement + calling convention macros). -# protectFile - True if multiple inclusion protection should be -# generated (based on the filename) around the entire header. -# protectFeature - True if #ifndef..#endif protection should be -# generated around a feature interface in the header file. -# genFuncPointers - True if function pointer typedefs should be -# generated -# protectProto - If conditional protection should be generated -# around prototype declarations, set to either '#ifdef' -# to require opt-in (#ifdef protectProtoStr) or '#ifndef' -# to require opt-out (#ifndef protectProtoStr). Otherwise -# set to None. -# protectProtoStr - #ifdef/#ifndef symbol to use around prototype -# declarations, if protectProto is set -# apicall - string to use for the function declaration prefix, -# such as APICALL on Windows. -# apientry - string to use for the calling convention macro, -# in typedefs, such as APIENTRY. -# apientryp - string to use for the calling convention macro -# in function pointer typedefs, such as APIENTRYP. -# indentFuncProto - True if prototype declarations should put each -# parameter on a separate line -# indentFuncPointer - True if typedefed function pointers should put each -# parameter on a separate line -# alignFuncParam - if nonzero and parameters are being put on a -# separate line, align parameter names at the specified column -class MockICDGeneratorOptions(GeneratorOptions): - def __init__(self, - conventions = None, - filename = None, - directory = '.', - genpath = None, - apiname = None, - profile = None, - versions = '.*', - emitversions = '.*', - defaultExtensions = None, - addExtensions = None, - removeExtensions = None, - emitExtensions = None, - sortProcedure = regSortFeatures, - prefixText = "", - genFuncPointers = True, - protectFile = True, - protectFeature = True, - protectProto = None, - protectProtoStr = None, - apicall = '', - apientry = '', - apientryp = '', - indentFuncProto = True, - indentFuncPointer = False, - alignFuncParam = 0, - expandEnumerants = True, - helper_file_type = ''): - GeneratorOptions.__init__(self, - conventions = conventions, - filename = filename, - directory = directory, - genpath = genpath, - apiname = apiname, - profile = profile, - versions = versions, - emitversions = emitversions, - defaultExtensions = defaultExtensions, - addExtensions = addExtensions, - removeExtensions = removeExtensions, - emitExtensions = emitExtensions, - sortProcedure = sortProcedure) - self.prefixText = prefixText - self.genFuncPointers = genFuncPointers - self.protectFile = protectFile - self.protectFeature = protectFeature - self.protectProto = protectProto - self.protectProtoStr = protectProtoStr - self.apicall = apicall - self.apientry = apientry - self.apientryp = apientryp - self.indentFuncProto = indentFuncProto - self.indentFuncPointer = indentFuncPointer - self.alignFuncParam = alignFuncParam - -# MockICDOutputGenerator - subclass of OutputGenerator. -# Generates a mock vulkan ICD. -# This is intended to be a minimal replacement for a vulkan device in order -# to enable Vulkan Validation testing. -# -# ---- methods ---- -# MockOutputGenerator(errFile, warnFile, diagFile) - args as for -# OutputGenerator. Defines additional internal state. -# ---- methods overriding base class ---- -# beginFile(genOpts) -# endFile() -# beginFeature(interface, emit) -# endFeature() -# genType(typeinfo,name) -# genStruct(typeinfo,name) -# genGroup(groupinfo,name) -# genEnum(enuminfo, name) -# genCmd(cmdinfo) -class MockICDOutputGenerator(OutputGenerator): - """Generate specified API interfaces in a specific style, such as a C header""" - # This is an ordered list of sections in the header file. - TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum', - 'group', 'bitmask', 'funcpointer', 'struct'] - ALL_SECTIONS = TYPE_SECTIONS + ['command'] - def __init__(self, - errFile = sys.stderr, - warnFile = sys.stderr, - diagFile = sys.stdout): - OutputGenerator.__init__(self, errFile, warnFile, diagFile) - # Internal state - accumulators for different inner block text - self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) - self.intercepts = [] - self.function_declarations = False - - # Check if the parameter passed in is a pointer to an array - def paramIsArray(self, param): - return param.attrib.get('len') is not None - - # Check if the parameter passed in is a pointer - def paramIsPointer(self, param): - ispointer = False - for elem in param: - if ((elem.tag != 'type') and (elem.tail is not None)) and '*' in elem.tail: - ispointer = True - return ispointer - - # Check if an object is a non-dispatchable handle - def isHandleTypeNonDispatchable(self, handletype): - handle = self.registry.tree.find("types/type/[name='" + handletype + "'][@category='handle']") - if handle is not None and handle.find('type').text == 'VK_DEFINE_NON_DISPATCHABLE_HANDLE': - return True - else: - return False - - # Check if an object is a dispatchable handle - def isHandleTypeDispatchable(self, handletype): - handle = self.registry.tree.find("types/type/[name='" + handletype + "'][@category='handle']") - if handle is not None and handle.find('type').text == 'VK_DEFINE_HANDLE': - return True - else: - return False - - # Check that the target API is in the supported list for the extension - def checkExtensionAPISupport(self, supported): - return self.genOpts.apiname in supported.split(',') - - def beginFile(self, genOpts): - OutputGenerator.beginFile(self, genOpts) - # C-specific - # - # Multiple inclusion protection & C++ namespace. - if (genOpts.protectFile and self.genOpts.filename == "function_declarations.h"): - self.function_declarations = True - - # User-supplied prefix text, if any (list of strings) - if (genOpts.prefixText): - for s in genOpts.prefixText: - write(s, file=self.outFile) - - if self.function_declarations: - self.newline() - # Include all of the extensions in ICD except specific ignored ones - device_exts = [] - instance_exts = [] - # Ignore extensions that ICDs should not implement or are not safe to report - ignore_exts = ['VK_EXT_validation_cache', 'VK_KHR_portability_subset'] - for ext in self.registry.tree.findall("extensions/extension"): - if self.checkExtensionAPISupport(ext.attrib['supported']): # Only include API-relevant extensions - if (ext.attrib['name'] not in ignore_exts): - # Search for extension version enum - for enum in ext.findall('require/enum'): - if enum.get('name', '').endswith('_SPEC_VERSION'): - ext_version = enum.get('value') - if (ext.attrib.get('type') == 'instance'): - instance_exts.append(' {"%s", %s},' % (ext.attrib['name'], ext_version)) - else: - device_exts.append(' {"%s", %s},' % (ext.attrib['name'], ext_version)) - break - write('#pragma once\n',file=self.outFile) - write('#include <stdint.h>',file=self.outFile) - write('#include <cstring>',file=self.outFile) - write('#include <string>',file=self.outFile) - write('#include <unordered_map>',file=self.outFile) - write('#include <vulkan/vulkan.h>',file=self.outFile) - self.newline() - write('namespace vkmock {\n', file=self.outFile) - write('// Map of instance extension name to version', file=self.outFile) - write('static const std::unordered_map<std::string, uint32_t> instance_extension_map = {', file=self.outFile) - write('\n'.join(instance_exts), file=self.outFile) - write('};', file=self.outFile) - write('// Map of device extension name to version', file=self.outFile) - write('static const std::unordered_map<std::string, uint32_t> device_extension_map = {', file=self.outFile) - write('\n'.join(device_exts), file=self.outFile) - write('};', file=self.outFile) - else: - write('#pragma once\n',file=self.outFile) - write('#include "mock_icd.h"',file=self.outFile) - write('#include "function_declarations.h"\n',file=self.outFile) - write('namespace vkmock {', file=self.outFile) - - - def endFile(self): - # C-specific - # Finish C++ namespace - self.newline() - if self.function_declarations: - # record intercepted procedures - write('// Map of all APIs to be intercepted by this layer', file=self.outFile) - write('static const std::unordered_map<std::string, void*> name_to_funcptr_map = {', file=self.outFile) - write('\n'.join(self.intercepts), file=self.outFile) - write('};\n', file=self.outFile) - write('} // namespace vkmock', file=self.outFile) - self.newline() - - # Finish processing in superclass - OutputGenerator.endFile(self) - def beginFeature(self, interface, emit): - #write('// starting beginFeature', file=self.outFile) - # Start processing in superclass - OutputGenerator.beginFeature(self, interface, emit) - self.featureExtraProtect = GetFeatureProtect(interface) - # C-specific - # Accumulate includes, defines, types, enums, function pointer typedefs, - # end function prototypes separately for this feature. They're only - # printed in endFeature(). - self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) - #write('// ending beginFeature', file=self.outFile) - def endFeature(self): - # C-specific - # Actually write the interface to the output file. - #write('// starting endFeature', file=self.outFile) - if (self.emit): - self.newline() - if (self.genOpts.protectFeature): - write('#ifndef', self.featureName, file=self.outFile) - # If type declarations are needed by other features based on - # this one, it may be necessary to suppress the ExtraProtect, - # or move it below the 'for section...' loop. - #write('// endFeature looking at self.featureExtraProtect', file=self.outFile) - if (self.featureExtraProtect != None): - write('#ifdef', self.featureExtraProtect, file=self.outFile) - #write('#define', self.featureName, '1', file=self.outFile) - for section in self.TYPE_SECTIONS: - #write('// endFeature writing section'+section, file=self.outFile) - contents = self.sections[section] - if contents: - write('\n'.join(contents), file=self.outFile) - self.newline() - #write('// endFeature looking at self.sections[command]', file=self.outFile) - if (self.sections['command']): - write('\n'.join(self.sections['command']), end=u'', file=self.outFile) - self.newline() - if (self.featureExtraProtect != None): - write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile) - if (self.genOpts.protectFeature): - write('#endif /*', self.featureName, '*/', file=self.outFile) - # Finish processing in superclass - OutputGenerator.endFeature(self) - #write('// ending endFeature', file=self.outFile) - # - # Append a definition to the specified section - def appendSection(self, section, text): - # self.sections[section].append('SECTION: ' + section + '\n') - self.sections[section].append(text) - # - # Type generation - def genType(self, typeinfo, name, alias): - pass - # - # Struct (e.g. C "struct" type) generation. - # This is a special case of the <type> tag where the contents are - # interpreted as a set of <member> tags instead of freeform C - # C type declarations. The <member> tags are just like <param> - # tags - they are a declaration of a struct or union member. - # Only simple member declarations are supported (no nested - # structs etc.) - def genStruct(self, typeinfo, typeName, alias): - OutputGenerator.genStruct(self, typeinfo, typeName, alias) - body = 'typedef ' + typeinfo.elem.get('category') + ' ' + typeName + ' {\n' - # paramdecl = self.makeCParamDecl(typeinfo.elem, self.genOpts.alignFuncParam) - for member in typeinfo.elem.findall('.//member'): - body += self.makeCParamDecl(member, self.genOpts.alignFuncParam) - body += ';\n' - body += '} ' + typeName + ';\n' - self.appendSection('struct', body) - # - # Group (e.g. C "enum" type) generation. - # These are concatenated together with other types. - def genGroup(self, groupinfo, groupName, alias): - pass - # Enumerant generation - # <enum> tags may specify their values in several ways, but are usually - # just integers. - def genEnum(self, enuminfo, name, alias): - pass - # - # Command generation - def genCmd(self, cmdinfo, name, alias): - decls = self.makeCDecls(cmdinfo.elem) - if self.function_declarations: # In the header declare all intercepts - self.appendSection('command', '') - self.appendSection('command', 'static %s' % (decls[0])) - if (self.featureExtraProtect != None): - self.intercepts += [ '#ifdef %s' % self.featureExtraProtect ] - self.intercepts += [ ' {"%s", (void*)%s},' % (name,name[2:]) ] - if (self.featureExtraProtect != None): - self.intercepts += [ '#endif' ] - return - - manual_functions = [ - # Include functions here to be intercepted w/ manually implemented function bodies - 'vkGetDeviceProcAddr', - 'vkGetInstanceProcAddr', - 'vkCreateDevice', - 'vkDestroyDevice', - 'vkCreateInstance', - 'vkDestroyInstance', - 'vkFreeCommandBuffers', - 'vkAllocateCommandBuffers', - 'vkDestroyCommandPool', - #'vkCreateDebugReportCallbackEXT', - #'vkDestroyDebugReportCallbackEXT', - 'vkEnumerateInstanceLayerProperties', - 'vkEnumerateInstanceVersion', - 'vkEnumerateInstanceExtensionProperties', - 'vkEnumerateDeviceLayerProperties', - 'vkEnumerateDeviceExtensionProperties', - ] - if name in manual_functions: - self.appendSection('command', '') - if name not in CUSTOM_C_INTERCEPTS: - self.appendSection('command', '// declare only') - self.appendSection('command', 'static %s' % (decls[0])) - self.appendSection('command', '// TODO: Implement custom intercept body') - else: - self.appendSection('command', 'static %s' % (decls[0][:-1])) - self.appendSection('command', '{\n%s}' % (CUSTOM_C_INTERCEPTS[name])) - self.intercepts += [ ' {"%s", (void*)%s},' % (name,name[2:]) ] - return - # record that the function will be intercepted - if (self.featureExtraProtect != None): - self.intercepts += [ '#ifdef %s' % self.featureExtraProtect ] - self.intercepts += [ ' {"%s", (void*)%s},' % (name,name[2:]) ] - if (self.featureExtraProtect != None): - self.intercepts += [ '#endif' ] - - OutputGenerator.genCmd(self, cmdinfo, name, alias) - # - self.appendSection('command', '') - self.appendSection('command', 'static %s' % (decls[0][:-1])) - if name in CUSTOM_C_INTERCEPTS: - self.appendSection('command', '{%s}' % (CUSTOM_C_INTERCEPTS[name])) - return - - # Declare result variable, if any. - resulttype = cmdinfo.elem.find('proto/type') - if (resulttype != None and resulttype.text == 'void'): - resulttype = None - # if the name w/ KHR postfix is in the CUSTOM_C_INTERCEPTS - # Call the KHR custom version instead of generating separate code - khr_name = name + "KHR" - if khr_name in CUSTOM_C_INTERCEPTS: - return_string = '' - if resulttype != None: - return_string = 'return ' - params = cmdinfo.elem.findall('param/name') - param_names = [] - for param in params: - param_names.append(param.text) - self.appendSection('command', '{\n %s%s(%s);\n}' % (return_string, khr_name[2:], ", ".join(param_names))) - return - self.appendSection('command', '{') - - api_function_name = cmdinfo.elem.attrib.get('name') - # GET THE TYPE OF FUNCTION - if any(api_function_name.startswith(ftxt) for ftxt in ('vkCreate', 'vkAllocate')): - # Get last param - last_param = cmdinfo.elem.findall('param')[-1] - lp_txt = last_param.find('name').text - lp_len = None - if ('len' in last_param.attrib): - lp_len = last_param.attrib['len'] - lp_len = lp_len.replace('::', '->') - lp_type = last_param.find('type').text - handle_type = 'dispatchable' - allocator_txt = 'CreateDispObjHandle()'; - if (self.isHandleTypeNonDispatchable(lp_type)): - handle_type = 'non-' + handle_type - allocator_txt = 'global_unique_handle++'; - # Need to lock in both cases - self.appendSection('command', ' unique_lock_t lock(global_lock);') - if (lp_len != None): - #print("%s last params (%s) has len %s" % (handle_type, lp_txt, lp_len)) - self.appendSection('command', ' for (uint32_t i = 0; i < %s; ++i) {' % (lp_len)) - self.appendSection('command', ' %s[i] = (%s)%s;' % (lp_txt, lp_type, allocator_txt)) - self.appendSection('command', ' }') - else: - #print("Single %s last param is '%s' w/ type '%s'" % (handle_type, lp_txt, lp_type)) - if 'AllocateMemory' in api_function_name: - # Store allocation size in case it's mapped - self.appendSection('command', ' allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize;') - self.appendSection('command', ' *%s = (%s)%s;' % (lp_txt, lp_type, allocator_txt)) - elif True in [ftxt in api_function_name for ftxt in ['Destroy', 'Free']]: - self.appendSection('command', '//Destroy object') - if 'FreeMemory' in api_function_name: - # If the memory is mapped, unmap it - self.appendSection('command', ' UnmapMemory(device, memory);') - # Remove from allocation map - self.appendSection('command', ' unique_lock_t lock(global_lock);') - self.appendSection('command', ' allocated_memory_size_map.erase(memory);') - else: - self.appendSection('command', '//Not a CREATE or DESTROY function') - - # Return result variable, if any. - if (resulttype != None): - if api_function_name == 'vkGetEventStatus': - self.appendSection('command', ' return VK_EVENT_SET;') - else: - self.appendSection('command', ' return VK_SUCCESS;') - self.appendSection('command', '}') - # - # override makeProtoName to drop the "vk" prefix - def makeProtoName(self, name, tail): - return self.genOpts.apientry + name[2:] + tail
diff --git a/scripts/update_deps.py b/scripts/update_deps.py index 47810a0..7d30086 100755 --- a/scripts/update_deps.py +++ b/scripts/update_deps.py
@@ -498,7 +498,7 @@ # Use the CMake -A option to select the platform architecture # without needing a Visual Studio generator. - if platform.system() == 'Windows' and self._args.generator != "Ninja": + if platform.system() == 'Windows' and not self._args.generator in ["Ninja", "MinGW Makefiles"]: cmake_cmd.append('-A') if self._args.arch.lower() == '64' or self._args.arch == 'x64' or self._args.arch == 'win64': cmake_cmd.append('x64')
diff --git a/scripts/vulkan_tools_helper_file_generator.py b/scripts/vulkan_tools_helper_file_generator.py deleted file mode 100644 index b0e486e..0000000 --- a/scripts/vulkan_tools_helper_file_generator.py +++ /dev/null
@@ -1,1240 +0,0 @@ -#!/usr/bin/python3 -i -# -# Copyright (c) 2015-2021 The Khronos Group Inc. -# Copyright (c) 2015-2021 Valve Corporation -# Copyright (c) 2015-2021 LunarG, Inc. -# Copyright (c) 2015-2021 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Author: Mark Lobodzinski <mark@lunarg.com> -# Author: Tobin Ehlis <tobine@google.com> -# Author: John Zulauf <jzulauf@lunarg.com> - -import os,re,sys -import xml.etree.ElementTree as etree -from generator import * -from collections import namedtuple -from common_codegen import * - -# -# HelperFileOutputGeneratorOptions - subclass of GeneratorOptions. -class HelperFileOutputGeneratorOptions(GeneratorOptions): - def __init__(self, - conventions = None, - filename = None, - directory = '.', - genpath = None, - apiname = None, - profile = None, - versions = '.*', - emitversions = '.*', - defaultExtensions = None, - addExtensions = None, - removeExtensions = None, - emitExtensions = None, - sortProcedure = regSortFeatures, - prefixText = "", - genFuncPointers = True, - protectFile = True, - protectFeature = True, - apicall = '', - apientry = '', - apientryp = '', - alignFuncParam = 0, - library_name = '', - expandEnumerants = True, - helper_file_type = ''): - GeneratorOptions.__init__(self, - conventions = conventions, - filename = filename, - directory = directory, - genpath = genpath, - apiname = apiname, - profile = profile, - versions = versions, - emitversions = emitversions, - defaultExtensions = defaultExtensions, - addExtensions = addExtensions, - removeExtensions = removeExtensions, - emitExtensions = emitExtensions, - sortProcedure = sortProcedure) - self.prefixText = prefixText - self.genFuncPointers = genFuncPointers - self.protectFile = protectFile - self.protectFeature = protectFeature - self.apicall = apicall - self.apientry = apientry - self.apientryp = apientryp - self.alignFuncParam = alignFuncParam - self.library_name = library_name - self.helper_file_type = helper_file_type -# -# HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files -class HelperFileOutputGenerator(OutputGenerator): - """Generate helper file based on XML element attributes""" - def __init__(self, - errFile = sys.stderr, - warnFile = sys.stderr, - diagFile = sys.stdout): - OutputGenerator.__init__(self, errFile, warnFile, diagFile) - # Internal state - accumulators for different inner block text - self.enum_output = '' # string built up of enum string routines - # Internal state - accumulators for different inner block text - self.structNames = [] # List of Vulkan struct typenames - self.structTypes = dict() # Map of Vulkan struct typename to required VkStructureType - self.structMembers = [] # List of StructMemberData records for all Vulkan structs - self.object_types = [] # List of all handle types - self.object_type_aliases = [] # Aliases to handles types (for handles that were extensions) - self.debug_report_object_types = [] # Handy copy of debug_report_object_type enum data - self.core_object_types = [] # Handy copy of core_object_type enum data - self.device_extension_info = dict() # Dict of device extension name defines and ifdef values - self.instance_extension_info = dict() # Dict of instance extension name defines and ifdef values - - # Named tuples to store struct and command data - self.StructType = namedtuple('StructType', ['name', 'value']) - self.CommandParam = namedtuple('CommandParam', ['type', 'name', 'ispointer', 'isstaticarray', 'isconst', 'iscount', 'len', 'extstructs', 'cdecl']) - self.StructMemberData = namedtuple('StructMemberData', ['name', 'members', 'ifdef_protect']) - - self.custom_construct_params = { - # safe_VkGraphicsPipelineCreateInfo needs to know if subpass has color and\or depth\stencil attachments to use its pointers - 'VkGraphicsPipelineCreateInfo' : - ', const bool uses_color_attachment, const bool uses_depthstencil_attachment', - # safe_VkPipelineViewportStateCreateInfo needs to know if viewport and scissor is dynamic to use its pointers - 'VkPipelineViewportStateCreateInfo' : - ', const bool is_dynamic_viewports, const bool is_dynamic_scissors', - } - # - # Called once at the beginning of each run - def beginFile(self, genOpts): - OutputGenerator.beginFile(self, genOpts) - # User-supplied prefix text, if any (list of strings) - self.helper_file_type = genOpts.helper_file_type - self.library_name = genOpts.library_name - # File Comment - file_comment = '// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n' - file_comment += '// See vulkan_tools_helper_file_generator.py for modifications\n' - write(file_comment, file=self.outFile) - # Copyright Notice - copyright = '' - copyright += '\n' - copyright += '/***************************************************************************\n' - copyright += ' *\n' - copyright += ' * Copyright (c) 2015-2017 The Khronos Group Inc.\n' - copyright += ' * Copyright (c) 2015-2017 Valve Corporation\n' - copyright += ' * Copyright (c) 2015-2017 LunarG, Inc.\n' - copyright += ' * Copyright (c) 2015-2017 Google Inc.\n' - copyright += ' *\n' - copyright += ' * Licensed under the Apache License, Version 2.0 (the "License");\n' - copyright += ' * you may not use this file except in compliance with the License.\n' - copyright += ' * You may obtain a copy of the License at\n' - copyright += ' *\n' - copyright += ' * http://www.apache.org/licenses/LICENSE-2.0\n' - copyright += ' *\n' - copyright += ' * Unless required by applicable law or agreed to in writing, software\n' - copyright += ' * distributed under the License is distributed on an "AS IS" BASIS,\n' - copyright += ' * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n' - copyright += ' * See the License for the specific language governing permissions and\n' - copyright += ' * limitations under the License.\n' - copyright += ' *\n' - copyright += ' * Author: Mark Lobodzinski <mark@lunarg.com>\n' - copyright += ' * Author: Courtney Goeltzenleuchter <courtneygo@google.com>\n' - copyright += ' * Author: Tobin Ehlis <tobine@google.com>\n' - copyright += ' * Author: Chris Forbes <chrisforbes@google.com>\n' - copyright += ' * Author: John Zulauf<jzulauf@lunarg.com>\n' - copyright += ' *\n' - copyright += ' ****************************************************************************/\n' - write(copyright, file=self.outFile) - # - # Write generated file content to output file - def endFile(self): - dest_file = '' - dest_file += self.OutputDestFile() - # Remove blank lines at EOF - if dest_file.endswith('\n'): - dest_file = dest_file[:-1] - write(dest_file, file=self.outFile); - # Finish processing in superclass - OutputGenerator.endFile(self) - # - # Override parent class to be notified of the beginning of an extension - def beginFeature(self, interface, emit): - # Start processing in superclass - OutputGenerator.beginFeature(self, interface, emit) - self.featureExtraProtect = GetFeatureProtect(interface) - - if interface.tag != 'extension': - return - name = self.featureName - for enum in interface.findall('require/enum'): - if enum.get('name', '').endswith('EXTENSION_NAME'): - name_define = enum.get('name') - break - requires = interface.get('requires') - if requires is not None: - required_extensions = requires.split(',') - else: - required_extensions = list() - info = { 'define': name_define, 'ifdef':self.featureExtraProtect, 'reqs':required_extensions } - if interface.get('type') == 'instance': - self.instance_extension_info[name] = info - else: - self.device_extension_info[name] = info - - # - # Override parent class to be notified of the end of an extension - def endFeature(self): - # Finish processing in superclass - OutputGenerator.endFeature(self) - # - # Grab group (e.g. C "enum" type) info to output for enum-string conversion helper - def genGroup(self, groupinfo, groupName, alias): - OutputGenerator.genGroup(self, groupinfo, groupName, alias) - groupElem = groupinfo.elem - # For enum_string_header - if self.helper_file_type == 'enum_string_header': - value_set = set() - for elem in groupElem.findall('enum'): - if elem.get('supported') != 'disabled' and elem.get('alias') == None: - value_set.add(elem.get('name')) - self.enum_output += self.GenerateEnumStringConversion(groupName, value_set) - elif self.helper_file_type == 'object_types_header': - if groupName == 'VkDebugReportObjectTypeEXT': - for elem in groupElem.findall('enum'): - if elem.get('supported') != 'disabled': - item_name = elem.get('name') - self.debug_report_object_types.append(item_name) - elif groupName == 'VkObjectType': - for elem in groupElem.findall('enum'): - if elem.get('supported') != 'disabled': - item_name = elem.get('name') - self.core_object_types.append(item_name) - - # - # Called for each type -- if the type is a struct/union, grab the metadata - def genType(self, typeinfo, name, alias): - OutputGenerator.genType(self, typeinfo, name, alias) - typeElem = typeinfo.elem - # If the type is a struct type, traverse the imbedded <member> tags generating a structure. - # Otherwise, emit the tag text. - category = typeElem.get('category') - if category == 'handle': - if alias: - self.object_type_aliases.append((name,alias)) - else: - self.object_types.append(name) - elif (category == 'struct' or category == 'union'): - self.structNames.append(name) - self.genStruct(typeinfo, name, alias) - # - # Check if the parameter passed in is a pointer - def paramIsPointer(self, param): - ispointer = False - for elem in param: - if ((elem.tag != 'type') and (elem.tail is not None)) and '*' in elem.tail: - ispointer = True - return ispointer - # - # Check if the parameter passed in is a static array - def paramIsStaticArray(self, param): - isstaticarray = 0 - paramname = param.find('name') - if (paramname.tail is not None) and ('[' in paramname.tail): - isstaticarray = paramname.tail.count('[') - return isstaticarray - # - # Retrieve the type and name for a parameter - def getTypeNameTuple(self, param): - type = '' - name = '' - for elem in param: - if elem.tag == 'type': - type = noneStr(elem.text) - elif elem.tag == 'name': - name = noneStr(elem.text) - return (type, name) - # - # Retrieve the value of the len tag - def getLen(self, param): - result = None - len = param.attrib.get('len') - if len and len != 'null-terminated': - # For string arrays, 'len' can look like 'count,null-terminated', indicating that we - # have a null terminated array of strings. We strip the null-terminated from the - # 'len' field and only return the parameter specifying the string count - if 'null-terminated' in len: - result = len.split(',')[0] - else: - result = len - if 'altlen' in param.attrib: - # Elements with latexmath 'len' also contain a C equivalent 'altlen' attribute - # Use indexing operator instead of get() so we fail if the attribute is missing - result = param.attrib['altlen'] - # Spec has now notation for len attributes, using :: instead of platform specific pointer symbol - result = str(result).replace('::', '->') - return result - # - # Check if a structure is or contains a dispatchable (dispatchable = True) or - # non-dispatchable (dispatchable = False) handle - def TypeContainsObjectHandle(self, handle_type, dispatchable): - if dispatchable: - type_key = 'VK_DEFINE_HANDLE' - else: - type_key = 'VK_DEFINE_NON_DISPATCHABLE_HANDLE' - handle = self.registry.tree.find("types/type/[name='" + handle_type + "'][@category='handle']") - if handle is not None and handle.find('type').text == type_key: - return True - # if handle_type is a struct, search its members - if handle_type in self.structNames: - member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == handle_type), None) - if member_index is not None: - for item in self.structMembers[member_index].members: - handle = self.registry.tree.find("types/type/[name='" + item.type + "'][@category='handle']") - if handle is not None and handle.find('type').text == type_key: - return True - return False - # - # Generate local ready-access data describing Vulkan structures and unions from the XML metadata - def genStruct(self, typeinfo, typeName, alias): - OutputGenerator.genStruct(self, typeinfo, typeName, alias) - members = typeinfo.elem.findall('.//member') - # Iterate over members once to get length parameters for arrays - lens = set() - for member in members: - len = self.getLen(member) - if len: - lens.add(len) - # Generate member info - membersInfo = [] - for member in members: - # Get the member's type and name - info = self.getTypeNameTuple(member) - type = info[0] - name = info[1] - cdecl = self.makeCParamDecl(member, 1) - # Process VkStructureType - if type == 'VkStructureType': - # Extract the required struct type value from the comments - # embedded in the original text defining the 'typeinfo' element - rawXml = etree.tostring(typeinfo.elem).decode('ascii') - result = re.search(r'VK_STRUCTURE_TYPE_\w+', rawXml) - if result: - value = result.group(0) - # Store the required type value - self.structTypes[typeName] = self.StructType(name=name, value=value) - # Store pointer/array/string info - isstaticarray = self.paramIsStaticArray(member) - membersInfo.append(self.CommandParam(type=type, - name=name, - ispointer=self.paramIsPointer(member), - isstaticarray=isstaticarray, - isconst=True if 'const' in cdecl else False, - iscount=True if name in lens else False, - len=self.getLen(member), - extstructs=self.registry.validextensionstructs[typeName] if name == 'pNext' else None, - cdecl=cdecl)) - self.structMembers.append(self.StructMemberData(name=typeName, members=membersInfo, ifdef_protect=self.featureExtraProtect)) - # - # Enum_string_header: Create a routine to convert an enumerated value into a string - def GenerateEnumStringConversion(self, groupName, value_list): - outstring = '\n' - outstring += 'static inline const char* string_%s(%s input_value)\n' % (groupName, groupName) - outstring += '{\n' - outstring += ' switch ((%s)input_value)\n' % groupName - outstring += ' {\n' - for item in value_list: - outstring += ' case %s:\n' % item - outstring += ' return "%s";\n' % item - outstring += ' default:\n' - outstring += ' return "Unhandled %s";\n' % groupName - outstring += ' }\n' - outstring += '}\n' - return outstring - # - # Tack on a helper which, given an index into a VkPhysicalDeviceFeatures structure, will print the corresponding feature name - def DeIndexPhysDevFeatures(self): - pdev_members = None - for name, members, ifdef in self.structMembers: - if name == 'VkPhysicalDeviceFeatures': - pdev_members = members - break - deindex = '\n' - deindex += 'static inline const char * GetPhysDevFeatureString(uint32_t index) {\n' - deindex += ' const char * IndexToPhysDevFeatureString[] = {\n' - for feature in pdev_members: - deindex += ' "%s",\n' % feature.name - deindex += ' };\n\n' - deindex += ' return IndexToPhysDevFeatureString[index];\n' - deindex += '}\n' - return deindex - # - # Combine enum string helper header file preamble with body text and return - def GenerateEnumStringHelperHeader(self): - enum_string_helper_header = '\n' - enum_string_helper_header += '#pragma once\n' - enum_string_helper_header += '#ifdef _WIN32\n' - enum_string_helper_header += '#pragma warning( disable : 4065 )\n' - enum_string_helper_header += '#endif\n' - enum_string_helper_header += '\n' - enum_string_helper_header += '#include <vulkan/vulkan.h>\n' - enum_string_helper_header += '\n' - enum_string_helper_header += self.enum_output - enum_string_helper_header += self.DeIndexPhysDevFeatures() - return enum_string_helper_header - # - # Helper function for declaring a counter variable only once - def DeclareCounter(self, string_var, declare_flag): - if declare_flag == False: - string_var += ' uint32_t i = 0;\n' - declare_flag = True - return string_var, declare_flag - # - # Combine safe struct helper header file preamble with body text and return - def GenerateSafeStructHelperHeader(self): - safe_struct_helper_header = '\n' - safe_struct_helper_header += '#pragma once\n' - safe_struct_helper_header += '#include <vulkan/vulkan.h>\n' - safe_struct_helper_header += '\n' - safe_struct_helper_header += self.GenerateSafeStructHeader() - return safe_struct_helper_header - # - # safe_struct header: build function prototypes for header file - def GenerateSafeStructHeader(self): - safe_struct_header = '' - for item in self.structMembers: - if self.NeedSafeStruct(item) == True: - safe_struct_header += '\n' - if item.ifdef_protect != None: - safe_struct_header += '#ifdef %s\n' % item.ifdef_protect - safe_struct_header += 'struct safe_%s {\n' % (item.name) - for member in item.members: - if member.type in self.structNames: - member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None) - if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True: - if member.ispointer: - safe_struct_header += ' safe_%s* %s;\n' % (member.type, member.name) - else: - safe_struct_header += ' safe_%s %s;\n' % (member.type, member.name) - continue - if member.len is not None and (self.TypeContainsObjectHandle(member.type, True) or self.TypeContainsObjectHandle(member.type, False)): - safe_struct_header += ' %s* %s;\n' % (member.type, member.name) - else: - safe_struct_header += '%s;\n' % member.cdecl - safe_struct_header += ' safe_%s(const %s* in_struct%s);\n' % (item.name, item.name, self.custom_construct_params.get(item.name, '')) - safe_struct_header += ' safe_%s(const safe_%s& src);\n' % (item.name, item.name) - safe_struct_header += ' safe_%s& operator=(const safe_%s& src);\n' % (item.name, item.name) - safe_struct_header += ' safe_%s();\n' % item.name - safe_struct_header += ' ~safe_%s();\n' % item.name - safe_struct_header += ' void initialize(const %s* in_struct%s);\n' % (item.name, self.custom_construct_params.get(item.name, '')) - safe_struct_header += ' void initialize(const safe_%s* src);\n' % (item.name) - safe_struct_header += ' %s *ptr() { return reinterpret_cast<%s *>(this); }\n' % (item.name, item.name) - safe_struct_header += ' %s const *ptr() const { return reinterpret_cast<%s const *>(this); }\n' % (item.name, item.name) - safe_struct_header += '};\n' - if item.ifdef_protect != None: - safe_struct_header += '#endif // %s\n' % item.ifdef_protect - return safe_struct_header - # - # Generate extension helper header file - def GenerateExtensionHelperHeader(self): - - V_1_0_instance_extensions_promoted_to_core = [ - 'vk_khr_device_group_creation', - 'vk_khr_external_fence_capabilities', - 'vk_khr_external_memory_capabilities', - 'vk_khr_external_semaphore_capabilities', - 'vk_khr_get_physical_device_properties_2', - ] - - V_1_0_device_extensions_promoted_to_core = [ - 'vk_khr_16bit_storage', - 'vk_khr_bind_memory_2', - 'vk_khr_dedicated_allocation', - 'vk_khr_descriptor_update_template', - 'vk_khr_device_group', - 'vk_khr_external_fence', - 'vk_khr_external_memory', - 'vk_khr_external_semaphore', - 'vk_khr_get_memory_requirements_2', - 'vk_khr_maintenance1', - 'vk_khr_maintenance2', - 'vk_khr_maintenance3', - 'vk_khr_multiview', - 'vk_khr_relaxed_block_layout', - 'vk_khr_sampler_ycbcr_conversion', - 'vk_khr_shader_draw_parameters', - 'vk_khr_storage_buffer_storage_class', - 'vk_khr_variable_pointers', - ] - - output = [ - '', - '#ifndef VK_EXTENSION_HELPER_H_', - '#define VK_EXTENSION_HELPER_H_', - '#include <string>', - '#include <unordered_map>', - '#include <utility>', - '', - '#include <vulkan/vulkan.h>', - ''] - - def guarded(ifdef, value): - if ifdef is not None: - return '\n'.join([ '#ifdef %s' % ifdef, value, '#endif' ]) - else: - return value - - for type in ['Instance', 'Device']: - struct_type = '%sExtensions' % type - if type == 'Instance': - extension_dict = self.instance_extension_info - promoted_ext_list = V_1_0_instance_extensions_promoted_to_core - struct_decl = 'struct %s {' % struct_type - instance_struct_type = struct_type - else: - extension_dict = self.device_extension_info - promoted_ext_list = V_1_0_device_extensions_promoted_to_core - struct_decl = 'struct %s : public %s {' % (struct_type, instance_struct_type) - - extension_items = sorted(extension_dict.items()) - - field_name = { ext_name: re.sub('_extension_name', '', info['define'].lower()) for ext_name, info in extension_items } - if type == 'Instance': - instance_field_name = field_name - instance_extension_dict = extension_dict - else: - # Get complete field name and extension data for both Instance and Device extensions - field_name.update(instance_field_name) - extension_dict = extension_dict.copy() # Don't modify the self.<dict> we're pointing to - extension_dict.update(instance_extension_dict) - - # Output the data member list - struct = [struct_decl] - struct.extend([ ' bool %s{false};' % field_name[ext_name] for ext_name, info in extension_items]) - - # Construct the extension information map -- mapping name to data member (field), and required extensions - # The map is contained within a static function member for portability reasons. - info_type = '%sInfo' % type - info_map_type = '%sMap' % info_type - req_type = '%sReq' % type - req_vec_type = '%sVec' % req_type - struct.extend([ - '', - ' struct %s {' % req_type, - ' const bool %s::* enabled;' % struct_type, - ' const char *name;', - ' };', - ' typedef std::vector<%s> %s;' % (req_type, req_vec_type), - ' struct %s {' % info_type, - ' %s(bool %s::* state_, const %s requires_): state(state_), requires(requires_) {}' % ( info_type, struct_type, req_vec_type), - ' bool %s::* state;' % struct_type, - ' %s requires;' % req_vec_type, - ' };', - '', - ' typedef std::unordered_map<std::string,%s> %s;' % (info_type, info_map_type), - ' static const %s &get_info(const char *name) {' %info_type, - ' static const %s info_map = {' % info_map_type ]) - - field_format = '&' + struct_type + '::%s' - req_format = '{' + field_format+ ', %s}' - req_indent = '\n ' - req_join = ',' + req_indent - info_format = (' std::make_pair(%s, ' + info_type + '(' + field_format + ', {%s})),') - def format_info(ext_name, info): - reqs = req_join.join([req_format % (field_name[req], extension_dict[req]['define']) for req in info['reqs']]) - return info_format % (info['define'], field_name[ext_name], '{%s}' % (req_indent + reqs) if reqs else '') - - struct.extend([guarded(info['ifdef'], format_info(ext_name, info)) for ext_name, info in extension_items]) - struct.extend([ - ' };', - '', - ' static const %s empty_info {nullptr, %s()};' % (info_type, req_vec_type), - ' %s::const_iterator info = info_map.find(name);' % info_map_type, - ' if ( info != info_map.cend()) {', - ' return info->second;', - ' }', - ' return empty_info;', - ' }', - '']) - - if type == 'Instance': - struct.extend([ - ' uint32_t NormalizeApiVersion(uint32_t specified_version) {', - ' uint32_t api_version = (specified_version < VK_API_VERSION_1_1) ? VK_API_VERSION_1_0 : VK_API_VERSION_1_1;', - ' return api_version;', - ' }', - '', - ' uint32_t InitFromInstanceCreateInfo(uint32_t requested_api_version, const VkInstanceCreateInfo *pCreateInfo) {']) - else: - struct.extend([ - ' %s() = default;' % struct_type, - ' %s(const %s& instance_ext) : %s(instance_ext) {}' % (struct_type, instance_struct_type, instance_struct_type), - '', - ' uint32_t InitFromDeviceCreateInfo(const %s *instance_extensions, uint32_t requested_api_version,' % instance_struct_type, - ' const VkDeviceCreateInfo *pCreateInfo) {', - ' // Initialize: this to defaults, base class fields to input.', - ' assert(instance_extensions);', - ' *this = %s(*instance_extensions);' % struct_type]) - - struct.extend([ - '', - ' static const std::vector<const char *> V_1_0_promoted_%s_extensions = {' % type.lower() ]) - struct.extend([' %s_EXTENSION_NAME,' % ext_name.upper() for ext_name in promoted_ext_list]) - struct.extend([ - ' };', - '', - ' // Initialize struct data, robust to invalid pCreateInfo', - ' if (pCreateInfo->ppEnabledExtensionNames) {', - ' for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {', - ' if (!pCreateInfo->ppEnabledExtensionNames[i]) continue;', - ' auto info = get_info(pCreateInfo->ppEnabledExtensionNames[i]);', - ' if(info.state) this->*(info.state) = true;', - ' }', - ' }', - ' uint32_t api_version = NormalizeApiVersion(requested_api_version);', - ' if (api_version >= VK_API_VERSION_1_1) {', - ' for (auto promoted_ext : V_1_0_promoted_%s_extensions) {' % type.lower(), - ' auto info = get_info(promoted_ext);', - ' assert(info.state);', - ' if (info.state) this->*(info.state) = true;', - ' }', - ' }', - ' return api_version;', - ' }', - '};']) - - # Output reference lists of instance/device extension names - struct.extend(['', 'static const char * const k%sExtensionNames = ' % type]) - struct.extend([guarded(info['ifdef'], ' %s' % info['define']) for ext_name, info in extension_items]) - struct.extend([';', '']) - output.extend(struct) - - output.extend(['', '#endif // VK_EXTENSION_HELPER_H_']) - return '\n'.join(output) - # - # Combine object types helper header file preamble with body text and return - def GenerateObjectTypesHelperHeader(self): - object_types_helper_header = '\n' - object_types_helper_header += '#pragma once\n' - object_types_helper_header += '\n' - object_types_helper_header += '#include <vulkan/vulkan.h>\n\n' - object_types_helper_header += self.GenerateObjectTypesHeader() - return object_types_helper_header - # - # Object types header: create object enum type header file - def GenerateObjectTypesHeader(self): - object_types_header = '' - object_types_header += '// Object Type enum for validation layer internal object handling\n' - object_types_header += 'typedef enum VulkanObjectType {\n' - object_types_header += ' kVulkanObjectTypeUnknown = 0,\n' - enum_num = 1 - type_list = []; - enum_entry_map = {} - - # Output enum definition as each handle is processed, saving the names to use for the conversion routine - for item in self.object_types: - fixup_name = item[2:] - enum_entry = 'kVulkanObjectType%s' % fixup_name - enum_entry_map[item] = enum_entry - object_types_header += ' ' + enum_entry - object_types_header += ' = %d,\n' % enum_num - enum_num += 1 - type_list.append(enum_entry) - object_types_header += ' kVulkanObjectTypeMax = %d,\n' % enum_num - object_types_header += ' // Aliases for backwards compatibilty of "promoted" types\n' - for (name, alias) in self.object_type_aliases: - fixup_name = name[2:] - object_types_header += ' kVulkanObjectType{} = {},\n'.format(fixup_name, enum_entry_map[alias]) - object_types_header += '} VulkanObjectType;\n\n' - - # Output name string helper - object_types_header += '// Array of object name strings for OBJECT_TYPE enum conversion\n' - object_types_header += 'static const char * const object_string[kVulkanObjectTypeMax] = {\n' - object_types_header += ' "Unknown",\n' - for item in self.object_types: - fixup_name = item[2:] - object_types_header += ' "%s",\n' % fixup_name - object_types_header += '};\n' - - # Key creation helper for map comprehensions that convert between k<Name> and VK<Name> symbols - def to_key(regex, raw_key): return re.search(regex, raw_key).group(1).lower().replace("_","") - - # Output a conversion routine from the layer object definitions to the debug report definitions - # As the VK_DEBUG_REPORT types are not being updated, specify UNKNOWN for unmatched types - object_types_header += '\n' - object_types_header += '// Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version\n' - object_types_header += 'const VkDebugReportObjectTypeEXT get_debug_report_enum[] = {\n' - object_types_header += ' VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeUnknown\n' - - dbg_re = '^VK_DEBUG_REPORT_OBJECT_TYPE_(.*)_EXT$' - dbg_map = {to_key(dbg_re, dbg) : dbg for dbg in self.debug_report_object_types} - dbg_default = 'VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT' - for object_type in type_list: - vk_object_type = dbg_map.get(object_type.replace("kVulkanObjectType", "").lower(), dbg_default) - object_types_header += ' %s, // %s\n' % (vk_object_type, object_type) - object_types_header += '};\n' - - # Output a conversion routine from the layer object definitions to the core object type definitions - # This will intentionally *fail* for unmatched types as the VK_OBJECT_TYPE list should match the kVulkanObjectType list - object_types_header += '\n' - object_types_header += '// Helper array to get Official Vulkan VkObjectType enum from the internal layers version\n' - object_types_header += 'const VkObjectType get_object_type_enum[] = {\n' - object_types_header += ' VK_OBJECT_TYPE_UNKNOWN, // kVulkanObjectTypeUnknown\n' - - vko_re = '^VK_OBJECT_TYPE_(.*)' - vko_map = {to_key(vko_re, vko) : vko for vko in self.core_object_types} - for object_type in type_list: - vk_object_type = vko_map[object_type.replace("kVulkanObjectType", "").lower()] - object_types_header += ' %s, // %s\n' % (vk_object_type, object_type) - object_types_header += '};\n' - - # Create a function to convert from VkDebugReportObjectTypeEXT to VkObjectType - object_types_header += '\n' - object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n' - object_types_header += 'static inline VkObjectType convertDebugReportObjectToCoreObject(VkDebugReportObjectTypeEXT debug_report_obj){\n' - object_types_header += ' if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {\n' - object_types_header += ' return VK_OBJECT_TYPE_UNKNOWN;\n' - for core_object_type in self.core_object_types: - core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower() - core_target_type = core_target_type.replace("_", "") - for dr_object_type in self.debug_report_object_types: - dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower() - dr_target_type = dr_target_type[:-4] - dr_target_type = dr_target_type.replace("_", "") - if core_target_type == dr_target_type: - object_types_header += ' } else if (debug_report_obj == %s) {\n' % dr_object_type - object_types_header += ' return %s;\n' % core_object_type - break - object_types_header += ' }\n' - object_types_header += ' return VK_OBJECT_TYPE_UNKNOWN;\n' - object_types_header += '}\n' - - # Create a function to convert from VkObjectType to VkDebugReportObjectTypeEXT - object_types_header += '\n' - object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n' - object_types_header += 'static inline VkDebugReportObjectTypeEXT convertCoreObjectToDebugReportObject(VkObjectType core_report_obj){\n' - object_types_header += ' if (core_report_obj == VK_OBJECT_TYPE_UNKNOWN) {\n' - object_types_header += ' return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n' - for core_object_type in self.core_object_types: - core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower() - core_target_type = core_target_type.replace("_", "") - for dr_object_type in self.debug_report_object_types: - dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower() - dr_target_type = dr_target_type[:-4] - dr_target_type = dr_target_type.replace("_", "") - if core_target_type == dr_target_type: - object_types_header += ' } else if (core_report_obj == %s) {\n' % core_object_type - object_types_header += ' return %s;\n' % dr_object_type - break - object_types_header += ' }\n' - object_types_header += ' return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n' - object_types_header += '}\n' - return object_types_header - # - # Determine if a structure needs a safe_struct helper function - # That is, it has an sType or one of its members is a pointer - def NeedSafeStruct(self, structure): - if 'sType' == structure.name: - return True - for member in structure.members: - if member.ispointer == True: - return True - return False - # - # Combine safe struct helper source file preamble with body text and return - def GenerateSafeStructHelperSource(self): - safe_struct_helper_source = '\n' - safe_struct_helper_source += '#include "vk_safe_struct.h"\n' - safe_struct_helper_source += '#include <string.h>\n' - safe_struct_helper_source += '#ifdef VK_USE_PLATFORM_ANDROID_KHR\n' - safe_struct_helper_source += '#if __ANDROID_API__ < __ANDROID_API_O__\n' - safe_struct_helper_source += 'struct AHardwareBuffer {};\n' - safe_struct_helper_source += '#endif\n' - safe_struct_helper_source += '#endif\n' - - safe_struct_helper_source += '\n' - safe_struct_helper_source += self.GenerateSafeStructSource() - return safe_struct_helper_source - # - # safe_struct source -- create bodies of safe struct helper functions - def GenerateSafeStructSource(self): - safe_struct_body = [] - wsi_structs = ['VkXlibSurfaceCreateInfoKHR', - 'VkXcbSurfaceCreateInfoKHR', - 'VkWaylandSurfaceCreateInfoKHR', - 'VkMirSurfaceCreateInfoKHR', - 'VkAndroidSurfaceCreateInfoKHR', - 'VkWin32SurfaceCreateInfoKHR' - ] - for item in self.structMembers: - if self.NeedSafeStruct(item) == False: - continue - if item.name in wsi_structs: - continue - if item.ifdef_protect != None: - safe_struct_body.append("#ifdef %s\n" % item.ifdef_protect) - ss_name = "safe_%s" % item.name - init_list = '' # list of members in struct constructor initializer - default_init_list = '' # Default constructor just inits ptrs to nullptr in initializer - init_func_txt = '' # Txt for initialize() function that takes struct ptr and inits members - construct_txt = '' # Body of constuctor as well as body of initialize() func following init_func_txt - destruct_txt = '' - - custom_construct_txt = { - # VkWriteDescriptorSet is special case because pointers may be non-null but ignored - 'VkWriteDescriptorSet' : - ' switch (descriptorType) {\n' - ' case VK_DESCRIPTOR_TYPE_SAMPLER:\n' - ' case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:\n' - ' case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:\n' - ' case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:\n' - ' case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:\n' - ' if (descriptorCount && in_struct->pImageInfo) {\n' - ' pImageInfo = new VkDescriptorImageInfo[descriptorCount];\n' - ' for (uint32_t i=0; i<descriptorCount; ++i) {\n' - ' pImageInfo[i] = in_struct->pImageInfo[i];\n' - ' }\n' - ' }\n' - ' break;\n' - ' case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:\n' - ' case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:\n' - ' case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:\n' - ' case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:\n' - ' if (descriptorCount && in_struct->pBufferInfo) {\n' - ' pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];\n' - ' for (uint32_t i=0; i<descriptorCount; ++i) {\n' - ' pBufferInfo[i] = in_struct->pBufferInfo[i];\n' - ' }\n' - ' }\n' - ' break;\n' - ' case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:\n' - ' case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:\n' - ' if (descriptorCount && in_struct->pTexelBufferView) {\n' - ' pTexelBufferView = new VkBufferView[descriptorCount];\n' - ' for (uint32_t i=0; i<descriptorCount; ++i) {\n' - ' pTexelBufferView[i] = in_struct->pTexelBufferView[i];\n' - ' }\n' - ' }\n' - ' break;\n' - ' default:\n' - ' break;\n' - ' }\n', - 'VkShaderModuleCreateInfo' : - ' if (in_struct->pCode) {\n' - ' pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);\n' - ' memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);\n' - ' }\n', - # VkGraphicsPipelineCreateInfo is special case because its pointers may be non-null but ignored - 'VkGraphicsPipelineCreateInfo' : - ' if (stageCount && in_struct->pStages) {\n' - ' pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n' - ' for (uint32_t i=0; i<stageCount; ++i) {\n' - ' pStages[i].initialize(&in_struct->pStages[i]);\n' - ' }\n' - ' }\n' - ' if (in_struct->pVertexInputState)\n' - ' pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);\n' - ' else\n' - ' pVertexInputState = NULL;\n' - ' if (in_struct->pInputAssemblyState)\n' - ' pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);\n' - ' else\n' - ' pInputAssemblyState = NULL;\n' - ' bool has_tessellation_stage = false;\n' - ' if (stageCount && pStages)\n' - ' for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n' - ' if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n' - ' has_tessellation_stage = true;\n' - ' if (in_struct->pTessellationState && has_tessellation_stage)\n' - ' pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);\n' - ' else\n' - ' pTessellationState = NULL; // original pTessellationState pointer ignored\n' - ' bool has_rasterization = in_struct->pRasterizationState ? !in_struct->pRasterizationState->rasterizerDiscardEnable : false;\n' - ' if (in_struct->pViewportState && has_rasterization) {\n' - ' bool is_dynamic_viewports = false;\n' - ' bool is_dynamic_scissors = false;\n' - ' if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {\n' - ' for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)\n' - ' if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT)\n' - ' is_dynamic_viewports = true;\n' - ' for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)\n' - ' if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR)\n' - ' is_dynamic_scissors = true;\n' - ' }\n' - ' pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);\n' - ' } else\n' - ' pViewportState = NULL; // original pViewportState pointer ignored\n' - ' if (in_struct->pRasterizationState)\n' - ' pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);\n' - ' else\n' - ' pRasterizationState = NULL;\n' - ' if (in_struct->pMultisampleState && has_rasterization)\n' - ' pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);\n' - ' else\n' - ' pMultisampleState = NULL; // original pMultisampleState pointer ignored\n' - ' // needs a tracked subpass state uses_depthstencil_attachment\n' - ' if (in_struct->pDepthStencilState && has_rasterization && uses_depthstencil_attachment)\n' - ' pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);\n' - ' else\n' - ' pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n' - ' // needs a tracked subpass state usesColorAttachment\n' - ' if (in_struct->pColorBlendState && has_rasterization && uses_color_attachment)\n' - ' pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);\n' - ' else\n' - ' pColorBlendState = NULL; // original pColorBlendState pointer ignored\n' - ' if (in_struct->pDynamicState)\n' - ' pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);\n' - ' else\n' - ' pDynamicState = NULL;\n', - # VkPipelineViewportStateCreateInfo is special case because its pointers may be non-null but ignored - 'VkPipelineViewportStateCreateInfo' : - ' if (in_struct->pViewports && !is_dynamic_viewports) {\n' - ' pViewports = new VkViewport[in_struct->viewportCount];\n' - ' memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);\n' - ' }\n' - ' else\n' - ' pViewports = NULL;\n' - ' if (in_struct->pScissors && !is_dynamic_scissors) {\n' - ' pScissors = new VkRect2D[in_struct->scissorCount];\n' - ' memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);\n' - ' }\n' - ' else\n' - ' pScissors = NULL;\n', - # VkDescriptorSetLayoutBinding is special case because its pImmutableSamplers pointer may be non-null but ignored - 'VkDescriptorSetLayoutBinding' : - ' const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;\n' - ' if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {\n' - ' pImmutableSamplers = new VkSampler[descriptorCount];\n' - ' for (uint32_t i=0; i<descriptorCount; ++i) {\n' - ' pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];\n' - ' }\n' - ' }\n', - } - - custom_copy_txt = { - # VkGraphicsPipelineCreateInfo is special case because it has custom construct parameters - 'VkGraphicsPipelineCreateInfo' : - ' if (stageCount && src.pStages) {\n' - ' pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n' - ' for (uint32_t i=0; i<stageCount; ++i) {\n' - ' pStages[i].initialize(&src.pStages[i]);\n' - ' }\n' - ' }\n' - ' if (src.pVertexInputState)\n' - ' pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src.pVertexInputState);\n' - ' else\n' - ' pVertexInputState = NULL;\n' - ' if (src.pInputAssemblyState)\n' - ' pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src.pInputAssemblyState);\n' - ' else\n' - ' pInputAssemblyState = NULL;\n' - ' bool has_tessellation_stage = false;\n' - ' if (stageCount && pStages)\n' - ' for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n' - ' if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n' - ' has_tessellation_stage = true;\n' - ' if (src.pTessellationState && has_tessellation_stage)\n' - ' pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src.pTessellationState);\n' - ' else\n' - ' pTessellationState = NULL; // original pTessellationState pointer ignored\n' - ' bool has_rasterization = src.pRasterizationState ? !src.pRasterizationState->rasterizerDiscardEnable : false;\n' - ' if (src.pViewportState && has_rasterization) {\n' - ' pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src.pViewportState);\n' - ' } else\n' - ' pViewportState = NULL; // original pViewportState pointer ignored\n' - ' if (src.pRasterizationState)\n' - ' pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src.pRasterizationState);\n' - ' else\n' - ' pRasterizationState = NULL;\n' - ' if (src.pMultisampleState && has_rasterization)\n' - ' pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src.pMultisampleState);\n' - ' else\n' - ' pMultisampleState = NULL; // original pMultisampleState pointer ignored\n' - ' if (src.pDepthStencilState && has_rasterization)\n' - ' pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src.pDepthStencilState);\n' - ' else\n' - ' pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n' - ' if (src.pColorBlendState && has_rasterization)\n' - ' pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src.pColorBlendState);\n' - ' else\n' - ' pColorBlendState = NULL; // original pColorBlendState pointer ignored\n' - ' if (src.pDynamicState)\n' - ' pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src.pDynamicState);\n' - ' else\n' - ' pDynamicState = NULL;\n', - # VkPipelineViewportStateCreateInfo is special case because it has custom construct parameters - 'VkPipelineViewportStateCreateInfo' : - ' if (src.pViewports) {\n' - ' pViewports = new VkViewport[src.viewportCount];\n' - ' memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);\n' - ' }\n' - ' else\n' - ' pViewports = NULL;\n' - ' if (src.pScissors) {\n' - ' pScissors = new VkRect2D[src.scissorCount];\n' - ' memcpy ((void *)pScissors, (void *)src.pScissors, sizeof(VkRect2D)*src.scissorCount);\n' - ' }\n' - ' else\n' - ' pScissors = NULL;\n', - } - - custom_destruct_txt = {'VkShaderModuleCreateInfo' : - ' if (pCode)\n' - ' delete[] reinterpret_cast<const uint8_t *>(pCode);\n' } - - for member in item.members: - m_type = member.type - if member.type in self.structNames: - member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None) - if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True: - m_type = 'safe_%s' % member.type - if member.ispointer and 'safe_' not in m_type and self.TypeContainsObjectHandle(member.type, False) == False: - # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in - if m_type in ['void', 'char']: - # For these exceptions just copy initial value over for now - init_list += '\n %s(in_struct->%s),' % (member.name, member.name) - init_func_txt += ' %s = in_struct->%s;\n' % (member.name, member.name) - else: - default_init_list += '\n %s(nullptr),' % (member.name) - init_list += '\n %s(nullptr),' % (member.name) - init_func_txt += ' %s = nullptr;\n' % (member.name) - if 'pNext' != member.name and 'void' not in m_type: - if not member.isstaticarray and (member.len is None or '/' in member.len): - construct_txt += ' if (in_struct->%s) {\n' % member.name - construct_txt += ' %s = new %s(*in_struct->%s);\n' % (member.name, m_type, member.name) - construct_txt += ' }\n' - destruct_txt += ' if (%s)\n' % member.name - destruct_txt += ' delete %s;\n' % member.name - else: - construct_txt += ' if (in_struct->%s) {\n' % member.name - construct_txt += ' %s = new %s[in_struct->%s];\n' % (member.name, m_type, member.len) - construct_txt += ' memcpy ((void *)%s, (void *)in_struct->%s, sizeof(%s)*in_struct->%s);\n' % (member.name, member.name, m_type, member.len) - construct_txt += ' }\n' - destruct_txt += ' if (%s)\n' % member.name - destruct_txt += ' delete[] %s;\n' % member.name - elif member.isstaticarray or member.len is not None: - if member.len is None: - # Extract length of static array by grabbing val between [] - static_array_size = re.match(r"[^[]*\[([^]]*)\]", member.cdecl) - construct_txt += ' for (uint32_t i=0; i<%s; ++i) {\n' % static_array_size.group(1) - construct_txt += ' %s[i] = in_struct->%s[i];\n' % (member.name, member.name) - construct_txt += ' }\n' - else: - # Init array ptr to NULL - default_init_list += '\n %s(nullptr),' % member.name - init_list += '\n %s(nullptr),' % member.name - init_func_txt += ' %s = nullptr;\n' % member.name - array_element = 'in_struct->%s[i]' % member.name - if member.type in self.structNames: - member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None) - if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True: - array_element = '%s(&in_struct->safe_%s[i])' % (member.type, member.name) - construct_txt += ' if (%s && in_struct->%s) {\n' % (member.len, member.name) - construct_txt += ' %s = new %s[%s];\n' % (member.name, m_type, member.len) - destruct_txt += ' if (%s)\n' % member.name - destruct_txt += ' delete[] %s;\n' % member.name - construct_txt += ' for (uint32_t i=0; i<%s; ++i) {\n' % (member.len) - if 'safe_' in m_type: - construct_txt += ' %s[i].initialize(&in_struct->%s[i]);\n' % (member.name, member.name) - else: - construct_txt += ' %s[i] = %s;\n' % (member.name, array_element) - construct_txt += ' }\n' - construct_txt += ' }\n' - elif member.ispointer == True: - construct_txt += ' if (in_struct->%s)\n' % member.name - construct_txt += ' %s = new %s(in_struct->%s);\n' % (member.name, m_type, member.name) - construct_txt += ' else\n' - construct_txt += ' %s = NULL;\n' % member.name - destruct_txt += ' if (%s)\n' % member.name - destruct_txt += ' delete %s;\n' % member.name - elif 'safe_' in m_type: - init_list += '\n %s(&in_struct->%s),' % (member.name, member.name) - init_func_txt += ' %s.initialize(&in_struct->%s);\n' % (member.name, member.name) - else: - init_list += '\n %s(in_struct->%s),' % (member.name, member.name) - init_func_txt += ' %s = in_struct->%s;\n' % (member.name, member.name) - if '' != init_list: - init_list = init_list[:-1] # hack off final comma - if item.name in custom_construct_txt: - construct_txt = custom_construct_txt[item.name] - if item.name in custom_destruct_txt: - destruct_txt = custom_destruct_txt[item.name] - safe_struct_body.append("\n%s::%s(const %s* in_struct%s) :%s\n{\n%s}" % (ss_name, ss_name, item.name, self.custom_construct_params.get(item.name, ''), init_list, construct_txt)) - if '' != default_init_list: - default_init_list = " :%s" % (default_init_list[:-1]) - safe_struct_body.append("\n%s::%s()%s\n{}" % (ss_name, ss_name, default_init_list)) - # Create slight variation of init and construct txt for copy constructor that takes a src object reference vs. struct ptr - copy_construct_init = init_func_txt.replace('in_struct->', 'src.') - copy_construct_txt = construct_txt.replace(' (in_struct->', ' (src.') # Exclude 'if' blocks from next line - copy_construct_txt = copy_construct_txt.replace('(in_struct->', '(*src.') # Pass object to copy constructors - copy_construct_txt = copy_construct_txt.replace('in_struct->', 'src.') # Modify remaining struct refs for src object - if item.name in custom_copy_txt: - copy_construct_txt = custom_copy_txt[item.name] - copy_assign_txt = ' if (&src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n return *this;' - safe_struct_body.append("\n%s::%s(const %s& src)\n{\n%s%s}" % (ss_name, ss_name, ss_name, copy_construct_init, copy_construct_txt)) # Copy constructor - safe_struct_body.append("\n%s& %s::operator=(const %s& src)\n{\n%s\n}" % (ss_name, ss_name, ss_name, copy_assign_txt)) # Copy assignment operator - safe_struct_body.append("\n%s::~%s()\n{\n%s}" % (ss_name, ss_name, destruct_txt)) - safe_struct_body.append("\nvoid %s::initialize(const %s* in_struct%s)\n{\n%s%s}" % (ss_name, item.name, self.custom_construct_params.get(item.name, ''), init_func_txt, construct_txt)) - # Copy initializer uses same txt as copy constructor but has a ptr and not a reference - init_copy = copy_construct_init.replace('src.', 'src->') - init_construct = copy_construct_txt.replace('src.', 'src->') - safe_struct_body.append("\nvoid %s::initialize(const %s* src)\n{\n%s%s}" % (ss_name, ss_name, init_copy, init_construct)) - if item.ifdef_protect != None: - safe_struct_body.append("#endif // %s\n" % item.ifdef_protect) - return "\n".join(safe_struct_body) - # - # Generate the type map - def GenerateTypeMapHelperHeader(self): - prefix = 'Lvl' - fprefix = 'lvl_' - typemap = prefix + 'TypeMap' - idmap = prefix + 'STypeMap' - type_member = 'Type' - id_member = 'kSType' - id_decl = 'static const VkStructureType ' - generic_header = prefix + 'GenericHeader' - generic_mod_header = prefix + 'GenericModHeader' - typename_func = fprefix + 'typename' - idname_func = fprefix + 'stype_name' - find_func = fprefix + 'find_in_chain' - find_mod_func = fprefix + 'find_mod_in_chain' - init_func = fprefix + 'init_struct' - - explanatory_comment = '\n'.join(( - '// These empty generic templates are specialized for each type with sType', - '// members and for each sType -- providing a two way map between structure', - '// types and sTypes')) - - empty_typemap = 'template <typename T> struct ' + typemap + ' {};' - typemap_format = 'template <> struct {template}<{typename}> {{\n' - typemap_format += ' {id_decl}{id_member} = {id_value};\n' - typemap_format += '}};\n' - - empty_idmap = 'template <VkStructureType id> struct ' + idmap + ' {};' - idmap_format = ''.join(( - 'template <> struct {template}<{id_value}> {{\n', - ' typedef {typename} {typedef};\n', - '}};\n')) - - # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file - utilities_format = '\n'.join(( - '// Header "base class" for pNext chain traversal', - 'struct {header} {{', - ' VkStructureType sType;', - ' const {header} *pNext;', - '}};', - 'struct {mod_header} {{', - ' VkStructureType sType;', - ' {mod_header} *pNext;', - '}};', - '', - '// Find an entry of the given type in the pNext chain', - 'template <typename T> const T *{find_func}(const void *next) {{', - ' const {header} *current = reinterpret_cast<const {header} *>(next);', - ' const T *found = nullptr;', - ' while (current) {{', - ' if ({type_map}<T>::{id_member} == current->sType) {{', - ' found = reinterpret_cast<const T*>(current);', - ' current = nullptr;', - ' }} else {{', - ' current = current->pNext;', - ' }}', - ' }}', - ' return found;', - '}}', - '// Find an entry of the given type in the pNext chain', - 'template <typename T> T *{find_mod_func}(void *next) {{', - ' {mod_header} *current = reinterpret_cast<{mod_header} *>(next);', - ' T *found = nullptr;', - ' while (current) {{', - ' if ({type_map}<T>::{id_member} == current->sType) {{', - ' found = reinterpret_cast<T*>(current);', - ' current = nullptr;', - ' }} else {{', - ' current = current->pNext;', - ' }}', - ' }}', - ' return found;', - '}}', - '', - '// Init the header of an sType struct with pNext', - 'template <typename T> T {init_func}(void *p_next) {{', - ' T out = {{}};', - ' out.sType = {type_map}<T>::kSType;', - ' out.pNext = p_next;', - ' return out;', - '}}', - '', - '// Init the header of an sType struct', - 'template <typename T> T {init_func}() {{', - ' T out = {{}};', - ' out.sType = {type_map}<T>::kSType;', - ' return out;', - '}}', - - '')) - - code = [] - - # Generate header - code.append('\n'.join(( - '#pragma once', - '#include <vulkan/vulkan.h>\n', - explanatory_comment, '', - empty_idmap, - empty_typemap, ''))) - - # Generate the specializations for each type and stype - for item in self.structMembers: - typename = item.name - info = self.structTypes.get(typename) - if not info: - continue - - if item.ifdef_protect != None: - code.append('#ifdef %s' % item.ifdef_protect) - - code.append('// Map type {} to id {}'.format(typename, info.value)) - code.append(typemap_format.format(template=typemap, typename=typename, id_value=info.value, - id_decl=id_decl, id_member=id_member)) - code.append(idmap_format.format(template=idmap, typename=typename, id_value=info.value, typedef=type_member)) - - if item.ifdef_protect != None: - code.append('#endif // %s' % item.ifdef_protect) - - # Generate utilities for all types - code.append('\n'.join(( - utilities_format.format(id_member=id_member, id_map=idmap, type_map=typemap, - type_member=type_member, header=generic_header, mod_header=generic_mod_header, - typename_func=typename_func, idname_func=idname_func, find_func=find_func, - find_mod_func=find_mod_func, init_func=init_func), '' - ))) - - return "\n".join(code) - - # - # Create a helper file and return it as a string - def OutputDestFile(self): - if self.helper_file_type == 'enum_string_header': - return self.GenerateEnumStringHelperHeader() - elif self.helper_file_type == 'safe_struct_header': - return self.GenerateSafeStructHelperHeader() - elif self.helper_file_type == 'safe_struct_source': - return self.GenerateSafeStructHelperSource() - elif self.helper_file_type == 'object_types_header': - return self.GenerateObjectTypesHelperHeader() - elif self.helper_file_type == 'extension_helper_header': - return self.GenerateExtensionHelperHeader() - elif self.helper_file_type == 'typemap_helper_header': - return self.GenerateTypeMapHelperHeader() - else: - return 'Bad Helper File Generator Option %s' % self.helper_file_type
diff --git a/scripts/vulkaninfo_generator.py b/scripts/vulkaninfo_generator.py deleted file mode 100644 index c0d7ee4..0000000 --- a/scripts/vulkaninfo_generator.py +++ /dev/null
@@ -1,1203 +0,0 @@ -#!/usr/bin/python3 -# -# Copyright (c) 2019-2022 Valve Corporation -# Copyright (c) 2019-2022 LunarG, Inc. -# Copyright (c) 2019-2022 Google Inc. -# Copyright (c) 2023-2023 RasterGrid Kft. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Author: Charles Giessen <charles@lunarg.com> - -import re -import sys -import operator -from collections import OrderedDict -import generator as gen -from common_codegen import GetFeatureProtect -from generator import GeneratorOptions, OutputGenerator - -LICENSE_HEADER = ''' -/* - * Copyright (c) 2019-2022 The Khronos Group Inc. - * Copyright (c) 2019-2022 Valve Corporation - * Copyright (c) 2019-2022 LunarG, Inc. - * Copyright (c) 2023-2023 RasterGrid Kft. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Charles Giessen <charles@lunarg.com> - * - */ - -/* - * This file is generated from the Khronos Vulkan XML API Registry. - */ -''' - -CUSTOM_FORMATTERS = r''' -template <typename T> -std::string to_hex_str(const T i) { - std::stringstream stream; - stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i; - return stream.str(); -} - -template <typename T> -std::string to_hex_str(Printer &p, const T i) { - if (p.Type() == OutputType::json) - return std::to_string(i); - else if (p.Type() == OutputType::vkconfig_output) - return std::string("\"") + to_hex_str(i) + std::string("\""); - else - return to_hex_str(i); -} - -''' - - -# used in the .cpp code -STRUCTURES_TO_GEN = ['VkExtent3D', 'VkExtent2D', 'VkPhysicalDeviceLimits', 'VkPhysicalDeviceFeatures', 'VkPhysicalDeviceSparseProperties', - 'VkSurfaceCapabilitiesKHR', 'VkSurfaceFormatKHR', 'VkLayerProperties', 'VkPhysicalDeviceToolProperties', 'VkFormatProperties', - 'VkSurfacePresentScalingCapabilitiesEXT', 'VkSurfacePresentModeCompatibilityEXT', 'VkPhysicalDeviceHostImageCopyProperties'] -ENUMS_TO_GEN = ['VkResult', 'VkFormat', 'VkPresentModeKHR', - 'VkPhysicalDeviceType', 'VkImageTiling'] -FLAGS_TO_GEN = ['VkSurfaceTransformFlagsKHR', 'VkCompositeAlphaFlagsKHR', 'VkSurfaceCounterFlagsEXT', 'VkQueueFlags', - 'VkDeviceGroupPresentModeFlagsKHR', 'VkFormatFeatureFlags', 'VkFormatFeatureFlags2', 'VkMemoryPropertyFlags', 'VkMemoryHeapFlags'] -FLAG_STRINGS_TO_GEN = ['VkQueueFlags'] - -STRUCT_SHORT_VERSIONS_TO_GEN = ['VkExtent3D'] - -STRUCT_COMPARISONS_TO_GEN = ['VkSurfaceFormatKHR', 'VkSurfaceFormat2KHR', 'VkSurfaceCapabilitiesKHR', - 'VkSurfaceCapabilities2KHR', 'VkSurfaceCapabilities2EXT'] -# don't generate these structures -STRUCT_BLACKLIST = ['VkVideoProfileListInfoKHR', 'VkVideoProfileInfoKHR', 'VkDrmFormatModifierPropertiesListEXT', 'VkDrmFormatModifierPropertiesEXT', 'VkDrmFormatModifierPropertiesList2EXT'] -# These structures are only used in version 1.1, otherwise they are included in the promoted structs -STRUCT_1_1_LIST = ['VkPhysicalDeviceProtectedMemoryFeatures', 'VkPhysicalDeviceShaderDrawParametersFeatures', 'VkPhysicalDeviceSubgroupProperties', 'VkPhysicalDeviceProtectedMemoryProperties'] - -# generate these structures such that they only print when not in json mode (as json wants them separate) -PORTABILITY_STRUCTS = ['VkPhysicalDevicePortabilitySubsetFeaturesKHR', 'VkPhysicalDevicePortabilitySubsetPropertiesKHR'] - -# iostream or custom outputter handles these types -PREDEFINED_TYPES = ['char', 'VkBool32', 'uint32_t', 'uint8_t', 'int32_t', - 'float', 'uint64_t', 'size_t', 'VkDeviceSize', 'int64_t'] - -NAMES_TO_IGNORE = ['sType', 'pNext', 'stdProfileIdc'] - -EXTENSION_TYPE_INSTANCE = 'instance' -EXTENSION_TYPE_DEVICE = 'device' -EXTENSION_TYPE_BOTH = 'both' - -# Types that need pNext Chains built. 'extends' is the xml tag used in the structextends member. 'type' can be device, instance, or both -EXTENSION_CATEGORIES = OrderedDict(( - ('phys_device_props2', - {'extends': 'VkPhysicalDeviceProperties2', - 'type': EXTENSION_TYPE_BOTH, - 'holder_type': 'VkPhysicalDeviceProperties2', - 'print_iterator': True, - 'can_show_promoted_structs': True}), - ('phys_device_mem_props2', - {'extends': 'VkPhysicalDeviceMemoryProperties2', - 'type': EXTENSION_TYPE_DEVICE, - 'holder_type':'VkPhysicalDeviceMemoryProperties2', - 'print_iterator': False, - 'can_show_promoted_structs': False}), - ('phys_device_features2', - {'extends': 'VkPhysicalDeviceFeatures2,VkDeviceCreateInfo', - 'type': EXTENSION_TYPE_DEVICE, - 'holder_type': 'VkPhysicalDeviceFeatures2', - 'print_iterator': True, - 'can_show_promoted_structs': True}), - ('surface_capabilities2', - {'extends': 'VkSurfaceCapabilities2KHR', - 'type': EXTENSION_TYPE_BOTH, - 'holder_type': 'VkSurfaceCapabilities2KHR', - 'print_iterator': True, - 'can_show_promoted_structs': False, - 'exclude': ['VkSurfacePresentScalingCapabilitiesEXT', 'VkSurfacePresentModeCompatibilityEXT']}), - ('format_properties2', - {'extends': 'VkFormatProperties2', - 'type': EXTENSION_TYPE_DEVICE, - 'holder_type':'VkFormatProperties2', - 'print_iterator': True, - 'can_show_promoted_structs': False}), - ('queue_properties2', - {'extends': 'VkQueueFamilyProperties2', - 'type': EXTENSION_TYPE_DEVICE, - 'holder_type': 'VkQueueFamilyProperties2', - 'print_iterator': True, - 'can_show_promoted_structs': False}) - )) -class VulkanInfoGeneratorOptions(GeneratorOptions): - def __init__(self, - conventions=None, - input=None, - filename=None, - directory='.', - genpath = None, - apiname=None, - profile=None, - versions='.*', - emitversions='.*', - defaultExtensions=None, - addExtensions=None, - removeExtensions=None, - emitExtensions=None, - sortProcedure=None, - prefixText='', - genFuncPointers=True, - protectFile=True, - protectFeature=True, - protectProto=None, - protectProtoStr=None, - apicall='', - apientry='', - apientryp='', - indentFuncProto=True, - indentFuncPointer=False, - alignFuncParam=0, - expandEnumerants=True, - ): - GeneratorOptions.__init__(self, - conventions = conventions, - filename = filename, - directory = directory, - genpath = genpath, - apiname = apiname, - profile = profile, - versions = versions, - emitversions = emitversions, - defaultExtensions = defaultExtensions, - addExtensions = addExtensions, - removeExtensions = removeExtensions, - emitExtensions = emitExtensions, - sortProcedure = sortProcedure) - self.input = input - self.prefixText = prefixText - self.genFuncPointers = genFuncPointers - self.protectFile = protectFile - self.protectFeature = protectFeature - self.protectProto = protectProto - self.protectProtoStr = protectProtoStr - self.apicall = apicall - self.apientry = apientry - self.apientryp = apientryp - self.indentFuncProto = indentFuncProto - self.indentFuncPointer = indentFuncPointer - self.alignFuncParam = alignFuncParam - -# VulkanInfoGenerator - subclass of OutputGenerator. -# Generates a vulkan info output helper function - - -class VulkanInfoGenerator(OutputGenerator): - - def __init__(self, - errFile=sys.stderr, - warnFile=sys.stderr, - diagFile=sys.stdout): - OutputGenerator.__init__(self, errFile, warnFile, diagFile) - - self.constants = OrderedDict() - - self.types_to_gen = set() - - self.extension_sets = OrderedDict() - for ext_cat in EXTENSION_CATEGORIES.keys(): - self.extension_sets[ext_cat] = set() - - self.enums = [] - self.flags = [] - self.bitmasks = [] - self.format_ranges = [] - self.all_structures = [] - self.aliases = OrderedDict() - - self.extFuncs = OrderedDict() - self.extTypes = OrderedDict() - - self.vendor_abbreviations = [] - self.vulkan_versions = [] - - def beginFile(self, genOpts): - gen.OutputGenerator.beginFile(self, genOpts) - - for node in self.registry.reg.findall('enums'): - if node.get('name') == 'API Constants': - for item in node.findall('enum'): - self.constants[item.get('name')] = item.get('value') - - for node in self.registry.reg.find('extensions').findall('extension'): - ext = VulkanExtension(node) - for item in ext.vktypes: - if item not in self.extTypes: - self.extTypes[item] = [] - self.extTypes[item].append(ext) - for item in ext.vkfuncs: - self.extFuncs[item] = ext - - # need list of venders to blacklist vendor extensions - for tag in self.registry.reg.find('tags'): - if tag.get('name') not in ['KHR', 'EXT']: - self.vendor_abbreviations.append('_' + tag.get('name')) - - for ver in self.registry.reg.findall('feature'): - self.vulkan_versions.append(VulkanVersion(ver)) - - def endFile(self): - self.findFormatRanges() - - # gather the types that are needed to generate - types_to_gen = set() - for s in ENUMS_TO_GEN: - types_to_gen.add(s) - - for f in FLAGS_TO_GEN: - types_to_gen.add(f) - - types_to_gen.update( - GatherTypesToGen(self.all_structures, STRUCTURES_TO_GEN)) - for key, info in EXTENSION_CATEGORIES.items(): - types_to_gen.update( - GatherTypesToGen(self.all_structures, self.extension_sets[key], info.get('exclude'))) - types_to_gen = sorted(types_to_gen) - - names_of_structures_to_gen = set() - for s in self.all_structures: - if s.name in types_to_gen: - names_of_structures_to_gen.add(s.name) - names_of_structures_to_gen = sorted(names_of_structures_to_gen) - - structs_to_comp = set() - for s in STRUCT_COMPARISONS_TO_GEN: - structs_to_comp.add(s) - structs_to_comp.update( - GatherTypesToGen(self.all_structures, STRUCT_COMPARISONS_TO_GEN)) - - for key, value in self.extension_sets.items(): - self.extension_sets[key] = sorted(value) - - self.enums = sorted(self.enums, key=operator.attrgetter('name')) - self.flags = sorted(self.flags, key=operator.attrgetter('name')) - self.bitmasks = sorted(self.bitmasks, key=operator.attrgetter('name')) - self.all_structures = sorted(self.all_structures, key=operator.attrgetter('name')) - - # print the types gathered - out = '' - out += LICENSE_HEADER + '\n' - out += '#include "vulkaninfo.h"\n' - out += '#include "outputprinter.h"\n' - out += CUSTOM_FORMATTERS - - for enum in (e for e in self.enums if e.name in types_to_gen): - out += PrintEnumToString(enum, self) - out += PrintEnum(enum, self) - - for flag in self.flags: - if flag.name in types_to_gen: - for bitmask in (b for b in self.bitmasks if b.name == flag.enum): - out += PrintBitMask(bitmask, flag.name, self) - - if flag.name in FLAG_STRINGS_TO_GEN: - for bitmask in (b for b in self.bitmasks if b.name == flag.enum): - out += PrintBitMaskToString(bitmask, flag.name, self) - - for s in (x for x in self.all_structures if x.name in types_to_gen and x.name not in STRUCT_BLACKLIST): - out += PrintStructure(s) - - for key, value in EXTENSION_CATEGORIES.items(): - out += PrintChainStruct(key, self.extension_sets[key], self.all_structures, value, self.extTypes, self.aliases, self.vulkan_versions) - - for s in (x for x in self.all_structures if x.name in structs_to_comp): - out += PrintStructComparisonForwardDecl(s) - for s in (x for x in self.all_structures if x.name in structs_to_comp): - out += PrintStructComparison(s) - for s in (x for x in self.all_structures if x.name in STRUCT_SHORT_VERSIONS_TO_GEN): - out += PrintStructShort(s) - - out += 'auto format_ranges = std::array{\n' - for f in self.format_ranges: - out += f' FormatRange{{{f.minimum_instance_version}, {f.extension_name if f.extension_name is not None else "nullptr"}, ' - out += f'static_cast<VkFormat>({f.first_format}), static_cast<VkFormat>({f.last_format})}},\n' - out += '};\n' - - - gen.write(out, file=self.outFile) - - gen.OutputGenerator.endFile(self) - - def genCmd(self, cmd, name, alias): - gen.OutputGenerator.genCmd(self, cmd, name, alias) - - # These are actually constants - def genEnum(self, enuminfo, name, alias): - gen.OutputGenerator.genEnum(self, enuminfo, name, alias) - - # These are actually enums - def genGroup(self, groupinfo, groupName, alias): - gen.OutputGenerator.genGroup(self, groupinfo, groupName, alias) - - if alias is not None: - if alias in self.aliases.keys(): - self.aliases[alias].append(groupName) - else: - self.aliases[alias] = [groupName, ] - return - - if groupinfo.elem.get('type') == 'bitmask': - self.bitmasks.append(VulkanBitmask(groupinfo.elem)) - elif groupinfo.elem.get('type') == 'enum': - self.enums.append(VulkanEnum(groupinfo.elem)) - - def genType(self, typeinfo, name, alias): - gen.OutputGenerator.genType(self, typeinfo, name, alias) - - if alias is not None: - if alias in self.aliases.keys(): - self.aliases[alias].append(name) - else: - self.aliases[alias] = [name, ] - return - - if typeinfo.elem.get('category') == 'bitmask': - self.flags.append(VulkanFlags(typeinfo.elem)) - - if typeinfo.elem.get('category') == 'struct': - self.all_structures.append(VulkanStructure( - name, typeinfo.elem, self.constants, self.extTypes)) - - for vendor in self.vendor_abbreviations: - for node in typeinfo.elem.findall('member'): - if node.get('values') is not None: - if node.get('values').find(vendor) != -1: - return - - for key, value in EXTENSION_CATEGORIES.items(): - if str(typeinfo.elem.get('structextends')).find(value.get('extends')) != -1: - if value.get('exclude') is None or name not in value.get('exclude'): - self.extension_sets[key].add(name) - - # finds all the ranges of formats from core (1.0), core versions (1.1+), and extensions - def findFormatRanges(self): - for enums in self.registry.reg.findall('enums'): - if enums.get('name') == 'VkFormat': - min_val = 2**32 - max_val = 0 - for enum in enums.findall('enum'): - if enum.get('value') is None: - continue - value = int(enum.get('value')) - min_val = min(min_val, value) - max_val = max(max_val, value) - if min_val < 2**32 and max_val > 0: - self.format_ranges.append(VulkanFormatRange(0, None, min_val, max_val)) - - for feature in self.registry.reg.findall('feature'): - for require in feature.findall('require'): - comment = require.get('comment') - original_ext = None - if comment is not None and comment.find('Promoted from') >= 0: - # may need tweaking in the future - some ext names aren't just the upper case version - original_ext = comment.split(' ')[2].upper() + '_EXTENSION_NAME' - # insert an underscore before numbers in the name define - original_ext = re.sub(r'([A-Z])(\d+)', r'\1_\2', original_ext) - min_val = 2**32 - max_val = 0 - for enum in require.findall('enum'): - if enum.get('extends') == 'VkFormat': - value = CalcEnumValue(int(enum.get('extnumber')), int(enum.get('offset'))) - min_val = min(min_val, value) - max_val = max(max_val, value) - if min_val < 2**32 and max_val > 0: - self.format_ranges.append(VulkanFormatRange(feature.get('name').replace('_VERSION_', '_API_VERSION_'), None, min_val, max_val)) - # If the formats came from an extension, add a format range for that extension so it'll be printed if the ext is supported but not the core version - if original_ext is not None: - self.format_ranges.append(VulkanFormatRange(0, original_ext, min_val, max_val)) - - for extension in self.registry.reg.find('extensions').findall('extension'): - if not self.genOpts.apiname in extension.get('supported').split(','): - continue - - min_val = 2**32 - max_val = 0 - enum_name_string = '' - for require in extension.findall('require'): - for enum in require.findall('enum'): - if enum.get('value') is not None and enum.get('value').find(extension.get('name')): - enum_name_string = enum.get('name') - if enum.get('extends') == 'VkFormat': - if enum.get('offset') is None: - continue - value = CalcEnumValue(int(extension.get('number')), int(enum.get('offset'))) - min_val = min(min_val, value) - max_val = max(max_val, value) - if min_val < 2**32 and max_val > 0: - self.format_ranges.append(VulkanFormatRange(0, enum_name_string, min_val, max_val)) - - - -def GatherTypesToGen(structure_list, structures, exclude = None): - if exclude is None: - exclude = [] - types = set() - for s in structures: - types.add(s) - added_stuff = True # repeat until no new types are added - while added_stuff is True: - added_stuff = False - for s in structure_list: - if s.name in types: - for m in s.members: - if m.typeID not in PREDEFINED_TYPES and m.name not in NAMES_TO_IGNORE: - if m.typeID not in types: - if s.name not in exclude: - types.add(m.typeID) - added_stuff = True - return types - - -def GetExtension(name, generator): - if name in generator.extFuncs: - return generator.extFuncs[name] - elif name in generator.extTypes: - return generator.extTypes[name][0] - else: - return None - - -def AddGuardHeader(obj): - if obj is not None and obj.guard is not None: - return f'#ifdef {obj.guard}\n' - else: - return '' - - -def AddGuardFooter(obj): - if obj is not None and obj.guard is not None: - return f'#endif // {obj.guard}\n' - else: - return '' - -def CalcEnumValue(num, offset): - base = 1000000000 - block_size = 1000 - return base + (num - 1) * block_size + offset - -def PrintEnumToString(enum, generator): - out = '' - out += AddGuardHeader(GetExtension(enum.name, generator)) - out += f'std::string {enum.name}String({enum.name} value) {{\n' - out += ' switch (value) {\n' - for v in enum.options: - out += f' case ({v.name}): return "{v.name[3:]}";\n' - out += f' default: return std::string("UNKNOWN_{enum.name}_value") + std::to_string(value);\n' - out += ' }\n}\n' - out += AddGuardFooter(GetExtension(enum.name, generator)) - return out - - -def PrintEnum(enum, generator): - out = '' - out += AddGuardHeader(GetExtension(enum.name, generator)) - out += f'''void Dump{enum.name}(Printer &p, std::string name, {enum.name} value) {{ - if (p.Type() == OutputType::json) - p.PrintKeyString(name, std::string("VK_") + {enum.name}String(value)); - else - p.PrintKeyString(name, {enum.name}String(value)); -}} -''' - out += AddGuardFooter(GetExtension(enum.name, generator)) - return out - - -def PrintGetFlagStrings(name, bitmask): - out = '' - out += f'std::vector<const char *> {name}GetStrings({name} value) {{\n' - out += ' std::vector<const char *> strings;\n' - # If a bitmask contains a field whose value is zero, we want to support printing the correct bitflag - # Otherwise, use "None" for when there are not bits set in the bitmask - if bitmask.options[0].value != 0: - out += ' if (value == 0) { strings.push_back("None"); return strings; }\n' - for v in bitmask.options: - # only check single-bit flags - if (v.value & (v.value - 1)) == 0: - out += f' if ({v.name} & value) strings.push_back("{v.name[3:]}");\n' - out += ' return strings;\n}\n' - return out - - -def PrintFlags(bitmask, name): - out = f'void Dump{name}(Printer &p, std::string name, {name} value) {{\n' - out += f''' if (static_cast<{bitmask.name}>(value) == 0) {{ - ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); - return; - }} - auto strings = {bitmask.name}GetStrings(static_cast<{bitmask.name}>(value)); - ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){{ - if (p.Type() == OutputType::json) - p.SetAsType().PrintString(std::string("VK_") + str); - else - p.SetAsType().PrintString(str); - }} -}} -''' - return out - - -def PrintFlagBits(bitmask): - return f'''void Dump{bitmask.name}(Printer &p, std::string name, {bitmask.name} value) {{ - auto strings = {bitmask.name}GetStrings(value); - if (strings.size() > 0) {{ - if (p.Type() == OutputType::json) - p.PrintKeyString(name, std::string("VK_") + strings.at(0)); - else - p.PrintKeyString(name, strings.at(0)); - }} -}} -''' - - - -def PrintBitMask(bitmask, name, generator): - out = PrintGetFlagStrings(bitmask.name, bitmask) - out += AddGuardHeader(GetExtension(bitmask.name, generator)) - out += PrintFlags(bitmask, name) - out += PrintFlagBits(bitmask) - out += AddGuardFooter(GetExtension(bitmask.name, generator)) - out += '\n' - return out - - -def PrintBitMaskToString(bitmask, name, generator): - out = AddGuardHeader(GetExtension(bitmask.name, generator)) - out += f'std::string {name}String({name} value) {{\n' - out += ' std::string out;\n' - out += ' bool is_first = true;\n' - for v in bitmask.options: - out += f' if ({v.name} & value) {{\n' - out += ' if (is_first) { is_first = false; } else { out += " | "; }\n' - out += f' out += "{str(v.name)[3:]}";\n' - out += ' }\n' - out += ' return out;\n' - out += '}\n' - out += AddGuardFooter(GetExtension(bitmask.name, generator)) - return out - - -def PrintStructure(struct): - if len(struct.members) == 0: - return '' - out = '' - out += AddGuardHeader(struct) - max_key_len = 0 - for v in struct.members: - if v.arrayLength is not None: - if len(v.name) + len(v.arrayLength) + 2 > max_key_len: - max_key_len = len(v.name) + len(v.arrayLength) + 2 - elif v.typeID in PREDEFINED_TYPES or v.typeID in STRUCT_BLACKLIST: - if len(v.name) > max_key_len: - max_key_len = len(v.name) - - out += f'void Dump{struct.name}(Printer &p, std::string name, const {struct.name} &obj) {{\n' - if struct.name == 'VkPhysicalDeviceLimits': - out += ' if (p.Type() == OutputType::json)\n' - out += ' p.ObjectStart("limits");\n' - out += ' else\n' - out += ' p.SetSubHeader().ObjectStart(name);\n' - elif struct.name == 'VkPhysicalDeviceSparseProperties': - out += ' if (p.Type() == OutputType::json)\n' - out += ' p.ObjectStart("sparseProperties");\n' - out += ' else\n' - out += ' p.SetSubHeader().ObjectStart(name);\n' - else: - out += ' ObjectWrapper object{p, name};\n' - if max_key_len > 0: - out += f' p.SetMinKeyWidth({max_key_len});\n' - for v in struct.members: - # arrays - if v.arrayLength is not None: - # strings - if v.typeID == 'char': - out += f' p.PrintKeyString("{v.name}", obj.{v.name});\n' - # uuid's - elif v.typeID == 'uint8_t' and (v.arrayLength == '8' or v.arrayLength == '16'): # VK_UUID_SIZE - if v.arrayLength == '8': - out += ' if (obj.deviceLUIDValid) { // special case\n' - out += f' p.PrintKeyValue("{v.name}", obj.{v.name});\n' - if v.arrayLength == '8': - out += ' }\n' - elif struct.name == 'VkQueueFamilyGlobalPriorityProperties' and v.name == 'priorities': - out += f' ArrayWrapper arr(p,"{v.name}", obj.priorityCount);\n' - out += ' for (uint32_t i = 0; i < obj.priorityCount; i++) {\n' - out += ' if (p.Type() == OutputType::json)\n' - out += ' p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i]));\n' - out += ' else\n' - out += ' p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i]));\n' - out += ' }\n' - elif v.arrayLength.isdigit(): - out += f' {{\n ArrayWrapper arr(p,"{v.name}", ' + v.arrayLength + ');\n' - out += f' for (uint32_t i = 0; i < {v.arrayLength}; i++) {{ p.PrintElement(obj.{v.name}[i]); }}\n' - out += ' }\n' - else: # dynamic array length based on other member - out += f' if (obj.{v.arrayLength} == 0 || obj.{v.name} == nullptr) {{\n' - out += f' p.PrintKeyString("{v.name}", "NULL");\n' - out += ' } else {\n' - out += f' ArrayWrapper arr(p,"{v.name}", obj.{v.arrayLength});\n' - out += f' for (uint32_t i = 0; i < obj.{v.arrayLength}; i++) {{\n' - out += f' Dump{v.typeID}(p, std::to_string(i), obj.{v.name}[i]);\n' - out += ' }\n' - out += ' }\n' - elif v.typeID == 'VkBool32': - out += f' p.PrintKeyBool("{v.name}", static_cast<bool>(obj.{v.name}));\n' - elif v.typeID == 'uint8_t': - out += f' p.PrintKeyValue("{v.name}", static_cast<uint32_t>(obj.{v.name}));\n' - elif v.typeID == 'VkDeviceSize': - out += f' p.PrintKeyValue("{v.name}", to_hex_str(p, obj.{v.name}));\n' - elif v.typeID in PREDEFINED_TYPES: - out += f' p.PrintKeyValue("{v.name}", obj.{v.name});\n' - elif v.name not in NAMES_TO_IGNORE: - # if it is an enum/flag/bitmask - if v.typeID in ['VkFormatFeatureFlags', 'VkFormatFeatureFlags2']: - out += ' p.SetOpenDetails();\n' # special case so that feature flags are open in html output - out += f' Dump{v.typeID}(p, "{v.name}", obj.{v.name});\n' - - if struct.name in ['VkPhysicalDeviceLimits', 'VkPhysicalDeviceSparseProperties']: - out += ' p.ObjectEnd();\n' - out += '}\n' - - out += AddGuardFooter(struct) - return out - - -def PrintStructShort(struct): - out = '' - out += AddGuardHeader(struct) - out += f'std::ostream &operator<<(std::ostream &o, {struct.name} &obj) {{\n' - out += ' return o << "(" << ' - - first = True - for v in struct.members: - if first: - first = False - out += f'obj.{v.name} << ' - else: - out += f'\',\' << obj.{v.name} << ' - out += '")";\n' - out += '}\n' - out += AddGuardFooter(struct) - return out - -def PrintChainStruct(listName, structures, all_structures, chain_details, extTypes, aliases, vulkan_versions): - sorted_structures = sorted( - all_structures, key=operator.attrgetter('name')) - - version_desc = '' - if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: - version_desc = 'gpu.api_version' - else: - version_desc = 'inst.instance_version' - - out = '' - structs_to_print = [] - for s in sorted_structures: - if s.name in structures: - structs_to_print.append(s) - # use default constructor and delete copy & move operators - out += f'''struct {listName}_chain {{ - {listName}_chain() = default; - {listName}_chain(const {listName}_chain &) = delete; - {listName}_chain& operator=(const {listName}_chain &) = delete; - {listName}_chain({listName}_chain &&) = delete; - {listName}_chain& operator=({listName}_chain &&) = delete; -''' - - out += ' void* start_of_chain = nullptr;\n' - for s in structs_to_print: - if s.name in STRUCT_BLACKLIST: - continue - out += AddGuardHeader(s) - if s.sTypeName is not None: - out += f' {s.name} {s.name[2:]}{{}};\n' - # Specific versions of drivers have an incorrect definition of the size of these structs. - # We need to artificially pad the structure it just so the driver doesn't write out of bounds and - # into other structures that are adjacent. This bug comes from the in-development version of - # the extension having a larger size than the final version, so older drivers try to write to - # members which don't exist. - if s.name in ['VkPhysicalDeviceShaderIntegerDotProductFeatures', 'VkPhysicalDeviceHostImageCopyFeaturesEXT']: - out += f' char {s.name}_padding[64];\n' - if s.hasLengthmember: - for member in s.members: - if member.lengthMember: - out += f' std::vector<{member.typeID}> {s.name}_{member.name};\n' - out += AddGuardFooter(s) - out += ' void initialize_chain(' - if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]: - out += 'AppInstance &inst, ' - if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: - out += 'AppGpu &gpu ' - if chain_details.get('can_show_promoted_structs'): - out += ', bool show_promoted_structs' - out += ') noexcept {\n' - for s in structs_to_print: - if s.name in STRUCT_BLACKLIST: - continue - out += AddGuardHeader(s) - out += f' {s.name[2:]}.sType = {s.sTypeName};\n' - out += AddGuardFooter(s) - - - out += ' std::vector<VkBaseOutStructure*> chain_members{};\n' - for s in structs_to_print: - if s.name in STRUCT_BLACKLIST: - continue - out += AddGuardHeader(s) - extEnables = {} - for k, elem in extTypes.items(): - if k == s.name or (s.name in aliases.keys() and k in aliases[s.name]): - for e in elem: - extEnables[e.extNameStr] = e.type - - version = None - oldVersionName = None - for v in vulkan_versions: - if s.name in v.names: - version = v - if s.name in aliases.keys(): - for alias in aliases[s.name]: - oldVersionName = alias - - has_version = version is not None - has_extNameStr = len(extEnables) > 0 or s.name in aliases.keys() - if has_version or has_extNameStr: - out += ' if (' - has_printed_condition = False - if has_extNameStr: - for key, value in extEnables.items(): - if has_printed_condition: - out += '\n || ' - else: - has_printed_condition = True - if has_version: - out += '(' - if value == EXTENSION_TYPE_DEVICE: - out += f'gpu.CheckPhysicalDeviceExtensionIncluded({key})' - elif value == EXTENSION_TYPE_INSTANCE: - out += f'inst.CheckExtensionEnabled({key})' - else: - assert False, 'Should never get here' - if has_version: - str_show_promoted_structs = '|| show_promoted_structs' if chain_details.get('can_show_promoted_structs') else '' - if s.name in STRUCT_1_1_LIST: - out += f'{version_desc} == {version.constant} {str_show_promoted_structs}' - elif has_printed_condition: - out += f')\n && ({version_desc} < {version.constant} {str_show_promoted_structs})' - else: - out += f'({version_desc} >= {version.constant})' - out += ')\n ' - else: - out += ' ' - out += f'chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&{s.name[2:]}));\n' - out += AddGuardFooter(s) - chain_param_list = [] - chain_arg_list = [] - if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]: - chain_param_list.append('AppInstance &inst') - chain_arg_list.append('inst') - if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: - chain_param_list.append('AppGpu &gpu') - chain_arg_list.append('gpu') - if chain_details.get('can_show_promoted_structs'): - chain_param_list.append('bool show_promoted_structs') - chain_arg_list.append('show_promoted_structs') - - out += f''' - if (!chain_members.empty()) {{ - for(size_t i = 0; i < chain_members.size() - 1; i++){{ - chain_members[i]->pNext = chain_members[i + 1]; - }} - start_of_chain = chain_members[0]; - }} - }} -}}; -void setup_{listName}_chain({chain_details['holder_type']}& start, std::unique_ptr<{listName}_chain>& chain, {','.join(chain_param_list)}){{ - chain = std::unique_ptr<{listName}_chain>(new {listName}_chain()); - chain->initialize_chain({','.join(chain_arg_list)}); - start.pNext = chain->start_of_chain; -}}; -''' - if chain_details.get('print_iterator'): - out += '\n' - out += f'void chain_iterator_{listName}(Printer &p, ' - if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]: - out += 'AppInstance &inst, ' - if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]: - out += 'AppGpu &gpu, ' - if chain_details.get('can_show_promoted_structs'): - out += 'bool show_promoted_structs, ' - out += 'void * place) {\n' - out += ' while (place) {\n' - out += ' struct VkBaseOutStructure *structure = (struct VkBaseOutStructure *)place;\n' - out += ' p.SetSubHeader();\n' - - for s in sorted_structures: - if s.sTypeName is None or s.name in STRUCT_BLACKLIST: - continue - - extEnables = {} - for k, elem in extTypes.items(): - if k == s.name or (s.name in aliases.keys() and k in aliases[s.name]): - for e in elem: - extEnables[e.extNameStr] = e.type - - version = None - oldVersionName = None - for v in vulkan_versions: - if s.name in v.names: - version = v - if s.name in aliases.keys(): - for alias in aliases[s.name]: - oldVersionName = alias - - if s.name in structures: - out += AddGuardHeader(s) - out += f' if (structure->sType == {s.sTypeName}' - if s.name in PORTABILITY_STRUCTS: - out += ' && p.Type() != OutputType::json' - has_version = version is not None - has_extNameStr = len(extEnables) > 0 or s.name in aliases.keys() - out += ') {\n' - out += f' {s.name}* props = ({s.name}*)structure;\n' - out += f' Dump{s.name}(p, ' - if s.name in aliases.keys() and version is not None: - out += f'{version_desc} >= {version.constant} ?"{s.name}":"{oldVersionName}"' - else: - out += f'"{s.name}"' - out += ', *props);\n' - out += ' p.AddNewline();\n' - out += ' }\n' - out += AddGuardFooter(s) - out += ' place = structure->pNext;\n' - out += ' }\n' - out += '}\n' - - out += '\n' - out += f'bool prepare_{listName}_twocall_chain_vectors(std::unique_ptr<{listName}_chain>& chain) {{\n' - out += ' (void)chain;\n' - is_twocall = False - for s in structs_to_print: - if not s.hasLengthmember: - continue - if s.name in STRUCT_BLACKLIST: - continue - out += AddGuardHeader(s) - for member in s.members: - if member.lengthMember: - out += f' chain->{s.name}_{member.name}.resize(chain->{s.name[2:]}.{member.arrayLength});\n' - out += f' chain->{s.name[2:]}.{member.name} = chain->{s.name}_{member.name}.data();\n' - out += AddGuardFooter(s) - is_twocall = True - out += f' return {"true" if is_twocall else "false"};\n' - out += '}\n' - - return out - - -def PrintStructComparisonForwardDecl(structure): - out = '' - out += f'bool operator==(const {structure.name} & a, const {structure.name} b);\n' - return out - - -def PrintStructComparison(structure): - out = '' - out += f'bool operator==(const {structure.name} & a, const {structure.name} b) {{\n' - out += ' return ' - is_first = True - for m in structure.members: - if m.name not in NAMES_TO_IGNORE: - if not is_first: - out += '\n && ' - else: - is_first = False - out += f'a.{m.name} == b.{m.name}' - out += ';\n' - out += '}\n' - return out - - -class VulkanEnum: - class Option: - - def __init__(self, name, value, bitpos, comment): - self.name = name - self.comment = comment - - if bitpos is not None: - value = 1 << int(bitpos) - elif isinstance(value, str): - if value.lower().startswith('0x'): - value = int(value, 16) - else: - value = int(value) - - self.value = value - - def values(self): - return { - 'optName': self.name, - 'optValue': self.value, - 'optComment': self.comment, - } - - def __init__(self, rootNode): - self.name = rootNode.get('name') - self.type = rootNode.get('type') - self.options = [] - - for child in rootNode: - childName = child.get('name') - childValue = child.get('value') - childBitpos = child.get('bitpos') - childComment = child.get('comment') - childExtends = child.get('extends') - childOffset = child.get('offset') - childExtNum = child.get('extnumber') - support = child.get('supported') - if support == 'disabled': - continue - - if childName is None: - continue - if childValue is None and childBitpos is None and childOffset is None: - continue - - if childExtends is not None and childExtNum is not None and childOffset is not None: - childValue = CalcEnumValue(int(childExtNum), int(childOffset)) - if 'dir' in child.keys(): - childValue = -childValue - duplicate = False - for o in self.options: - if o.values()['optName'] == childName: - duplicate = True - if duplicate: - continue - - self.options.append(VulkanEnum.Option( - childName, childValue, childBitpos, childComment)) - - -class VulkanBitmask: - - def __init__(self, rootNode): - self.name = rootNode.get('name') - self.type = rootNode.get('type') - - # Read each value that the enum contains - self.options = [] - for child in rootNode: - childName = child.get('name') - childValue = child.get('value') - childBitpos = child.get('bitpos') - childComment = child.get('comment') - support = child.get('supported') - if childName is None or (childValue is None and childBitpos is None): - continue - if support == 'disabled': - continue - - duplicate = False - for option in self.options: - if option.name == childName: - duplicate = True - if duplicate: - continue - - self.options.append(VulkanEnum.Option( - childName, childValue, childBitpos, childComment)) - - -class VulkanFlags: - - def __init__(self, rootNode): - self.name = rootNode.get('name') - self.type = rootNode.get('type') - self.enum = rootNode.get('requires') - # 64 bit flags use bitvalues, not requires - if self.enum is None: - self.enum = rootNode.get('bitvalues') - - -class VulkanVariable: - def __init__(self, rootNode, constants): - self.name = rootNode.find('name').text - # Typename, dereferenced and converted to a useable C++ token - self.typeID = rootNode.find('type').text - self.baseType = self.typeID - self.childType = None - self.arrayLength = None - self.text = '' - for node in rootNode.itertext(): - comment = rootNode.find('comment') - if comment is not None and comment.text == node: - continue - self.text += node - - typeMatch = re.search('.+?(?=' + self.name + ')', self.text) - self.type = typeMatch.string[typeMatch.start():typeMatch.end()] - self.type = ' '.join(self.type.split()) - bracketMatch = re.search('(?<=\\[)[a-zA-Z0-9_]+(?=\\])', self.text) - if bracketMatch is not None: - matchText = bracketMatch.string[bracketMatch.start( - ):bracketMatch.end()] - self.childType = self.type - self.type += '[' + matchText + ']' - if matchText in constants: - self.arrayLength = constants[matchText] - else: - self.arrayLength = matchText - - self.lengthMember = False - lengthString = rootNode.get('len') - lengths = [] - if lengthString is not None: - lengths = re.split(',', lengthString) - lengths = list(filter(('null-terminated').__ne__, lengths)) - if self.arrayLength is None and len(lengths) > 0: - self.childType = '*'.join(self.type.split('*')[0:-1]) - self.arrayLength = lengths[0] - self.lengthMember = True - if self.arrayLength is not None and self.arrayLength.startswith('latexmath'): - code = self.arrayLength[10:len(self.arrayLength)] - code = re.sub('\\[', '', code) - code = re.sub('\\]', '', code) - code = re.sub('\\\\(lceil|rceil)', '', code) - code = re.sub('{|}', '', code) - code = re.sub('\\\\mathit', '', code) - code = re.sub('\\\\over', '/', code) - code = re.sub('\\\\textrm', '', code) - self.arrayLength = code - - # Dereference if necessary and handle members of variables - if self.arrayLength is not None: - self.arrayLength = re.sub('::', '->', self.arrayLength) - sections = self.arrayLength.split('->') - if sections[-1][0] == 'p' and sections[0][1].isupper(): - self.arrayLength = '*' + self.arrayLength - - -class VulkanStructure: - def __init__(self, name, rootNode, constants, extTypes): - self.name = name - self.members = [] - self.guard = None - self.sTypeName = None - self.extendsStruct = rootNode.get('structextends') - self.hasLengthmember = False - - for node in rootNode.findall('member'): - if node.get('values') is not None: - self.sTypeName = node.get('values') - self.members.append(VulkanVariable(node, constants)) - - for member in self.members: - if member.lengthMember: - self.hasLengthmember = True - break - - for k, elem in extTypes.items(): - if k == self.name: - for e in elem: - if e.guard is not None: - self.guard = e.guard - - -class VulkanExtension: - def __init__(self, rootNode): - self.name = rootNode.get('name') - self.number = int(rootNode.get('number')) - self.type = rootNode.get('type') - self.dependency = rootNode.get('requires') - self.guard = GetFeatureProtect(rootNode) - self.supported = rootNode.get('supported') - self.extNameStr = None - self.vktypes = [] - self.vkfuncs = [] - self.constants = OrderedDict() - self.enumValues = OrderedDict() - self.node = rootNode - - for req in rootNode.findall('require'): - for ty in req.findall('type'): - self.vktypes.append(ty.get('name')) - - for func in req.findall('command'): - self.vkfuncs.append(func.get('name')) - - for enum in req.findall('enum'): - base = enum.get('extends') - name = enum.get('name') - value = enum.get('value') - bitpos = enum.get('bitpos') - offset = enum.get('offset') - # gets the VK_XXX_EXTENSION_NAME string - if value == f'"{self.name}"': - self.extNameStr = name - - if value is None and bitpos is not None: - value = 1 << int(bitpos) - - if offset is not None: - offset = int(offset) - if base is not None and offset is not None: - enumValue = 1000000000 + 1000*(self.number - 1) + offset - if enum.get('dir') == '-': - enumValue = -enumValue - self.enumValues[base] = (name, enumValue) - else: - self.constants[name] = value - - -class VulkanVersion: - def __init__(self, rootNode): - self.name = rootNode.get('name') - self.constant = self.name.replace('_VERSION_', '_API_VERSION_') - self.names = set() - - for req in rootNode.findall('require'): - for ty in req.findall('type'): - self.names.add(ty.get('name')) - for func in req.findall('command'): - self.names.add(func.get('name')) - for enum in req.findall('enum'): - self.names.add(enum.get('name')) - self.names = sorted(self.names) - -class VulkanFormatRange: - def __init__(self, min_inst_version, ext_name, first, last): - self.minimum_instance_version = min_inst_version - self.extension_name = ext_name - self.first_format = first - self.last_format = last
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 8a35ae3..a1b7250 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt
@@ -29,6 +29,11 @@ return() endif() +# Testing isn't supported with mingw +if (MINGW) + return() +endif() + find_package(VulkanLoader CONFIG) find_package(GTest REQUIRED CONFIG QUIET)
diff --git a/tests/icd/mock_icd_tests.cpp b/tests/icd/mock_icd_tests.cpp index 8d45ed1..06fc124 100644 --- a/tests/icd/mock_icd_tests.cpp +++ b/tests/icd/mock_icd_tests.cpp
@@ -240,7 +240,7 @@ } VkResult create_surface(VkInstance instance, VkSurfaceKHR& surface) { - VkDisplaySurfaceCreateInfoKHR surf_create_info{}; + VkDisplaySurfaceCreateInfoKHR surf_create_info{VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR}; return vkCreateDisplayPlaneSurfaceKHR(instance, &surf_create_info, nullptr, &surface); } @@ -1141,40 +1141,7 @@ video_format_info.pNext = &video_profile_list; uint32_t count = 0; VkResult res = vkGetPhysicalDeviceVideoFormatPropertiesKHR(physical_device, &video_format_info, &count, nullptr); - ASSERT_EQ(res, VK_SUCCESS); - ASSERT_EQ(count, 3); - std::array<VkVideoFormatPropertiesKHR, 3> video_format_properties{}; - res = vkGetPhysicalDeviceVideoFormatPropertiesKHR(physical_device, &video_format_info, &count, video_format_properties.data()); - ASSERT_EQ(res, VK_SUCCESS); - ASSERT_EQ(count, 3); - ASSERT_EQ(video_format_properties[0].format, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM); - ASSERT_EQ(video_format_properties[0].imageCreateFlags, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_ALIAS_BIT | - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT | VK_IMAGE_CREATE_PROTECTED_BIT | - VK_IMAGE_CREATE_DISJOINT_BIT); - ASSERT_EQ(video_format_properties[0].imageType, VK_IMAGE_TYPE_2D); - ASSERT_EQ(video_format_properties[0].imageTiling, VK_IMAGE_TILING_OPTIMAL); - ASSERT_EQ(video_format_properties[0].imageUsageFlags, - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR); - ASSERT_EQ(video_format_properties[1].format, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM); - ASSERT_EQ(video_format_properties[1].imageCreateFlags, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_ALIAS_BIT | - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT | VK_IMAGE_CREATE_PROTECTED_BIT | - VK_IMAGE_CREATE_DISJOINT_BIT); - ASSERT_EQ(video_format_properties[1].imageType, VK_IMAGE_TYPE_2D); - ASSERT_EQ(video_format_properties[1].imageTiling, VK_IMAGE_TILING_OPTIMAL); - ASSERT_EQ(video_format_properties[1].imageUsageFlags, - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | - VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR); - ASSERT_EQ(video_format_properties[2].format, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM); - ASSERT_EQ(video_format_properties[2].imageCreateFlags, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_ALIAS_BIT | - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT | VK_IMAGE_CREATE_PROTECTED_BIT | - VK_IMAGE_CREATE_DISJOINT_BIT); - ASSERT_EQ(video_format_properties[2].imageType, VK_IMAGE_TYPE_2D); - ASSERT_EQ(video_format_properties[2].imageTiling, VK_IMAGE_TILING_OPTIMAL); - ASSERT_EQ(video_format_properties[2].imageUsageFlags, - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | - VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR); + ASSERT_EQ(res, VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR); } TEST_F(MockICD, vkGetPhysicalDeviceVideoCapabilitiesKHR) { @@ -1202,22 +1169,7 @@ video_capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; video_capabilities.pNext = &decode_capabilities; VkResult res = vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile_info, &video_capabilities); - ASSERT_EQ(res, VK_SUCCESS); - ASSERT_EQ(video_capabilities.flags, VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR); - ASSERT_EQ(video_capabilities.minBitstreamBufferOffsetAlignment, 256); - ASSERT_EQ(video_capabilities.minBitstreamBufferSizeAlignment, 256); - ASSERT_EQ(video_capabilities.pictureAccessGranularity.width, 16); - ASSERT_EQ(video_capabilities.pictureAccessGranularity.height, 16); - ASSERT_EQ(video_capabilities.minCodedExtent.width, 16); - ASSERT_EQ(video_capabilities.minCodedExtent.height, 16); - ASSERT_EQ(video_capabilities.maxCodedExtent.width, 1920); - ASSERT_EQ(video_capabilities.maxCodedExtent.height, 1080); - ASSERT_EQ(video_capabilities.maxDpbSlots, 33); - ASSERT_EQ(video_capabilities.maxActiveReferencePictures, 32); - ASSERT_EQ(decode_capabilities.flags, VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR); - ASSERT_EQ(decode_h264_capabilities.maxLevelIdc, STD_VIDEO_H264_LEVEL_IDC_6_2); - ASSERT_EQ(decode_h264_capabilities.fieldOffsetGranularity.x, 0); - ASSERT_EQ(decode_h264_capabilities.fieldOffsetGranularity.y, 0); + ASSERT_EQ(res, VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR); } TEST_F(MockICD, vkGetDescriptorSetLayoutSupport) {
diff --git a/vulkaninfo/BUILD.gn b/vulkaninfo/BUILD.gn index 5bc2d03..56c6a9e 100644 --- a/vulkaninfo/BUILD.gn +++ b/vulkaninfo/BUILD.gn
@@ -25,6 +25,7 @@ "-Wno-missing-field-initializers", "-Wno-extra-semi", "-Wno-ambiguous-reversed-operator", + "-fno-sanitize=enum", ] }
diff --git a/vulkaninfo/CMakeLists.txt b/vulkaninfo/CMakeLists.txt index 7e51bb2..ed61c89 100644 --- a/vulkaninfo/CMakeLists.txt +++ b/vulkaninfo/CMakeLists.txt
@@ -93,6 +93,7 @@ target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_DIRECTFB_EXT) target_link_libraries(vulkaninfo PRIVATE PkgConfig::DirectFB) endif() + target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_DISPLAY) endif() if(APPLE) @@ -109,7 +110,6 @@ target_link_libraries(vulkaninfo PRIVATE Vulkan::Headers ${CMAKE_DL_LIBS} - volk::volk_headers ) if(WIN32)
diff --git a/vulkaninfo/generated/vulkaninfo.hpp b/vulkaninfo/generated/vulkaninfo.hpp index 191e9ab..200874e 100644 --- a/vulkaninfo/generated/vulkaninfo.hpp +++ b/vulkaninfo/generated/vulkaninfo.hpp
@@ -1,9 +1,9 @@ /* - * Copyright (c) 2019-2022 The Khronos Group Inc. - * Copyright (c) 2019-2022 Valve Corporation - * Copyright (c) 2019-2022 LunarG, Inc. - * Copyright (c) 2023-2023 RasterGrid Kft. + * Copyright (c) 2019-2026 The Khronos Group Inc. + * Copyright (c) 2019-2026 Valve Corporation + * Copyright (c) 2019-2026 LunarG, Inc. + * Copyright (c) 2023-2024 RasterGrid Kft. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -36,7 +36,7 @@ } template <typename T> -std::string to_hex_str(Printer &p, const T i) { +std::string to_hex_str(Printer& p, const T i) { if (p.Type() == OutputType::json) return std::to_string(i); else if (p.Type() == OutputType::vkconfig_output) @@ -45,66 +45,1144 @@ return to_hex_str(i); } -std::string VkColorSpaceKHRString(VkColorSpaceKHR value) { +std::string StdVideoH264ChromaFormatIdcString(StdVideoH264ChromaFormatIdc value) { switch (value) { - case (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR): return "COLOR_SPACE_SRGB_NONLINEAR_KHR"; - case (VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT): return "COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"; - case (VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT): return "COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT"; - case (VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT): return "COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"; - case (VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT): return "COLOR_SPACE_DCI_P3_NONLINEAR_EXT"; - case (VK_COLOR_SPACE_BT709_LINEAR_EXT): return "COLOR_SPACE_BT709_LINEAR_EXT"; - case (VK_COLOR_SPACE_BT709_NONLINEAR_EXT): return "COLOR_SPACE_BT709_NONLINEAR_EXT"; - case (VK_COLOR_SPACE_BT2020_LINEAR_EXT): return "COLOR_SPACE_BT2020_LINEAR_EXT"; - case (VK_COLOR_SPACE_HDR10_ST2084_EXT): return "COLOR_SPACE_HDR10_ST2084_EXT"; - case (VK_COLOR_SPACE_DOLBYVISION_EXT): return "COLOR_SPACE_DOLBYVISION_EXT"; - case (VK_COLOR_SPACE_HDR10_HLG_EXT): return "COLOR_SPACE_HDR10_HLG_EXT"; - case (VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT): return "COLOR_SPACE_ADOBERGB_LINEAR_EXT"; - case (VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT): return "COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"; - case (VK_COLOR_SPACE_PASS_THROUGH_EXT): return "COLOR_SPACE_PASS_THROUGH_EXT"; - case (VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT): return "COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT"; - case (VK_COLOR_SPACE_DISPLAY_NATIVE_AMD): return "COLOR_SPACE_DISPLAY_NATIVE_AMD"; - default: return std::string("UNKNOWN_VkColorSpaceKHR_value") + std::to_string(value); + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME: + return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME"; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_420: + return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_420"; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_422: + return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_422"; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_444: + return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_444"; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID: + return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264ChromaFormatIdc_value") + std::to_string(value); } } -void DumpVkColorSpaceKHR(Printer &p, std::string name, VkColorSpaceKHR value) { +void DumpStdVideoH264ChromaFormatIdc(Printer& p, std::string name, StdVideoH264ChromaFormatIdc value) { + p.PrintKeyString(name, StdVideoH264ChromaFormatIdcString(value)); +} +std::string StdVideoH264ProfileIdcString(StdVideoH264ProfileIdc value) { + switch (value) { + case STD_VIDEO_H264_PROFILE_IDC_BASELINE: + return "STD_VIDEO_H264_PROFILE_IDC_BASELINE"; + case STD_VIDEO_H264_PROFILE_IDC_MAIN: + return "STD_VIDEO_H264_PROFILE_IDC_MAIN"; + case STD_VIDEO_H264_PROFILE_IDC_HIGH: + return "STD_VIDEO_H264_PROFILE_IDC_HIGH"; + case STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: + return "STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE"; + case STD_VIDEO_H264_PROFILE_IDC_INVALID: + return "STD_VIDEO_H264_PROFILE_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264ProfileIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH264ProfileIdc(Printer& p, std::string name, StdVideoH264ProfileIdc value) { + p.PrintKeyString(name, StdVideoH264ProfileIdcString(value)); +} +std::string StdVideoH264LevelIdcString(StdVideoH264LevelIdc value) { + switch (value) { + case STD_VIDEO_H264_LEVEL_IDC_1_0: + return "STD_VIDEO_H264_LEVEL_IDC_1_0"; + case STD_VIDEO_H264_LEVEL_IDC_1_1: + return "STD_VIDEO_H264_LEVEL_IDC_1_1"; + case STD_VIDEO_H264_LEVEL_IDC_1_2: + return "STD_VIDEO_H264_LEVEL_IDC_1_2"; + case STD_VIDEO_H264_LEVEL_IDC_1_3: + return "STD_VIDEO_H264_LEVEL_IDC_1_3"; + case STD_VIDEO_H264_LEVEL_IDC_2_0: + return "STD_VIDEO_H264_LEVEL_IDC_2_0"; + case STD_VIDEO_H264_LEVEL_IDC_2_1: + return "STD_VIDEO_H264_LEVEL_IDC_2_1"; + case STD_VIDEO_H264_LEVEL_IDC_2_2: + return "STD_VIDEO_H264_LEVEL_IDC_2_2"; + case STD_VIDEO_H264_LEVEL_IDC_3_0: + return "STD_VIDEO_H264_LEVEL_IDC_3_0"; + case STD_VIDEO_H264_LEVEL_IDC_3_1: + return "STD_VIDEO_H264_LEVEL_IDC_3_1"; + case STD_VIDEO_H264_LEVEL_IDC_3_2: + return "STD_VIDEO_H264_LEVEL_IDC_3_2"; + case STD_VIDEO_H264_LEVEL_IDC_4_0: + return "STD_VIDEO_H264_LEVEL_IDC_4_0"; + case STD_VIDEO_H264_LEVEL_IDC_4_1: + return "STD_VIDEO_H264_LEVEL_IDC_4_1"; + case STD_VIDEO_H264_LEVEL_IDC_4_2: + return "STD_VIDEO_H264_LEVEL_IDC_4_2"; + case STD_VIDEO_H264_LEVEL_IDC_5_0: + return "STD_VIDEO_H264_LEVEL_IDC_5_0"; + case STD_VIDEO_H264_LEVEL_IDC_5_1: + return "STD_VIDEO_H264_LEVEL_IDC_5_1"; + case STD_VIDEO_H264_LEVEL_IDC_5_2: + return "STD_VIDEO_H264_LEVEL_IDC_5_2"; + case STD_VIDEO_H264_LEVEL_IDC_6_0: + return "STD_VIDEO_H264_LEVEL_IDC_6_0"; + case STD_VIDEO_H264_LEVEL_IDC_6_1: + return "STD_VIDEO_H264_LEVEL_IDC_6_1"; + case STD_VIDEO_H264_LEVEL_IDC_6_2: + return "STD_VIDEO_H264_LEVEL_IDC_6_2"; + case STD_VIDEO_H264_LEVEL_IDC_INVALID: + return "STD_VIDEO_H264_LEVEL_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264LevelIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH264LevelIdc(Printer& p, std::string name, StdVideoH264LevelIdc value) { + p.PrintKeyString(name, StdVideoH264LevelIdcString(value)); +} +std::string StdVideoH264PocTypeString(StdVideoH264PocType value) { + switch (value) { + case STD_VIDEO_H264_POC_TYPE_0: + return "STD_VIDEO_H264_POC_TYPE_0"; + case STD_VIDEO_H264_POC_TYPE_1: + return "STD_VIDEO_H264_POC_TYPE_1"; + case STD_VIDEO_H264_POC_TYPE_2: + return "STD_VIDEO_H264_POC_TYPE_2"; + case STD_VIDEO_H264_POC_TYPE_INVALID: + return "STD_VIDEO_H264_POC_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264PocType_value") + std::to_string(value); + } +} +void DumpStdVideoH264PocType(Printer& p, std::string name, StdVideoH264PocType value) { + p.PrintKeyString(name, StdVideoH264PocTypeString(value)); +} +std::string StdVideoH264AspectRatioIdcString(StdVideoH264AspectRatioIdc value) { + switch (value) { + case STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR"; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID: + return "STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264AspectRatioIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH264AspectRatioIdc(Printer& p, std::string name, StdVideoH264AspectRatioIdc value) { + p.PrintKeyString(name, StdVideoH264AspectRatioIdcString(value)); +} +std::string StdVideoH264WeightedBipredIdcString(StdVideoH264WeightedBipredIdc value) { + switch (value) { + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT: + return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT"; + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT: + return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT"; + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT: + return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT"; + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID: + return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264WeightedBipredIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH264WeightedBipredIdc(Printer& p, std::string name, StdVideoH264WeightedBipredIdc value) { + p.PrintKeyString(name, StdVideoH264WeightedBipredIdcString(value)); +} +std::string StdVideoH264ModificationOfPicNumsIdcString(StdVideoH264ModificationOfPicNumsIdc value) { + switch (value) { + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT: + return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT"; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD: + return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD"; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM: + return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM"; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END: + return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END"; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID: + return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264ModificationOfPicNumsIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH264ModificationOfPicNumsIdc(Printer& p, std::string name, StdVideoH264ModificationOfPicNumsIdc value) { + p.PrintKeyString(name, StdVideoH264ModificationOfPicNumsIdcString(value)); +} +std::string StdVideoH264MemMgmtControlOpString(StdVideoH264MemMgmtControlOp value) { + switch (value) { + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END"; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM"; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM"; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM"; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX"; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL"; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM"; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID: + return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264MemMgmtControlOp_value") + std::to_string(value); + } +} +void DumpStdVideoH264MemMgmtControlOp(Printer& p, std::string name, StdVideoH264MemMgmtControlOp value) { + p.PrintKeyString(name, StdVideoH264MemMgmtControlOpString(value)); +} +std::string StdVideoH264CabacInitIdcString(StdVideoH264CabacInitIdc value) { + switch (value) { + case STD_VIDEO_H264_CABAC_INIT_IDC_0: + return "STD_VIDEO_H264_CABAC_INIT_IDC_0"; + case STD_VIDEO_H264_CABAC_INIT_IDC_1: + return "STD_VIDEO_H264_CABAC_INIT_IDC_1"; + case STD_VIDEO_H264_CABAC_INIT_IDC_2: + return "STD_VIDEO_H264_CABAC_INIT_IDC_2"; + case STD_VIDEO_H264_CABAC_INIT_IDC_INVALID: + return "STD_VIDEO_H264_CABAC_INIT_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264CabacInitIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH264CabacInitIdc(Printer& p, std::string name, StdVideoH264CabacInitIdc value) { + p.PrintKeyString(name, StdVideoH264CabacInitIdcString(value)); +} +std::string StdVideoH264DisableDeblockingFilterIdcString(StdVideoH264DisableDeblockingFilterIdc value) { + switch (value) { + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED: + return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED"; + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED: + return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED"; + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL: + return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL"; + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID: + return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264DisableDeblockingFilterIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH264DisableDeblockingFilterIdc(Printer& p, std::string name, StdVideoH264DisableDeblockingFilterIdc value) { + p.PrintKeyString(name, StdVideoH264DisableDeblockingFilterIdcString(value)); +} +std::string StdVideoH264SliceTypeString(StdVideoH264SliceType value) { + switch (value) { + case STD_VIDEO_H264_SLICE_TYPE_P: + return "STD_VIDEO_H264_SLICE_TYPE_P"; + case STD_VIDEO_H264_SLICE_TYPE_B: + return "STD_VIDEO_H264_SLICE_TYPE_B"; + case STD_VIDEO_H264_SLICE_TYPE_I: + return "STD_VIDEO_H264_SLICE_TYPE_I"; + case STD_VIDEO_H264_SLICE_TYPE_INVALID: + return "STD_VIDEO_H264_SLICE_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264SliceType_value") + std::to_string(value); + } +} +void DumpStdVideoH264SliceType(Printer& p, std::string name, StdVideoH264SliceType value) { + p.PrintKeyString(name, StdVideoH264SliceTypeString(value)); +} +std::string StdVideoH264PictureTypeString(StdVideoH264PictureType value) { + switch (value) { + case STD_VIDEO_H264_PICTURE_TYPE_P: + return "STD_VIDEO_H264_PICTURE_TYPE_P"; + case STD_VIDEO_H264_PICTURE_TYPE_B: + return "STD_VIDEO_H264_PICTURE_TYPE_B"; + case STD_VIDEO_H264_PICTURE_TYPE_I: + return "STD_VIDEO_H264_PICTURE_TYPE_I"; + case STD_VIDEO_H264_PICTURE_TYPE_IDR: + return "STD_VIDEO_H264_PICTURE_TYPE_IDR"; + case STD_VIDEO_H264_PICTURE_TYPE_INVALID: + return "STD_VIDEO_H264_PICTURE_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264PictureType_value") + std::to_string(value); + } +} +void DumpStdVideoH264PictureType(Printer& p, std::string name, StdVideoH264PictureType value) { + p.PrintKeyString(name, StdVideoH264PictureTypeString(value)); +} +std::string StdVideoH264NonVclNaluTypeString(StdVideoH264NonVclNaluType value) { + switch (value) { + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS"; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS"; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD"; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX"; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE"; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM"; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED"; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID: + return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH264NonVclNaluType_value") + std::to_string(value); + } +} +void DumpStdVideoH264NonVclNaluType(Printer& p, std::string name, StdVideoH264NonVclNaluType value) { + p.PrintKeyString(name, StdVideoH264NonVclNaluTypeString(value)); +} +std::string StdVideoDecodeH264FieldOrderCountString(StdVideoDecodeH264FieldOrderCount value) { + switch (value) { + case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP: + return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP"; + case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM: + return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM"; + case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID: + return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID"; + default: + return std::string("UNKNOWN_StdVideoDecodeH264FieldOrderCount_value") + std::to_string(value); + } +} +void DumpStdVideoDecodeH264FieldOrderCount(Printer& p, std::string name, StdVideoDecodeH264FieldOrderCount value) { + p.PrintKeyString(name, StdVideoDecodeH264FieldOrderCountString(value)); +} +std::string StdVideoH265ChromaFormatIdcString(StdVideoH265ChromaFormatIdc value) { + switch (value) { + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME: + return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME"; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_420: + return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_420"; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_422: + return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_422"; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_444: + return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_444"; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID: + return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH265ChromaFormatIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH265ChromaFormatIdc(Printer& p, std::string name, StdVideoH265ChromaFormatIdc value) { + p.PrintKeyString(name, StdVideoH265ChromaFormatIdcString(value)); +} +std::string StdVideoH265ProfileIdcString(StdVideoH265ProfileIdc value) { + switch (value) { + case STD_VIDEO_H265_PROFILE_IDC_MAIN: + return "STD_VIDEO_H265_PROFILE_IDC_MAIN"; + case STD_VIDEO_H265_PROFILE_IDC_MAIN_10: + return "STD_VIDEO_H265_PROFILE_IDC_MAIN_10"; + case STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE: + return "STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE"; + case STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: + return "STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS"; + case STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: + return "STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS"; + case STD_VIDEO_H265_PROFILE_IDC_INVALID: + return "STD_VIDEO_H265_PROFILE_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH265ProfileIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH265ProfileIdc(Printer& p, std::string name, StdVideoH265ProfileIdc value) { + p.PrintKeyString(name, StdVideoH265ProfileIdcString(value)); +} +std::string StdVideoH265LevelIdcString(StdVideoH265LevelIdc value) { + switch (value) { + case STD_VIDEO_H265_LEVEL_IDC_1_0: + return "STD_VIDEO_H265_LEVEL_IDC_1_0"; + case STD_VIDEO_H265_LEVEL_IDC_2_0: + return "STD_VIDEO_H265_LEVEL_IDC_2_0"; + case STD_VIDEO_H265_LEVEL_IDC_2_1: + return "STD_VIDEO_H265_LEVEL_IDC_2_1"; + case STD_VIDEO_H265_LEVEL_IDC_3_0: + return "STD_VIDEO_H265_LEVEL_IDC_3_0"; + case STD_VIDEO_H265_LEVEL_IDC_3_1: + return "STD_VIDEO_H265_LEVEL_IDC_3_1"; + case STD_VIDEO_H265_LEVEL_IDC_4_0: + return "STD_VIDEO_H265_LEVEL_IDC_4_0"; + case STD_VIDEO_H265_LEVEL_IDC_4_1: + return "STD_VIDEO_H265_LEVEL_IDC_4_1"; + case STD_VIDEO_H265_LEVEL_IDC_5_0: + return "STD_VIDEO_H265_LEVEL_IDC_5_0"; + case STD_VIDEO_H265_LEVEL_IDC_5_1: + return "STD_VIDEO_H265_LEVEL_IDC_5_1"; + case STD_VIDEO_H265_LEVEL_IDC_5_2: + return "STD_VIDEO_H265_LEVEL_IDC_5_2"; + case STD_VIDEO_H265_LEVEL_IDC_6_0: + return "STD_VIDEO_H265_LEVEL_IDC_6_0"; + case STD_VIDEO_H265_LEVEL_IDC_6_1: + return "STD_VIDEO_H265_LEVEL_IDC_6_1"; + case STD_VIDEO_H265_LEVEL_IDC_6_2: + return "STD_VIDEO_H265_LEVEL_IDC_6_2"; + case STD_VIDEO_H265_LEVEL_IDC_INVALID: + return "STD_VIDEO_H265_LEVEL_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH265LevelIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH265LevelIdc(Printer& p, std::string name, StdVideoH265LevelIdc value) { + p.PrintKeyString(name, StdVideoH265LevelIdcString(value)); +} +std::string StdVideoH265SliceTypeString(StdVideoH265SliceType value) { + switch (value) { + case STD_VIDEO_H265_SLICE_TYPE_B: + return "STD_VIDEO_H265_SLICE_TYPE_B"; + case STD_VIDEO_H265_SLICE_TYPE_P: + return "STD_VIDEO_H265_SLICE_TYPE_P"; + case STD_VIDEO_H265_SLICE_TYPE_I: + return "STD_VIDEO_H265_SLICE_TYPE_I"; + case STD_VIDEO_H265_SLICE_TYPE_INVALID: + return "STD_VIDEO_H265_SLICE_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH265SliceType_value") + std::to_string(value); + } +} +void DumpStdVideoH265SliceType(Printer& p, std::string name, StdVideoH265SliceType value) { + p.PrintKeyString(name, StdVideoH265SliceTypeString(value)); +} +std::string StdVideoH265PictureTypeString(StdVideoH265PictureType value) { + switch (value) { + case STD_VIDEO_H265_PICTURE_TYPE_P: + return "STD_VIDEO_H265_PICTURE_TYPE_P"; + case STD_VIDEO_H265_PICTURE_TYPE_B: + return "STD_VIDEO_H265_PICTURE_TYPE_B"; + case STD_VIDEO_H265_PICTURE_TYPE_I: + return "STD_VIDEO_H265_PICTURE_TYPE_I"; + case STD_VIDEO_H265_PICTURE_TYPE_IDR: + return "STD_VIDEO_H265_PICTURE_TYPE_IDR"; + case STD_VIDEO_H265_PICTURE_TYPE_INVALID: + return "STD_VIDEO_H265_PICTURE_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH265PictureType_value") + std::to_string(value); + } +} +void DumpStdVideoH265PictureType(Printer& p, std::string name, StdVideoH265PictureType value) { + p.PrintKeyString(name, StdVideoH265PictureTypeString(value)); +} +std::string StdVideoH265AspectRatioIdcString(StdVideoH265AspectRatioIdc value) { + switch (value) { + case STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR"; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID: + return "STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID"; + default: + return std::string("UNKNOWN_StdVideoH265AspectRatioIdc_value") + std::to_string(value); + } +} +void DumpStdVideoH265AspectRatioIdc(Printer& p, std::string name, StdVideoH265AspectRatioIdc value) { + p.PrintKeyString(name, StdVideoH265AspectRatioIdcString(value)); +} +std::string StdVideoAV1ProfileString(StdVideoAV1Profile value) { + switch (value) { + case STD_VIDEO_AV1_PROFILE_MAIN: + return "STD_VIDEO_AV1_PROFILE_MAIN"; + case STD_VIDEO_AV1_PROFILE_HIGH: + return "STD_VIDEO_AV1_PROFILE_HIGH"; + case STD_VIDEO_AV1_PROFILE_PROFESSIONAL: + return "STD_VIDEO_AV1_PROFILE_PROFESSIONAL"; + case STD_VIDEO_AV1_PROFILE_INVALID: + return "STD_VIDEO_AV1_PROFILE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1Profile_value") + std::to_string(value); + } +} +void DumpStdVideoAV1Profile(Printer& p, std::string name, StdVideoAV1Profile value) { + p.PrintKeyString(name, StdVideoAV1ProfileString(value)); +} +std::string StdVideoAV1LevelString(StdVideoAV1Level value) { + switch (value) { + case STD_VIDEO_AV1_LEVEL_2_0: + return "STD_VIDEO_AV1_LEVEL_2_0"; + case STD_VIDEO_AV1_LEVEL_2_1: + return "STD_VIDEO_AV1_LEVEL_2_1"; + case STD_VIDEO_AV1_LEVEL_2_2: + return "STD_VIDEO_AV1_LEVEL_2_2"; + case STD_VIDEO_AV1_LEVEL_2_3: + return "STD_VIDEO_AV1_LEVEL_2_3"; + case STD_VIDEO_AV1_LEVEL_3_0: + return "STD_VIDEO_AV1_LEVEL_3_0"; + case STD_VIDEO_AV1_LEVEL_3_1: + return "STD_VIDEO_AV1_LEVEL_3_1"; + case STD_VIDEO_AV1_LEVEL_3_2: + return "STD_VIDEO_AV1_LEVEL_3_2"; + case STD_VIDEO_AV1_LEVEL_3_3: + return "STD_VIDEO_AV1_LEVEL_3_3"; + case STD_VIDEO_AV1_LEVEL_4_0: + return "STD_VIDEO_AV1_LEVEL_4_0"; + case STD_VIDEO_AV1_LEVEL_4_1: + return "STD_VIDEO_AV1_LEVEL_4_1"; + case STD_VIDEO_AV1_LEVEL_4_2: + return "STD_VIDEO_AV1_LEVEL_4_2"; + case STD_VIDEO_AV1_LEVEL_4_3: + return "STD_VIDEO_AV1_LEVEL_4_3"; + case STD_VIDEO_AV1_LEVEL_5_0: + return "STD_VIDEO_AV1_LEVEL_5_0"; + case STD_VIDEO_AV1_LEVEL_5_1: + return "STD_VIDEO_AV1_LEVEL_5_1"; + case STD_VIDEO_AV1_LEVEL_5_2: + return "STD_VIDEO_AV1_LEVEL_5_2"; + case STD_VIDEO_AV1_LEVEL_5_3: + return "STD_VIDEO_AV1_LEVEL_5_3"; + case STD_VIDEO_AV1_LEVEL_6_0: + return "STD_VIDEO_AV1_LEVEL_6_0"; + case STD_VIDEO_AV1_LEVEL_6_1: + return "STD_VIDEO_AV1_LEVEL_6_1"; + case STD_VIDEO_AV1_LEVEL_6_2: + return "STD_VIDEO_AV1_LEVEL_6_2"; + case STD_VIDEO_AV1_LEVEL_6_3: + return "STD_VIDEO_AV1_LEVEL_6_3"; + case STD_VIDEO_AV1_LEVEL_7_0: + return "STD_VIDEO_AV1_LEVEL_7_0"; + case STD_VIDEO_AV1_LEVEL_7_1: + return "STD_VIDEO_AV1_LEVEL_7_1"; + case STD_VIDEO_AV1_LEVEL_7_2: + return "STD_VIDEO_AV1_LEVEL_7_2"; + case STD_VIDEO_AV1_LEVEL_7_3: + return "STD_VIDEO_AV1_LEVEL_7_3"; + case STD_VIDEO_AV1_LEVEL_INVALID: + return "STD_VIDEO_AV1_LEVEL_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1Level_value") + std::to_string(value); + } +} +void DumpStdVideoAV1Level(Printer& p, std::string name, StdVideoAV1Level value) { + p.PrintKeyString(name, StdVideoAV1LevelString(value)); +} +std::string StdVideoAV1FrameTypeString(StdVideoAV1FrameType value) { + switch (value) { + case STD_VIDEO_AV1_FRAME_TYPE_KEY: + return "STD_VIDEO_AV1_FRAME_TYPE_KEY"; + case STD_VIDEO_AV1_FRAME_TYPE_INTER: + return "STD_VIDEO_AV1_FRAME_TYPE_INTER"; + case STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY: + return "STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY"; + case STD_VIDEO_AV1_FRAME_TYPE_SWITCH: + return "STD_VIDEO_AV1_FRAME_TYPE_SWITCH"; + case STD_VIDEO_AV1_FRAME_TYPE_INVALID: + return "STD_VIDEO_AV1_FRAME_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1FrameType_value") + std::to_string(value); + } +} +void DumpStdVideoAV1FrameType(Printer& p, std::string name, StdVideoAV1FrameType value) { + p.PrintKeyString(name, StdVideoAV1FrameTypeString(value)); +} +std::string StdVideoAV1ReferenceNameString(StdVideoAV1ReferenceName value) { + switch (value) { + case STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME: + return "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME"; + case STD_VIDEO_AV1_REFERENCE_NAME_INVALID: + return "STD_VIDEO_AV1_REFERENCE_NAME_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1ReferenceName_value") + std::to_string(value); + } +} +void DumpStdVideoAV1ReferenceName(Printer& p, std::string name, StdVideoAV1ReferenceName value) { + p.PrintKeyString(name, StdVideoAV1ReferenceNameString(value)); +} +std::string StdVideoAV1InterpolationFilterString(StdVideoAV1InterpolationFilter value) { + switch (value) { + case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP: + return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP"; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: + return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH"; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: + return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP"; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR: + return "STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR"; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE: + return "STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE"; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID: + return "STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1InterpolationFilter_value") + std::to_string(value); + } +} +void DumpStdVideoAV1InterpolationFilter(Printer& p, std::string name, StdVideoAV1InterpolationFilter value) { + p.PrintKeyString(name, StdVideoAV1InterpolationFilterString(value)); +} +std::string StdVideoAV1TxModeString(StdVideoAV1TxMode value) { + switch (value) { + case STD_VIDEO_AV1_TX_MODE_ONLY_4X4: + return "STD_VIDEO_AV1_TX_MODE_ONLY_4X4"; + case STD_VIDEO_AV1_TX_MODE_LARGEST: + return "STD_VIDEO_AV1_TX_MODE_LARGEST"; + case STD_VIDEO_AV1_TX_MODE_SELECT: + return "STD_VIDEO_AV1_TX_MODE_SELECT"; + case STD_VIDEO_AV1_TX_MODE_INVALID: + return "STD_VIDEO_AV1_TX_MODE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1TxMode_value") + std::to_string(value); + } +} +void DumpStdVideoAV1TxMode(Printer& p, std::string name, StdVideoAV1TxMode value) { + p.PrintKeyString(name, StdVideoAV1TxModeString(value)); +} +std::string StdVideoAV1FrameRestorationTypeString(StdVideoAV1FrameRestorationType value) { + switch (value) { + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE: + return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE"; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER: + return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER"; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ: + return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ"; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE: + return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE"; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID: + return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1FrameRestorationType_value") + std::to_string(value); + } +} +void DumpStdVideoAV1FrameRestorationType(Printer& p, std::string name, StdVideoAV1FrameRestorationType value) { + p.PrintKeyString(name, StdVideoAV1FrameRestorationTypeString(value)); +} +std::string StdVideoAV1ColorPrimariesString(StdVideoAV1ColorPrimaries value) { + switch (value) { + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213"; + case STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID: + return "STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1ColorPrimaries_value") + std::to_string(value); + } +} +void DumpStdVideoAV1ColorPrimaries(Printer& p, std::string name, StdVideoAV1ColorPrimaries value) { + p.PrintKeyString(name, StdVideoAV1ColorPrimariesString(value)); +} +std::string StdVideoAV1TransferCharacteristicsString(StdVideoAV1TransferCharacteristics value) { + switch (value) { + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG"; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID: + return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1TransferCharacteristics_value") + std::to_string(value); + } +} +void DumpStdVideoAV1TransferCharacteristics(Printer& p, std::string name, StdVideoAV1TransferCharacteristics value) { + p.PrintKeyString(name, StdVideoAV1TransferCharacteristicsString(value)); +} +std::string StdVideoAV1MatrixCoefficientsString(StdVideoAV1MatrixCoefficients value) { + switch (value) { + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP"; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID: + return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1MatrixCoefficients_value") + std::to_string(value); + } +} +void DumpStdVideoAV1MatrixCoefficients(Printer& p, std::string name, StdVideoAV1MatrixCoefficients value) { + p.PrintKeyString(name, StdVideoAV1MatrixCoefficientsString(value)); +} +std::string StdVideoAV1ChromaSamplePositionString(StdVideoAV1ChromaSamplePosition value) { + switch (value) { + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN: + return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN"; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL: + return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL"; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED: + return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED"; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED: + return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED"; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID: + return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID"; + default: + return std::string("UNKNOWN_StdVideoAV1ChromaSamplePosition_value") + std::to_string(value); + } +} +void DumpStdVideoAV1ChromaSamplePosition(Printer& p, std::string name, StdVideoAV1ChromaSamplePosition value) { + p.PrintKeyString(name, StdVideoAV1ChromaSamplePositionString(value)); +} +std::string StdVideoVP9ProfileString(StdVideoVP9Profile value) { + switch (value) { + case STD_VIDEO_VP9_PROFILE_0: + return "STD_VIDEO_VP9_PROFILE_0"; + case STD_VIDEO_VP9_PROFILE_1: + return "STD_VIDEO_VP9_PROFILE_1"; + case STD_VIDEO_VP9_PROFILE_2: + return "STD_VIDEO_VP9_PROFILE_2"; + case STD_VIDEO_VP9_PROFILE_3: + return "STD_VIDEO_VP9_PROFILE_3"; + case STD_VIDEO_VP9_PROFILE_INVALID: + return "STD_VIDEO_VP9_PROFILE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoVP9Profile_value") + std::to_string(value); + } +} +void DumpStdVideoVP9Profile(Printer& p, std::string name, StdVideoVP9Profile value) { + p.PrintKeyString(name, StdVideoVP9ProfileString(value)); +} +std::string StdVideoVP9LevelString(StdVideoVP9Level value) { + switch (value) { + case STD_VIDEO_VP9_LEVEL_1_0: + return "STD_VIDEO_VP9_LEVEL_1_0"; + case STD_VIDEO_VP9_LEVEL_1_1: + return "STD_VIDEO_VP9_LEVEL_1_1"; + case STD_VIDEO_VP9_LEVEL_2_0: + return "STD_VIDEO_VP9_LEVEL_2_0"; + case STD_VIDEO_VP9_LEVEL_2_1: + return "STD_VIDEO_VP9_LEVEL_2_1"; + case STD_VIDEO_VP9_LEVEL_3_0: + return "STD_VIDEO_VP9_LEVEL_3_0"; + case STD_VIDEO_VP9_LEVEL_3_1: + return "STD_VIDEO_VP9_LEVEL_3_1"; + case STD_VIDEO_VP9_LEVEL_4_0: + return "STD_VIDEO_VP9_LEVEL_4_0"; + case STD_VIDEO_VP9_LEVEL_4_1: + return "STD_VIDEO_VP9_LEVEL_4_1"; + case STD_VIDEO_VP9_LEVEL_5_0: + return "STD_VIDEO_VP9_LEVEL_5_0"; + case STD_VIDEO_VP9_LEVEL_5_1: + return "STD_VIDEO_VP9_LEVEL_5_1"; + case STD_VIDEO_VP9_LEVEL_5_2: + return "STD_VIDEO_VP9_LEVEL_5_2"; + case STD_VIDEO_VP9_LEVEL_6_0: + return "STD_VIDEO_VP9_LEVEL_6_0"; + case STD_VIDEO_VP9_LEVEL_6_1: + return "STD_VIDEO_VP9_LEVEL_6_1"; + case STD_VIDEO_VP9_LEVEL_6_2: + return "STD_VIDEO_VP9_LEVEL_6_2"; + case STD_VIDEO_VP9_LEVEL_INVALID: + return "STD_VIDEO_VP9_LEVEL_INVALID"; + default: + return std::string("UNKNOWN_StdVideoVP9Level_value") + std::to_string(value); + } +} +void DumpStdVideoVP9Level(Printer& p, std::string name, StdVideoVP9Level value) { + p.PrintKeyString(name, StdVideoVP9LevelString(value)); +} +std::string StdVideoVP9FrameTypeString(StdVideoVP9FrameType value) { + switch (value) { + case STD_VIDEO_VP9_FRAME_TYPE_KEY: + return "STD_VIDEO_VP9_FRAME_TYPE_KEY"; + case STD_VIDEO_VP9_FRAME_TYPE_NON_KEY: + return "STD_VIDEO_VP9_FRAME_TYPE_NON_KEY"; + case STD_VIDEO_VP9_FRAME_TYPE_INVALID: + return "STD_VIDEO_VP9_FRAME_TYPE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoVP9FrameType_value") + std::to_string(value); + } +} +void DumpStdVideoVP9FrameType(Printer& p, std::string name, StdVideoVP9FrameType value) { + p.PrintKeyString(name, StdVideoVP9FrameTypeString(value)); +} +std::string StdVideoVP9ReferenceNameString(StdVideoVP9ReferenceName value) { + switch (value) { + case STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME: + return "STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME"; + case STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME: + return "STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME"; + case STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME: + return "STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME"; + case STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME: + return "STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME"; + case STD_VIDEO_VP9_REFERENCE_NAME_INVALID: + return "STD_VIDEO_VP9_REFERENCE_NAME_INVALID"; + default: + return std::string("UNKNOWN_StdVideoVP9ReferenceName_value") + std::to_string(value); + } +} +void DumpStdVideoVP9ReferenceName(Printer& p, std::string name, StdVideoVP9ReferenceName value) { + p.PrintKeyString(name, StdVideoVP9ReferenceNameString(value)); +} +std::string StdVideoVP9InterpolationFilterString(StdVideoVP9InterpolationFilter value) { + switch (value) { + case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP: + return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP"; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: + return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH"; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP: + return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP"; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR: + return "STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR"; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE: + return "STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE"; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID: + return "STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID"; + default: + return std::string("UNKNOWN_StdVideoVP9InterpolationFilter_value") + std::to_string(value); + } +} +void DumpStdVideoVP9InterpolationFilter(Printer& p, std::string name, StdVideoVP9InterpolationFilter value) { + p.PrintKeyString(name, StdVideoVP9InterpolationFilterString(value)); +} +std::string StdVideoVP9ColorSpaceString(StdVideoVP9ColorSpace value) { + switch (value) { + case STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN: + return "STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN"; + case STD_VIDEO_VP9_COLOR_SPACE_BT_601: + return "STD_VIDEO_VP9_COLOR_SPACE_BT_601"; + case STD_VIDEO_VP9_COLOR_SPACE_BT_709: + return "STD_VIDEO_VP9_COLOR_SPACE_BT_709"; + case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170: + return "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170"; + case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240: + return "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240"; + case STD_VIDEO_VP9_COLOR_SPACE_BT_2020: + return "STD_VIDEO_VP9_COLOR_SPACE_BT_2020"; + case STD_VIDEO_VP9_COLOR_SPACE_RESERVED: + return "STD_VIDEO_VP9_COLOR_SPACE_RESERVED"; + case STD_VIDEO_VP9_COLOR_SPACE_RGB: + return "STD_VIDEO_VP9_COLOR_SPACE_RGB"; + case STD_VIDEO_VP9_COLOR_SPACE_INVALID: + return "STD_VIDEO_VP9_COLOR_SPACE_INVALID"; + default: + return std::string("UNKNOWN_StdVideoVP9ColorSpace_value") + std::to_string(value); + } +} +void DumpStdVideoVP9ColorSpace(Printer& p, std::string name, StdVideoVP9ColorSpace value) { + p.PrintKeyString(name, StdVideoVP9ColorSpaceString(value)); +} +std::string VkColorSpaceKHRString(VkColorSpaceKHR value) { + switch (value) { + case (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR): + return "COLOR_SPACE_SRGB_NONLINEAR_KHR"; + case (VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT): + return "COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"; + case (VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT): + return "COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT"; + case (VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT): + return "COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"; + case (VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT): + return "COLOR_SPACE_DCI_P3_NONLINEAR_EXT"; + case (VK_COLOR_SPACE_BT709_LINEAR_EXT): + return "COLOR_SPACE_BT709_LINEAR_EXT"; + case (VK_COLOR_SPACE_BT709_NONLINEAR_EXT): + return "COLOR_SPACE_BT709_NONLINEAR_EXT"; + case (VK_COLOR_SPACE_BT2020_LINEAR_EXT): + return "COLOR_SPACE_BT2020_LINEAR_EXT"; + case (VK_COLOR_SPACE_HDR10_ST2084_EXT): + return "COLOR_SPACE_HDR10_ST2084_EXT"; + case (VK_COLOR_SPACE_DOLBYVISION_EXT): + return "COLOR_SPACE_DOLBYVISION_EXT"; + case (VK_COLOR_SPACE_HDR10_HLG_EXT): + return "COLOR_SPACE_HDR10_HLG_EXT"; + case (VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT): + return "COLOR_SPACE_ADOBERGB_LINEAR_EXT"; + case (VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT): + return "COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"; + case (VK_COLOR_SPACE_PASS_THROUGH_EXT): + return "COLOR_SPACE_PASS_THROUGH_EXT"; + case (VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT): + return "COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT"; + case (VK_COLOR_SPACE_DISPLAY_NATIVE_AMD): + return "COLOR_SPACE_DISPLAY_NATIVE_AMD"; + default: + return std::string("UNKNOWN_VkColorSpaceKHR_value") + std::to_string(value); + } +} +void DumpVkColorSpaceKHR(Printer& p, std::string name, VkColorSpaceKHR value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkColorSpaceKHRString(value)); else p.PrintKeyString(name, VkColorSpaceKHRString(value)); } -std::string VkDriverIdString(VkDriverId value) { +std::string VkComponentSwizzleString(VkComponentSwizzle value) { switch (value) { - case (VK_DRIVER_ID_AMD_PROPRIETARY): return "DRIVER_ID_AMD_PROPRIETARY"; - case (VK_DRIVER_ID_AMD_OPEN_SOURCE): return "DRIVER_ID_AMD_OPEN_SOURCE"; - case (VK_DRIVER_ID_MESA_RADV): return "DRIVER_ID_MESA_RADV"; - case (VK_DRIVER_ID_NVIDIA_PROPRIETARY): return "DRIVER_ID_NVIDIA_PROPRIETARY"; - case (VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS): return "DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"; - case (VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA): return "DRIVER_ID_INTEL_OPEN_SOURCE_MESA"; - case (VK_DRIVER_ID_IMAGINATION_PROPRIETARY): return "DRIVER_ID_IMAGINATION_PROPRIETARY"; - case (VK_DRIVER_ID_QUALCOMM_PROPRIETARY): return "DRIVER_ID_QUALCOMM_PROPRIETARY"; - case (VK_DRIVER_ID_ARM_PROPRIETARY): return "DRIVER_ID_ARM_PROPRIETARY"; - case (VK_DRIVER_ID_GOOGLE_SWIFTSHADER): return "DRIVER_ID_GOOGLE_SWIFTSHADER"; - case (VK_DRIVER_ID_GGP_PROPRIETARY): return "DRIVER_ID_GGP_PROPRIETARY"; - case (VK_DRIVER_ID_BROADCOM_PROPRIETARY): return "DRIVER_ID_BROADCOM_PROPRIETARY"; - case (VK_DRIVER_ID_MESA_LLVMPIPE): return "DRIVER_ID_MESA_LLVMPIPE"; - case (VK_DRIVER_ID_MOLTENVK): return "DRIVER_ID_MOLTENVK"; - case (VK_DRIVER_ID_COREAVI_PROPRIETARY): return "DRIVER_ID_COREAVI_PROPRIETARY"; - case (VK_DRIVER_ID_JUICE_PROPRIETARY): return "DRIVER_ID_JUICE_PROPRIETARY"; - case (VK_DRIVER_ID_VERISILICON_PROPRIETARY): return "DRIVER_ID_VERISILICON_PROPRIETARY"; - case (VK_DRIVER_ID_MESA_TURNIP): return "DRIVER_ID_MESA_TURNIP"; - case (VK_DRIVER_ID_MESA_V3DV): return "DRIVER_ID_MESA_V3DV"; - case (VK_DRIVER_ID_MESA_PANVK): return "DRIVER_ID_MESA_PANVK"; - case (VK_DRIVER_ID_SAMSUNG_PROPRIETARY): return "DRIVER_ID_SAMSUNG_PROPRIETARY"; - case (VK_DRIVER_ID_MESA_VENUS): return "DRIVER_ID_MESA_VENUS"; - case (VK_DRIVER_ID_MESA_DOZEN): return "DRIVER_ID_MESA_DOZEN"; - case (VK_DRIVER_ID_MESA_NVK): return "DRIVER_ID_MESA_NVK"; - case (VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA): return "DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA"; - case (VK_DRIVER_ID_MESA_HONEYKRISP): return "DRIVER_ID_MESA_HONEYKRISP"; - case (VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN): return "DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN"; - default: return std::string("UNKNOWN_VkDriverId_value") + std::to_string(value); + case (VK_COMPONENT_SWIZZLE_IDENTITY): + return "COMPONENT_SWIZZLE_IDENTITY"; + case (VK_COMPONENT_SWIZZLE_ZERO): + return "COMPONENT_SWIZZLE_ZERO"; + case (VK_COMPONENT_SWIZZLE_ONE): + return "COMPONENT_SWIZZLE_ONE"; + case (VK_COMPONENT_SWIZZLE_R): + return "COMPONENT_SWIZZLE_R"; + case (VK_COMPONENT_SWIZZLE_G): + return "COMPONENT_SWIZZLE_G"; + case (VK_COMPONENT_SWIZZLE_B): + return "COMPONENT_SWIZZLE_B"; + case (VK_COMPONENT_SWIZZLE_A): + return "COMPONENT_SWIZZLE_A"; + default: + return std::string("UNKNOWN_VkComponentSwizzle_value") + std::to_string(value); } } -void DumpVkDriverId(Printer &p, std::string name, VkDriverId value) { +void DumpVkComponentSwizzle(Printer& p, std::string name, VkComponentSwizzle value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkComponentSwizzleString(value)); + else + p.PrintKeyString(name, VkComponentSwizzleString(value)); +} +std::string VkComponentTypeKHRString(VkComponentTypeKHR value) { + switch (value) { + case (VK_COMPONENT_TYPE_FLOAT16_KHR): + return "COMPONENT_TYPE_FLOAT16_KHR"; + case (VK_COMPONENT_TYPE_FLOAT32_KHR): + return "COMPONENT_TYPE_FLOAT32_KHR"; + case (VK_COMPONENT_TYPE_FLOAT64_KHR): + return "COMPONENT_TYPE_FLOAT64_KHR"; + case (VK_COMPONENT_TYPE_SINT8_KHR): + return "COMPONENT_TYPE_SINT8_KHR"; + case (VK_COMPONENT_TYPE_SINT16_KHR): + return "COMPONENT_TYPE_SINT16_KHR"; + case (VK_COMPONENT_TYPE_SINT32_KHR): + return "COMPONENT_TYPE_SINT32_KHR"; + case (VK_COMPONENT_TYPE_SINT64_KHR): + return "COMPONENT_TYPE_SINT64_KHR"; + case (VK_COMPONENT_TYPE_UINT8_KHR): + return "COMPONENT_TYPE_UINT8_KHR"; + case (VK_COMPONENT_TYPE_UINT16_KHR): + return "COMPONENT_TYPE_UINT16_KHR"; + case (VK_COMPONENT_TYPE_UINT32_KHR): + return "COMPONENT_TYPE_UINT32_KHR"; + case (VK_COMPONENT_TYPE_UINT64_KHR): + return "COMPONENT_TYPE_UINT64_KHR"; + case (VK_COMPONENT_TYPE_BFLOAT16_KHR): + return "COMPONENT_TYPE_BFLOAT16_KHR"; + case (VK_COMPONENT_TYPE_SINT8_PACKED_NV): + return "COMPONENT_TYPE_SINT8_PACKED_NV"; + case (VK_COMPONENT_TYPE_UINT8_PACKED_NV): + return "COMPONENT_TYPE_UINT8_PACKED_NV"; + case (VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT): + return "COMPONENT_TYPE_FLOAT8_E4M3_EXT"; + case (VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT): + return "COMPONENT_TYPE_FLOAT8_E5M2_EXT"; + default: + return std::string("UNKNOWN_VkComponentTypeKHR_value") + std::to_string(value); + } +} +void DumpVkComponentTypeKHR(Printer& p, std::string name, VkComponentTypeKHR value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkComponentTypeKHRString(value)); + else + p.PrintKeyString(name, VkComponentTypeKHRString(value)); +} +std::string VkDefaultVertexAttributeValueKHRString(VkDefaultVertexAttributeValueKHR value) { + switch (value) { + case (VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR): + return "DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR"; + case (VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR): + return "DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR"; + default: + return std::string("UNKNOWN_VkDefaultVertexAttributeValueKHR_value") + std::to_string(value); + } +} +void DumpVkDefaultVertexAttributeValueKHR(Printer& p, std::string name, VkDefaultVertexAttributeValueKHR value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkDefaultVertexAttributeValueKHRString(value)); + else + p.PrintKeyString(name, VkDefaultVertexAttributeValueKHRString(value)); +} +std::string VkDriverIdString(VkDriverId value) { + switch (value) { + case (VK_DRIVER_ID_AMD_PROPRIETARY): + return "DRIVER_ID_AMD_PROPRIETARY"; + case (VK_DRIVER_ID_AMD_OPEN_SOURCE): + return "DRIVER_ID_AMD_OPEN_SOURCE"; + case (VK_DRIVER_ID_MESA_RADV): + return "DRIVER_ID_MESA_RADV"; + case (VK_DRIVER_ID_NVIDIA_PROPRIETARY): + return "DRIVER_ID_NVIDIA_PROPRIETARY"; + case (VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS): + return "DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"; + case (VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA): + return "DRIVER_ID_INTEL_OPEN_SOURCE_MESA"; + case (VK_DRIVER_ID_IMAGINATION_PROPRIETARY): + return "DRIVER_ID_IMAGINATION_PROPRIETARY"; + case (VK_DRIVER_ID_QUALCOMM_PROPRIETARY): + return "DRIVER_ID_QUALCOMM_PROPRIETARY"; + case (VK_DRIVER_ID_ARM_PROPRIETARY): + return "DRIVER_ID_ARM_PROPRIETARY"; + case (VK_DRIVER_ID_GOOGLE_SWIFTSHADER): + return "DRIVER_ID_GOOGLE_SWIFTSHADER"; + case (VK_DRIVER_ID_GGP_PROPRIETARY): + return "DRIVER_ID_GGP_PROPRIETARY"; + case (VK_DRIVER_ID_BROADCOM_PROPRIETARY): + return "DRIVER_ID_BROADCOM_PROPRIETARY"; + case (VK_DRIVER_ID_MESA_LLVMPIPE): + return "DRIVER_ID_MESA_LLVMPIPE"; + case (VK_DRIVER_ID_MOLTENVK): + return "DRIVER_ID_MOLTENVK"; + case (VK_DRIVER_ID_COREAVI_PROPRIETARY): + return "DRIVER_ID_COREAVI_PROPRIETARY"; + case (VK_DRIVER_ID_JUICE_PROPRIETARY): + return "DRIVER_ID_JUICE_PROPRIETARY"; + case (VK_DRIVER_ID_VERISILICON_PROPRIETARY): + return "DRIVER_ID_VERISILICON_PROPRIETARY"; + case (VK_DRIVER_ID_MESA_TURNIP): + return "DRIVER_ID_MESA_TURNIP"; + case (VK_DRIVER_ID_MESA_V3DV): + return "DRIVER_ID_MESA_V3DV"; + case (VK_DRIVER_ID_MESA_PANVK): + return "DRIVER_ID_MESA_PANVK"; + case (VK_DRIVER_ID_SAMSUNG_PROPRIETARY): + return "DRIVER_ID_SAMSUNG_PROPRIETARY"; + case (VK_DRIVER_ID_MESA_VENUS): + return "DRIVER_ID_MESA_VENUS"; + case (VK_DRIVER_ID_MESA_DOZEN): + return "DRIVER_ID_MESA_DOZEN"; + case (VK_DRIVER_ID_MESA_NVK): + return "DRIVER_ID_MESA_NVK"; + case (VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA): + return "DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA"; + case (VK_DRIVER_ID_MESA_HONEYKRISP): + return "DRIVER_ID_MESA_HONEYKRISP"; + case (VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN): + return "DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN"; + case (VK_DRIVER_ID_MESA_KOSMICKRISP): + return "DRIVER_ID_MESA_KOSMICKRISP"; + default: + return std::string("UNKNOWN_VkDriverId_value") + std::to_string(value); + } +} +void DumpVkDriverId(Printer& p, std::string name, VkDriverId value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkDriverIdString(value)); else @@ -112,260 +1190,607 @@ } std::string VkFormatString(VkFormat value) { switch (value) { - case (VK_FORMAT_UNDEFINED): return "FORMAT_UNDEFINED"; - case (VK_FORMAT_R4G4_UNORM_PACK8): return "FORMAT_R4G4_UNORM_PACK8"; - case (VK_FORMAT_R4G4B4A4_UNORM_PACK16): return "FORMAT_R4G4B4A4_UNORM_PACK16"; - case (VK_FORMAT_B4G4R4A4_UNORM_PACK16): return "FORMAT_B4G4R4A4_UNORM_PACK16"; - case (VK_FORMAT_R5G6B5_UNORM_PACK16): return "FORMAT_R5G6B5_UNORM_PACK16"; - case (VK_FORMAT_B5G6R5_UNORM_PACK16): return "FORMAT_B5G6R5_UNORM_PACK16"; - case (VK_FORMAT_R5G5B5A1_UNORM_PACK16): return "FORMAT_R5G5B5A1_UNORM_PACK16"; - case (VK_FORMAT_B5G5R5A1_UNORM_PACK16): return "FORMAT_B5G5R5A1_UNORM_PACK16"; - case (VK_FORMAT_A1R5G5B5_UNORM_PACK16): return "FORMAT_A1R5G5B5_UNORM_PACK16"; - case (VK_FORMAT_R8_UNORM): return "FORMAT_R8_UNORM"; - case (VK_FORMAT_R8_SNORM): return "FORMAT_R8_SNORM"; - case (VK_FORMAT_R8_USCALED): return "FORMAT_R8_USCALED"; - case (VK_FORMAT_R8_SSCALED): return "FORMAT_R8_SSCALED"; - case (VK_FORMAT_R8_UINT): return "FORMAT_R8_UINT"; - case (VK_FORMAT_R8_SINT): return "FORMAT_R8_SINT"; - case (VK_FORMAT_R8_SRGB): return "FORMAT_R8_SRGB"; - case (VK_FORMAT_R8G8_UNORM): return "FORMAT_R8G8_UNORM"; - case (VK_FORMAT_R8G8_SNORM): return "FORMAT_R8G8_SNORM"; - case (VK_FORMAT_R8G8_USCALED): return "FORMAT_R8G8_USCALED"; - case (VK_FORMAT_R8G8_SSCALED): return "FORMAT_R8G8_SSCALED"; - case (VK_FORMAT_R8G8_UINT): return "FORMAT_R8G8_UINT"; - case (VK_FORMAT_R8G8_SINT): return "FORMAT_R8G8_SINT"; - case (VK_FORMAT_R8G8_SRGB): return "FORMAT_R8G8_SRGB"; - case (VK_FORMAT_R8G8B8_UNORM): return "FORMAT_R8G8B8_UNORM"; - case (VK_FORMAT_R8G8B8_SNORM): return "FORMAT_R8G8B8_SNORM"; - case (VK_FORMAT_R8G8B8_USCALED): return "FORMAT_R8G8B8_USCALED"; - case (VK_FORMAT_R8G8B8_SSCALED): return "FORMAT_R8G8B8_SSCALED"; - case (VK_FORMAT_R8G8B8_UINT): return "FORMAT_R8G8B8_UINT"; - case (VK_FORMAT_R8G8B8_SINT): return "FORMAT_R8G8B8_SINT"; - case (VK_FORMAT_R8G8B8_SRGB): return "FORMAT_R8G8B8_SRGB"; - case (VK_FORMAT_B8G8R8_UNORM): return "FORMAT_B8G8R8_UNORM"; - case (VK_FORMAT_B8G8R8_SNORM): return "FORMAT_B8G8R8_SNORM"; - case (VK_FORMAT_B8G8R8_USCALED): return "FORMAT_B8G8R8_USCALED"; - case (VK_FORMAT_B8G8R8_SSCALED): return "FORMAT_B8G8R8_SSCALED"; - case (VK_FORMAT_B8G8R8_UINT): return "FORMAT_B8G8R8_UINT"; - case (VK_FORMAT_B8G8R8_SINT): return "FORMAT_B8G8R8_SINT"; - case (VK_FORMAT_B8G8R8_SRGB): return "FORMAT_B8G8R8_SRGB"; - case (VK_FORMAT_R8G8B8A8_UNORM): return "FORMAT_R8G8B8A8_UNORM"; - case (VK_FORMAT_R8G8B8A8_SNORM): return "FORMAT_R8G8B8A8_SNORM"; - case (VK_FORMAT_R8G8B8A8_USCALED): return "FORMAT_R8G8B8A8_USCALED"; - case (VK_FORMAT_R8G8B8A8_SSCALED): return "FORMAT_R8G8B8A8_SSCALED"; - case (VK_FORMAT_R8G8B8A8_UINT): return "FORMAT_R8G8B8A8_UINT"; - case (VK_FORMAT_R8G8B8A8_SINT): return "FORMAT_R8G8B8A8_SINT"; - case (VK_FORMAT_R8G8B8A8_SRGB): return "FORMAT_R8G8B8A8_SRGB"; - case (VK_FORMAT_B8G8R8A8_UNORM): return "FORMAT_B8G8R8A8_UNORM"; - case (VK_FORMAT_B8G8R8A8_SNORM): return "FORMAT_B8G8R8A8_SNORM"; - case (VK_FORMAT_B8G8R8A8_USCALED): return "FORMAT_B8G8R8A8_USCALED"; - case (VK_FORMAT_B8G8R8A8_SSCALED): return "FORMAT_B8G8R8A8_SSCALED"; - case (VK_FORMAT_B8G8R8A8_UINT): return "FORMAT_B8G8R8A8_UINT"; - case (VK_FORMAT_B8G8R8A8_SINT): return "FORMAT_B8G8R8A8_SINT"; - case (VK_FORMAT_B8G8R8A8_SRGB): return "FORMAT_B8G8R8A8_SRGB"; - case (VK_FORMAT_A8B8G8R8_UNORM_PACK32): return "FORMAT_A8B8G8R8_UNORM_PACK32"; - case (VK_FORMAT_A8B8G8R8_SNORM_PACK32): return "FORMAT_A8B8G8R8_SNORM_PACK32"; - case (VK_FORMAT_A8B8G8R8_USCALED_PACK32): return "FORMAT_A8B8G8R8_USCALED_PACK32"; - case (VK_FORMAT_A8B8G8R8_SSCALED_PACK32): return "FORMAT_A8B8G8R8_SSCALED_PACK32"; - case (VK_FORMAT_A8B8G8R8_UINT_PACK32): return "FORMAT_A8B8G8R8_UINT_PACK32"; - case (VK_FORMAT_A8B8G8R8_SINT_PACK32): return "FORMAT_A8B8G8R8_SINT_PACK32"; - case (VK_FORMAT_A8B8G8R8_SRGB_PACK32): return "FORMAT_A8B8G8R8_SRGB_PACK32"; - case (VK_FORMAT_A2R10G10B10_UNORM_PACK32): return "FORMAT_A2R10G10B10_UNORM_PACK32"; - case (VK_FORMAT_A2R10G10B10_SNORM_PACK32): return "FORMAT_A2R10G10B10_SNORM_PACK32"; - case (VK_FORMAT_A2R10G10B10_USCALED_PACK32): return "FORMAT_A2R10G10B10_USCALED_PACK32"; - case (VK_FORMAT_A2R10G10B10_SSCALED_PACK32): return "FORMAT_A2R10G10B10_SSCALED_PACK32"; - case (VK_FORMAT_A2R10G10B10_UINT_PACK32): return "FORMAT_A2R10G10B10_UINT_PACK32"; - case (VK_FORMAT_A2R10G10B10_SINT_PACK32): return "FORMAT_A2R10G10B10_SINT_PACK32"; - case (VK_FORMAT_A2B10G10R10_UNORM_PACK32): return "FORMAT_A2B10G10R10_UNORM_PACK32"; - case (VK_FORMAT_A2B10G10R10_SNORM_PACK32): return "FORMAT_A2B10G10R10_SNORM_PACK32"; - case (VK_FORMAT_A2B10G10R10_USCALED_PACK32): return "FORMAT_A2B10G10R10_USCALED_PACK32"; - case (VK_FORMAT_A2B10G10R10_SSCALED_PACK32): return "FORMAT_A2B10G10R10_SSCALED_PACK32"; - case (VK_FORMAT_A2B10G10R10_UINT_PACK32): return "FORMAT_A2B10G10R10_UINT_PACK32"; - case (VK_FORMAT_A2B10G10R10_SINT_PACK32): return "FORMAT_A2B10G10R10_SINT_PACK32"; - case (VK_FORMAT_R16_UNORM): return "FORMAT_R16_UNORM"; - case (VK_FORMAT_R16_SNORM): return "FORMAT_R16_SNORM"; - case (VK_FORMAT_R16_USCALED): return "FORMAT_R16_USCALED"; - case (VK_FORMAT_R16_SSCALED): return "FORMAT_R16_SSCALED"; - case (VK_FORMAT_R16_UINT): return "FORMAT_R16_UINT"; - case (VK_FORMAT_R16_SINT): return "FORMAT_R16_SINT"; - case (VK_FORMAT_R16_SFLOAT): return "FORMAT_R16_SFLOAT"; - case (VK_FORMAT_R16G16_UNORM): return "FORMAT_R16G16_UNORM"; - case (VK_FORMAT_R16G16_SNORM): return "FORMAT_R16G16_SNORM"; - case (VK_FORMAT_R16G16_USCALED): return "FORMAT_R16G16_USCALED"; - case (VK_FORMAT_R16G16_SSCALED): return "FORMAT_R16G16_SSCALED"; - case (VK_FORMAT_R16G16_UINT): return "FORMAT_R16G16_UINT"; - case (VK_FORMAT_R16G16_SINT): return "FORMAT_R16G16_SINT"; - case (VK_FORMAT_R16G16_SFLOAT): return "FORMAT_R16G16_SFLOAT"; - case (VK_FORMAT_R16G16B16_UNORM): return "FORMAT_R16G16B16_UNORM"; - case (VK_FORMAT_R16G16B16_SNORM): return "FORMAT_R16G16B16_SNORM"; - case (VK_FORMAT_R16G16B16_USCALED): return "FORMAT_R16G16B16_USCALED"; - case (VK_FORMAT_R16G16B16_SSCALED): return "FORMAT_R16G16B16_SSCALED"; - case (VK_FORMAT_R16G16B16_UINT): return "FORMAT_R16G16B16_UINT"; - case (VK_FORMAT_R16G16B16_SINT): return "FORMAT_R16G16B16_SINT"; - case (VK_FORMAT_R16G16B16_SFLOAT): return "FORMAT_R16G16B16_SFLOAT"; - case (VK_FORMAT_R16G16B16A16_UNORM): return "FORMAT_R16G16B16A16_UNORM"; - case (VK_FORMAT_R16G16B16A16_SNORM): return "FORMAT_R16G16B16A16_SNORM"; - case (VK_FORMAT_R16G16B16A16_USCALED): return "FORMAT_R16G16B16A16_USCALED"; - case (VK_FORMAT_R16G16B16A16_SSCALED): return "FORMAT_R16G16B16A16_SSCALED"; - case (VK_FORMAT_R16G16B16A16_UINT): return "FORMAT_R16G16B16A16_UINT"; - case (VK_FORMAT_R16G16B16A16_SINT): return "FORMAT_R16G16B16A16_SINT"; - case (VK_FORMAT_R16G16B16A16_SFLOAT): return "FORMAT_R16G16B16A16_SFLOAT"; - case (VK_FORMAT_R32_UINT): return "FORMAT_R32_UINT"; - case (VK_FORMAT_R32_SINT): return "FORMAT_R32_SINT"; - case (VK_FORMAT_R32_SFLOAT): return "FORMAT_R32_SFLOAT"; - case (VK_FORMAT_R32G32_UINT): return "FORMAT_R32G32_UINT"; - case (VK_FORMAT_R32G32_SINT): return "FORMAT_R32G32_SINT"; - case (VK_FORMAT_R32G32_SFLOAT): return "FORMAT_R32G32_SFLOAT"; - case (VK_FORMAT_R32G32B32_UINT): return "FORMAT_R32G32B32_UINT"; - case (VK_FORMAT_R32G32B32_SINT): return "FORMAT_R32G32B32_SINT"; - case (VK_FORMAT_R32G32B32_SFLOAT): return "FORMAT_R32G32B32_SFLOAT"; - case (VK_FORMAT_R32G32B32A32_UINT): return "FORMAT_R32G32B32A32_UINT"; - case (VK_FORMAT_R32G32B32A32_SINT): return "FORMAT_R32G32B32A32_SINT"; - case (VK_FORMAT_R32G32B32A32_SFLOAT): return "FORMAT_R32G32B32A32_SFLOAT"; - case (VK_FORMAT_R64_UINT): return "FORMAT_R64_UINT"; - case (VK_FORMAT_R64_SINT): return "FORMAT_R64_SINT"; - case (VK_FORMAT_R64_SFLOAT): return "FORMAT_R64_SFLOAT"; - case (VK_FORMAT_R64G64_UINT): return "FORMAT_R64G64_UINT"; - case (VK_FORMAT_R64G64_SINT): return "FORMAT_R64G64_SINT"; - case (VK_FORMAT_R64G64_SFLOAT): return "FORMAT_R64G64_SFLOAT"; - case (VK_FORMAT_R64G64B64_UINT): return "FORMAT_R64G64B64_UINT"; - case (VK_FORMAT_R64G64B64_SINT): return "FORMAT_R64G64B64_SINT"; - case (VK_FORMAT_R64G64B64_SFLOAT): return "FORMAT_R64G64B64_SFLOAT"; - case (VK_FORMAT_R64G64B64A64_UINT): return "FORMAT_R64G64B64A64_UINT"; - case (VK_FORMAT_R64G64B64A64_SINT): return "FORMAT_R64G64B64A64_SINT"; - case (VK_FORMAT_R64G64B64A64_SFLOAT): return "FORMAT_R64G64B64A64_SFLOAT"; - case (VK_FORMAT_B10G11R11_UFLOAT_PACK32): return "FORMAT_B10G11R11_UFLOAT_PACK32"; - case (VK_FORMAT_E5B9G9R9_UFLOAT_PACK32): return "FORMAT_E5B9G9R9_UFLOAT_PACK32"; - case (VK_FORMAT_D16_UNORM): return "FORMAT_D16_UNORM"; - case (VK_FORMAT_X8_D24_UNORM_PACK32): return "FORMAT_X8_D24_UNORM_PACK32"; - case (VK_FORMAT_D32_SFLOAT): return "FORMAT_D32_SFLOAT"; - case (VK_FORMAT_S8_UINT): return "FORMAT_S8_UINT"; - case (VK_FORMAT_D16_UNORM_S8_UINT): return "FORMAT_D16_UNORM_S8_UINT"; - case (VK_FORMAT_D24_UNORM_S8_UINT): return "FORMAT_D24_UNORM_S8_UINT"; - case (VK_FORMAT_D32_SFLOAT_S8_UINT): return "FORMAT_D32_SFLOAT_S8_UINT"; - case (VK_FORMAT_BC1_RGB_UNORM_BLOCK): return "FORMAT_BC1_RGB_UNORM_BLOCK"; - case (VK_FORMAT_BC1_RGB_SRGB_BLOCK): return "FORMAT_BC1_RGB_SRGB_BLOCK"; - case (VK_FORMAT_BC1_RGBA_UNORM_BLOCK): return "FORMAT_BC1_RGBA_UNORM_BLOCK"; - case (VK_FORMAT_BC1_RGBA_SRGB_BLOCK): return "FORMAT_BC1_RGBA_SRGB_BLOCK"; - case (VK_FORMAT_BC2_UNORM_BLOCK): return "FORMAT_BC2_UNORM_BLOCK"; - case (VK_FORMAT_BC2_SRGB_BLOCK): return "FORMAT_BC2_SRGB_BLOCK"; - case (VK_FORMAT_BC3_UNORM_BLOCK): return "FORMAT_BC3_UNORM_BLOCK"; - case (VK_FORMAT_BC3_SRGB_BLOCK): return "FORMAT_BC3_SRGB_BLOCK"; - case (VK_FORMAT_BC4_UNORM_BLOCK): return "FORMAT_BC4_UNORM_BLOCK"; - case (VK_FORMAT_BC4_SNORM_BLOCK): return "FORMAT_BC4_SNORM_BLOCK"; - case (VK_FORMAT_BC5_UNORM_BLOCK): return "FORMAT_BC5_UNORM_BLOCK"; - case (VK_FORMAT_BC5_SNORM_BLOCK): return "FORMAT_BC5_SNORM_BLOCK"; - case (VK_FORMAT_BC6H_UFLOAT_BLOCK): return "FORMAT_BC6H_UFLOAT_BLOCK"; - case (VK_FORMAT_BC6H_SFLOAT_BLOCK): return "FORMAT_BC6H_SFLOAT_BLOCK"; - case (VK_FORMAT_BC7_UNORM_BLOCK): return "FORMAT_BC7_UNORM_BLOCK"; - case (VK_FORMAT_BC7_SRGB_BLOCK): return "FORMAT_BC7_SRGB_BLOCK"; - case (VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK): return "FORMAT_ETC2_R8G8B8_UNORM_BLOCK"; - case (VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK): return "FORMAT_ETC2_R8G8B8_SRGB_BLOCK"; - case (VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK): return "FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"; - case (VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK): return "FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"; - case (VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK): return "FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"; - case (VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK): return "FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"; - case (VK_FORMAT_EAC_R11_UNORM_BLOCK): return "FORMAT_EAC_R11_UNORM_BLOCK"; - case (VK_FORMAT_EAC_R11_SNORM_BLOCK): return "FORMAT_EAC_R11_SNORM_BLOCK"; - case (VK_FORMAT_EAC_R11G11_UNORM_BLOCK): return "FORMAT_EAC_R11G11_UNORM_BLOCK"; - case (VK_FORMAT_EAC_R11G11_SNORM_BLOCK): return "FORMAT_EAC_R11G11_SNORM_BLOCK"; - case (VK_FORMAT_ASTC_4x4_UNORM_BLOCK): return "FORMAT_ASTC_4x4_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_4x4_SRGB_BLOCK): return "FORMAT_ASTC_4x4_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_5x4_UNORM_BLOCK): return "FORMAT_ASTC_5x4_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_5x4_SRGB_BLOCK): return "FORMAT_ASTC_5x4_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_5x5_UNORM_BLOCK): return "FORMAT_ASTC_5x5_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_5x5_SRGB_BLOCK): return "FORMAT_ASTC_5x5_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_6x5_UNORM_BLOCK): return "FORMAT_ASTC_6x5_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_6x5_SRGB_BLOCK): return "FORMAT_ASTC_6x5_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_6x6_UNORM_BLOCK): return "FORMAT_ASTC_6x6_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_6x6_SRGB_BLOCK): return "FORMAT_ASTC_6x6_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_8x5_UNORM_BLOCK): return "FORMAT_ASTC_8x5_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_8x5_SRGB_BLOCK): return "FORMAT_ASTC_8x5_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_8x6_UNORM_BLOCK): return "FORMAT_ASTC_8x6_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_8x6_SRGB_BLOCK): return "FORMAT_ASTC_8x6_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_8x8_UNORM_BLOCK): return "FORMAT_ASTC_8x8_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_8x8_SRGB_BLOCK): return "FORMAT_ASTC_8x8_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_10x5_UNORM_BLOCK): return "FORMAT_ASTC_10x5_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_10x5_SRGB_BLOCK): return "FORMAT_ASTC_10x5_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_10x6_UNORM_BLOCK): return "FORMAT_ASTC_10x6_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_10x6_SRGB_BLOCK): return "FORMAT_ASTC_10x6_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_10x8_UNORM_BLOCK): return "FORMAT_ASTC_10x8_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_10x8_SRGB_BLOCK): return "FORMAT_ASTC_10x8_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_10x10_UNORM_BLOCK): return "FORMAT_ASTC_10x10_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_10x10_SRGB_BLOCK): return "FORMAT_ASTC_10x10_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_12x10_UNORM_BLOCK): return "FORMAT_ASTC_12x10_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_12x10_SRGB_BLOCK): return "FORMAT_ASTC_12x10_SRGB_BLOCK"; - case (VK_FORMAT_ASTC_12x12_UNORM_BLOCK): return "FORMAT_ASTC_12x12_UNORM_BLOCK"; - case (VK_FORMAT_ASTC_12x12_SRGB_BLOCK): return "FORMAT_ASTC_12x12_SRGB_BLOCK"; - case (VK_FORMAT_G8B8G8R8_422_UNORM): return "FORMAT_G8B8G8R8_422_UNORM"; - case (VK_FORMAT_B8G8R8G8_422_UNORM): return "FORMAT_B8G8R8G8_422_UNORM"; - case (VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM): return "FORMAT_G8_B8_R8_3PLANE_420_UNORM"; - case (VK_FORMAT_G8_B8R8_2PLANE_420_UNORM): return "FORMAT_G8_B8R8_2PLANE_420_UNORM"; - case (VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM): return "FORMAT_G8_B8_R8_3PLANE_422_UNORM"; - case (VK_FORMAT_G8_B8R8_2PLANE_422_UNORM): return "FORMAT_G8_B8R8_2PLANE_422_UNORM"; - case (VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM): return "FORMAT_G8_B8_R8_3PLANE_444_UNORM"; - case (VK_FORMAT_R10X6_UNORM_PACK16): return "FORMAT_R10X6_UNORM_PACK16"; - case (VK_FORMAT_R10X6G10X6_UNORM_2PACK16): return "FORMAT_R10X6G10X6_UNORM_2PACK16"; - case (VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16): return "FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"; - case (VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16): return "FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"; - case (VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16): return "FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"; - case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"; - case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16): return "FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"; - case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"; - case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16): return "FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"; - case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"; - case (VK_FORMAT_R12X4_UNORM_PACK16): return "FORMAT_R12X4_UNORM_PACK16"; - case (VK_FORMAT_R12X4G12X4_UNORM_2PACK16): return "FORMAT_R12X4G12X4_UNORM_2PACK16"; - case (VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16): return "FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"; - case (VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16): return "FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"; - case (VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16): return "FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"; - case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"; - case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16): return "FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"; - case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"; - case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16): return "FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"; - case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"; - case (VK_FORMAT_G16B16G16R16_422_UNORM): return "FORMAT_G16B16G16R16_422_UNORM"; - case (VK_FORMAT_B16G16R16G16_422_UNORM): return "FORMAT_B16G16R16G16_422_UNORM"; - case (VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM): return "FORMAT_G16_B16_R16_3PLANE_420_UNORM"; - case (VK_FORMAT_G16_B16R16_2PLANE_420_UNORM): return "FORMAT_G16_B16R16_2PLANE_420_UNORM"; - case (VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM): return "FORMAT_G16_B16_R16_3PLANE_422_UNORM"; - case (VK_FORMAT_G16_B16R16_2PLANE_422_UNORM): return "FORMAT_G16_B16R16_2PLANE_422_UNORM"; - case (VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM): return "FORMAT_G16_B16_R16_3PLANE_444_UNORM"; - case (VK_FORMAT_G8_B8R8_2PLANE_444_UNORM): return "FORMAT_G8_B8R8_2PLANE_444_UNORM"; - case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16): return "FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16"; - case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16): return "FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16"; - case (VK_FORMAT_G16_B16R16_2PLANE_444_UNORM): return "FORMAT_G16_B16R16_2PLANE_444_UNORM"; - case (VK_FORMAT_A4R4G4B4_UNORM_PACK16): return "FORMAT_A4R4G4B4_UNORM_PACK16"; - case (VK_FORMAT_A4B4G4R4_UNORM_PACK16): return "FORMAT_A4B4G4R4_UNORM_PACK16"; - case (VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK): return "FORMAT_ASTC_4x4_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK): return "FORMAT_ASTC_5x4_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK): return "FORMAT_ASTC_5x5_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK): return "FORMAT_ASTC_6x5_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK): return "FORMAT_ASTC_6x6_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK): return "FORMAT_ASTC_8x5_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK): return "FORMAT_ASTC_8x6_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK): return "FORMAT_ASTC_8x8_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK): return "FORMAT_ASTC_10x5_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK): return "FORMAT_ASTC_10x6_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK): return "FORMAT_ASTC_10x8_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK): return "FORMAT_ASTC_10x10_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK): return "FORMAT_ASTC_12x10_SFLOAT_BLOCK"; - case (VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK): return "FORMAT_ASTC_12x12_SFLOAT_BLOCK"; - case (VK_FORMAT_A1B5G5R5_UNORM_PACK16): return "FORMAT_A1B5G5R5_UNORM_PACK16"; - case (VK_FORMAT_A8_UNORM): return "FORMAT_A8_UNORM"; - case (VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG): return "FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"; - case (VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG): return "FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"; - case (VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG): return "FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"; - case (VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG): return "FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"; - case (VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG): return "FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"; - case (VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG): return "FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"; - case (VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG): return "FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"; - case (VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG): return "FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"; - case (VK_FORMAT_R16G16_SFIXED5_NV): return "FORMAT_R16G16_SFIXED5_NV"; - default: return std::string("UNKNOWN_VkFormat_value") + std::to_string(value); + case (VK_FORMAT_UNDEFINED): + return "FORMAT_UNDEFINED"; + case (VK_FORMAT_R4G4_UNORM_PACK8): + return "FORMAT_R4G4_UNORM_PACK8"; + case (VK_FORMAT_R4G4B4A4_UNORM_PACK16): + return "FORMAT_R4G4B4A4_UNORM_PACK16"; + case (VK_FORMAT_B4G4R4A4_UNORM_PACK16): + return "FORMAT_B4G4R4A4_UNORM_PACK16"; + case (VK_FORMAT_R5G6B5_UNORM_PACK16): + return "FORMAT_R5G6B5_UNORM_PACK16"; + case (VK_FORMAT_B5G6R5_UNORM_PACK16): + return "FORMAT_B5G6R5_UNORM_PACK16"; + case (VK_FORMAT_R5G5B5A1_UNORM_PACK16): + return "FORMAT_R5G5B5A1_UNORM_PACK16"; + case (VK_FORMAT_B5G5R5A1_UNORM_PACK16): + return "FORMAT_B5G5R5A1_UNORM_PACK16"; + case (VK_FORMAT_A1R5G5B5_UNORM_PACK16): + return "FORMAT_A1R5G5B5_UNORM_PACK16"; + case (VK_FORMAT_R8_UNORM): + return "FORMAT_R8_UNORM"; + case (VK_FORMAT_R8_SNORM): + return "FORMAT_R8_SNORM"; + case (VK_FORMAT_R8_USCALED): + return "FORMAT_R8_USCALED"; + case (VK_FORMAT_R8_SSCALED): + return "FORMAT_R8_SSCALED"; + case (VK_FORMAT_R8_UINT): + return "FORMAT_R8_UINT"; + case (VK_FORMAT_R8_SINT): + return "FORMAT_R8_SINT"; + case (VK_FORMAT_R8_SRGB): + return "FORMAT_R8_SRGB"; + case (VK_FORMAT_R8G8_UNORM): + return "FORMAT_R8G8_UNORM"; + case (VK_FORMAT_R8G8_SNORM): + return "FORMAT_R8G8_SNORM"; + case (VK_FORMAT_R8G8_USCALED): + return "FORMAT_R8G8_USCALED"; + case (VK_FORMAT_R8G8_SSCALED): + return "FORMAT_R8G8_SSCALED"; + case (VK_FORMAT_R8G8_UINT): + return "FORMAT_R8G8_UINT"; + case (VK_FORMAT_R8G8_SINT): + return "FORMAT_R8G8_SINT"; + case (VK_FORMAT_R8G8_SRGB): + return "FORMAT_R8G8_SRGB"; + case (VK_FORMAT_R8G8B8_UNORM): + return "FORMAT_R8G8B8_UNORM"; + case (VK_FORMAT_R8G8B8_SNORM): + return "FORMAT_R8G8B8_SNORM"; + case (VK_FORMAT_R8G8B8_USCALED): + return "FORMAT_R8G8B8_USCALED"; + case (VK_FORMAT_R8G8B8_SSCALED): + return "FORMAT_R8G8B8_SSCALED"; + case (VK_FORMAT_R8G8B8_UINT): + return "FORMAT_R8G8B8_UINT"; + case (VK_FORMAT_R8G8B8_SINT): + return "FORMAT_R8G8B8_SINT"; + case (VK_FORMAT_R8G8B8_SRGB): + return "FORMAT_R8G8B8_SRGB"; + case (VK_FORMAT_B8G8R8_UNORM): + return "FORMAT_B8G8R8_UNORM"; + case (VK_FORMAT_B8G8R8_SNORM): + return "FORMAT_B8G8R8_SNORM"; + case (VK_FORMAT_B8G8R8_USCALED): + return "FORMAT_B8G8R8_USCALED"; + case (VK_FORMAT_B8G8R8_SSCALED): + return "FORMAT_B8G8R8_SSCALED"; + case (VK_FORMAT_B8G8R8_UINT): + return "FORMAT_B8G8R8_UINT"; + case (VK_FORMAT_B8G8R8_SINT): + return "FORMAT_B8G8R8_SINT"; + case (VK_FORMAT_B8G8R8_SRGB): + return "FORMAT_B8G8R8_SRGB"; + case (VK_FORMAT_R8G8B8A8_UNORM): + return "FORMAT_R8G8B8A8_UNORM"; + case (VK_FORMAT_R8G8B8A8_SNORM): + return "FORMAT_R8G8B8A8_SNORM"; + case (VK_FORMAT_R8G8B8A8_USCALED): + return "FORMAT_R8G8B8A8_USCALED"; + case (VK_FORMAT_R8G8B8A8_SSCALED): + return "FORMAT_R8G8B8A8_SSCALED"; + case (VK_FORMAT_R8G8B8A8_UINT): + return "FORMAT_R8G8B8A8_UINT"; + case (VK_FORMAT_R8G8B8A8_SINT): + return "FORMAT_R8G8B8A8_SINT"; + case (VK_FORMAT_R8G8B8A8_SRGB): + return "FORMAT_R8G8B8A8_SRGB"; + case (VK_FORMAT_B8G8R8A8_UNORM): + return "FORMAT_B8G8R8A8_UNORM"; + case (VK_FORMAT_B8G8R8A8_SNORM): + return "FORMAT_B8G8R8A8_SNORM"; + case (VK_FORMAT_B8G8R8A8_USCALED): + return "FORMAT_B8G8R8A8_USCALED"; + case (VK_FORMAT_B8G8R8A8_SSCALED): + return "FORMAT_B8G8R8A8_SSCALED"; + case (VK_FORMAT_B8G8R8A8_UINT): + return "FORMAT_B8G8R8A8_UINT"; + case (VK_FORMAT_B8G8R8A8_SINT): + return "FORMAT_B8G8R8A8_SINT"; + case (VK_FORMAT_B8G8R8A8_SRGB): + return "FORMAT_B8G8R8A8_SRGB"; + case (VK_FORMAT_A8B8G8R8_UNORM_PACK32): + return "FORMAT_A8B8G8R8_UNORM_PACK32"; + case (VK_FORMAT_A8B8G8R8_SNORM_PACK32): + return "FORMAT_A8B8G8R8_SNORM_PACK32"; + case (VK_FORMAT_A8B8G8R8_USCALED_PACK32): + return "FORMAT_A8B8G8R8_USCALED_PACK32"; + case (VK_FORMAT_A8B8G8R8_SSCALED_PACK32): + return "FORMAT_A8B8G8R8_SSCALED_PACK32"; + case (VK_FORMAT_A8B8G8R8_UINT_PACK32): + return "FORMAT_A8B8G8R8_UINT_PACK32"; + case (VK_FORMAT_A8B8G8R8_SINT_PACK32): + return "FORMAT_A8B8G8R8_SINT_PACK32"; + case (VK_FORMAT_A8B8G8R8_SRGB_PACK32): + return "FORMAT_A8B8G8R8_SRGB_PACK32"; + case (VK_FORMAT_A2R10G10B10_UNORM_PACK32): + return "FORMAT_A2R10G10B10_UNORM_PACK32"; + case (VK_FORMAT_A2R10G10B10_SNORM_PACK32): + return "FORMAT_A2R10G10B10_SNORM_PACK32"; + case (VK_FORMAT_A2R10G10B10_USCALED_PACK32): + return "FORMAT_A2R10G10B10_USCALED_PACK32"; + case (VK_FORMAT_A2R10G10B10_SSCALED_PACK32): + return "FORMAT_A2R10G10B10_SSCALED_PACK32"; + case (VK_FORMAT_A2R10G10B10_UINT_PACK32): + return "FORMAT_A2R10G10B10_UINT_PACK32"; + case (VK_FORMAT_A2R10G10B10_SINT_PACK32): + return "FORMAT_A2R10G10B10_SINT_PACK32"; + case (VK_FORMAT_A2B10G10R10_UNORM_PACK32): + return "FORMAT_A2B10G10R10_UNORM_PACK32"; + case (VK_FORMAT_A2B10G10R10_SNORM_PACK32): + return "FORMAT_A2B10G10R10_SNORM_PACK32"; + case (VK_FORMAT_A2B10G10R10_USCALED_PACK32): + return "FORMAT_A2B10G10R10_USCALED_PACK32"; + case (VK_FORMAT_A2B10G10R10_SSCALED_PACK32): + return "FORMAT_A2B10G10R10_SSCALED_PACK32"; + case (VK_FORMAT_A2B10G10R10_UINT_PACK32): + return "FORMAT_A2B10G10R10_UINT_PACK32"; + case (VK_FORMAT_A2B10G10R10_SINT_PACK32): + return "FORMAT_A2B10G10R10_SINT_PACK32"; + case (VK_FORMAT_R16_UNORM): + return "FORMAT_R16_UNORM"; + case (VK_FORMAT_R16_SNORM): + return "FORMAT_R16_SNORM"; + case (VK_FORMAT_R16_USCALED): + return "FORMAT_R16_USCALED"; + case (VK_FORMAT_R16_SSCALED): + return "FORMAT_R16_SSCALED"; + case (VK_FORMAT_R16_UINT): + return "FORMAT_R16_UINT"; + case (VK_FORMAT_R16_SINT): + return "FORMAT_R16_SINT"; + case (VK_FORMAT_R16_SFLOAT): + return "FORMAT_R16_SFLOAT"; + case (VK_FORMAT_R16G16_UNORM): + return "FORMAT_R16G16_UNORM"; + case (VK_FORMAT_R16G16_SNORM): + return "FORMAT_R16G16_SNORM"; + case (VK_FORMAT_R16G16_USCALED): + return "FORMAT_R16G16_USCALED"; + case (VK_FORMAT_R16G16_SSCALED): + return "FORMAT_R16G16_SSCALED"; + case (VK_FORMAT_R16G16_UINT): + return "FORMAT_R16G16_UINT"; + case (VK_FORMAT_R16G16_SINT): + return "FORMAT_R16G16_SINT"; + case (VK_FORMAT_R16G16_SFLOAT): + return "FORMAT_R16G16_SFLOAT"; + case (VK_FORMAT_R16G16B16_UNORM): + return "FORMAT_R16G16B16_UNORM"; + case (VK_FORMAT_R16G16B16_SNORM): + return "FORMAT_R16G16B16_SNORM"; + case (VK_FORMAT_R16G16B16_USCALED): + return "FORMAT_R16G16B16_USCALED"; + case (VK_FORMAT_R16G16B16_SSCALED): + return "FORMAT_R16G16B16_SSCALED"; + case (VK_FORMAT_R16G16B16_UINT): + return "FORMAT_R16G16B16_UINT"; + case (VK_FORMAT_R16G16B16_SINT): + return "FORMAT_R16G16B16_SINT"; + case (VK_FORMAT_R16G16B16_SFLOAT): + return "FORMAT_R16G16B16_SFLOAT"; + case (VK_FORMAT_R16G16B16A16_UNORM): + return "FORMAT_R16G16B16A16_UNORM"; + case (VK_FORMAT_R16G16B16A16_SNORM): + return "FORMAT_R16G16B16A16_SNORM"; + case (VK_FORMAT_R16G16B16A16_USCALED): + return "FORMAT_R16G16B16A16_USCALED"; + case (VK_FORMAT_R16G16B16A16_SSCALED): + return "FORMAT_R16G16B16A16_SSCALED"; + case (VK_FORMAT_R16G16B16A16_UINT): + return "FORMAT_R16G16B16A16_UINT"; + case (VK_FORMAT_R16G16B16A16_SINT): + return "FORMAT_R16G16B16A16_SINT"; + case (VK_FORMAT_R16G16B16A16_SFLOAT): + return "FORMAT_R16G16B16A16_SFLOAT"; + case (VK_FORMAT_R32_UINT): + return "FORMAT_R32_UINT"; + case (VK_FORMAT_R32_SINT): + return "FORMAT_R32_SINT"; + case (VK_FORMAT_R32_SFLOAT): + return "FORMAT_R32_SFLOAT"; + case (VK_FORMAT_R32G32_UINT): + return "FORMAT_R32G32_UINT"; + case (VK_FORMAT_R32G32_SINT): + return "FORMAT_R32G32_SINT"; + case (VK_FORMAT_R32G32_SFLOAT): + return "FORMAT_R32G32_SFLOAT"; + case (VK_FORMAT_R32G32B32_UINT): + return "FORMAT_R32G32B32_UINT"; + case (VK_FORMAT_R32G32B32_SINT): + return "FORMAT_R32G32B32_SINT"; + case (VK_FORMAT_R32G32B32_SFLOAT): + return "FORMAT_R32G32B32_SFLOAT"; + case (VK_FORMAT_R32G32B32A32_UINT): + return "FORMAT_R32G32B32A32_UINT"; + case (VK_FORMAT_R32G32B32A32_SINT): + return "FORMAT_R32G32B32A32_SINT"; + case (VK_FORMAT_R32G32B32A32_SFLOAT): + return "FORMAT_R32G32B32A32_SFLOAT"; + case (VK_FORMAT_R64_UINT): + return "FORMAT_R64_UINT"; + case (VK_FORMAT_R64_SINT): + return "FORMAT_R64_SINT"; + case (VK_FORMAT_R64_SFLOAT): + return "FORMAT_R64_SFLOAT"; + case (VK_FORMAT_R64G64_UINT): + return "FORMAT_R64G64_UINT"; + case (VK_FORMAT_R64G64_SINT): + return "FORMAT_R64G64_SINT"; + case (VK_FORMAT_R64G64_SFLOAT): + return "FORMAT_R64G64_SFLOAT"; + case (VK_FORMAT_R64G64B64_UINT): + return "FORMAT_R64G64B64_UINT"; + case (VK_FORMAT_R64G64B64_SINT): + return "FORMAT_R64G64B64_SINT"; + case (VK_FORMAT_R64G64B64_SFLOAT): + return "FORMAT_R64G64B64_SFLOAT"; + case (VK_FORMAT_R64G64B64A64_UINT): + return "FORMAT_R64G64B64A64_UINT"; + case (VK_FORMAT_R64G64B64A64_SINT): + return "FORMAT_R64G64B64A64_SINT"; + case (VK_FORMAT_R64G64B64A64_SFLOAT): + return "FORMAT_R64G64B64A64_SFLOAT"; + case (VK_FORMAT_B10G11R11_UFLOAT_PACK32): + return "FORMAT_B10G11R11_UFLOAT_PACK32"; + case (VK_FORMAT_E5B9G9R9_UFLOAT_PACK32): + return "FORMAT_E5B9G9R9_UFLOAT_PACK32"; + case (VK_FORMAT_D16_UNORM): + return "FORMAT_D16_UNORM"; + case (VK_FORMAT_X8_D24_UNORM_PACK32): + return "FORMAT_X8_D24_UNORM_PACK32"; + case (VK_FORMAT_D32_SFLOAT): + return "FORMAT_D32_SFLOAT"; + case (VK_FORMAT_S8_UINT): + return "FORMAT_S8_UINT"; + case (VK_FORMAT_D16_UNORM_S8_UINT): + return "FORMAT_D16_UNORM_S8_UINT"; + case (VK_FORMAT_D24_UNORM_S8_UINT): + return "FORMAT_D24_UNORM_S8_UINT"; + case (VK_FORMAT_D32_SFLOAT_S8_UINT): + return "FORMAT_D32_SFLOAT_S8_UINT"; + case (VK_FORMAT_BC1_RGB_UNORM_BLOCK): + return "FORMAT_BC1_RGB_UNORM_BLOCK"; + case (VK_FORMAT_BC1_RGB_SRGB_BLOCK): + return "FORMAT_BC1_RGB_SRGB_BLOCK"; + case (VK_FORMAT_BC1_RGBA_UNORM_BLOCK): + return "FORMAT_BC1_RGBA_UNORM_BLOCK"; + case (VK_FORMAT_BC1_RGBA_SRGB_BLOCK): + return "FORMAT_BC1_RGBA_SRGB_BLOCK"; + case (VK_FORMAT_BC2_UNORM_BLOCK): + return "FORMAT_BC2_UNORM_BLOCK"; + case (VK_FORMAT_BC2_SRGB_BLOCK): + return "FORMAT_BC2_SRGB_BLOCK"; + case (VK_FORMAT_BC3_UNORM_BLOCK): + return "FORMAT_BC3_UNORM_BLOCK"; + case (VK_FORMAT_BC3_SRGB_BLOCK): + return "FORMAT_BC3_SRGB_BLOCK"; + case (VK_FORMAT_BC4_UNORM_BLOCK): + return "FORMAT_BC4_UNORM_BLOCK"; + case (VK_FORMAT_BC4_SNORM_BLOCK): + return "FORMAT_BC4_SNORM_BLOCK"; + case (VK_FORMAT_BC5_UNORM_BLOCK): + return "FORMAT_BC5_UNORM_BLOCK"; + case (VK_FORMAT_BC5_SNORM_BLOCK): + return "FORMAT_BC5_SNORM_BLOCK"; + case (VK_FORMAT_BC6H_UFLOAT_BLOCK): + return "FORMAT_BC6H_UFLOAT_BLOCK"; + case (VK_FORMAT_BC6H_SFLOAT_BLOCK): + return "FORMAT_BC6H_SFLOAT_BLOCK"; + case (VK_FORMAT_BC7_UNORM_BLOCK): + return "FORMAT_BC7_UNORM_BLOCK"; + case (VK_FORMAT_BC7_SRGB_BLOCK): + return "FORMAT_BC7_SRGB_BLOCK"; + case (VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK): + return "FORMAT_ETC2_R8G8B8_UNORM_BLOCK"; + case (VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK): + return "FORMAT_ETC2_R8G8B8_SRGB_BLOCK"; + case (VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK): + return "FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"; + case (VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK): + return "FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"; + case (VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK): + return "FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"; + case (VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK): + return "FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"; + case (VK_FORMAT_EAC_R11_UNORM_BLOCK): + return "FORMAT_EAC_R11_UNORM_BLOCK"; + case (VK_FORMAT_EAC_R11_SNORM_BLOCK): + return "FORMAT_EAC_R11_SNORM_BLOCK"; + case (VK_FORMAT_EAC_R11G11_UNORM_BLOCK): + return "FORMAT_EAC_R11G11_UNORM_BLOCK"; + case (VK_FORMAT_EAC_R11G11_SNORM_BLOCK): + return "FORMAT_EAC_R11G11_SNORM_BLOCK"; + case (VK_FORMAT_ASTC_4x4_UNORM_BLOCK): + return "FORMAT_ASTC_4x4_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_4x4_SRGB_BLOCK): + return "FORMAT_ASTC_4x4_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_5x4_UNORM_BLOCK): + return "FORMAT_ASTC_5x4_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_5x4_SRGB_BLOCK): + return "FORMAT_ASTC_5x4_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_5x5_UNORM_BLOCK): + return "FORMAT_ASTC_5x5_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_5x5_SRGB_BLOCK): + return "FORMAT_ASTC_5x5_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_6x5_UNORM_BLOCK): + return "FORMAT_ASTC_6x5_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_6x5_SRGB_BLOCK): + return "FORMAT_ASTC_6x5_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_6x6_UNORM_BLOCK): + return "FORMAT_ASTC_6x6_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_6x6_SRGB_BLOCK): + return "FORMAT_ASTC_6x6_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_8x5_UNORM_BLOCK): + return "FORMAT_ASTC_8x5_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_8x5_SRGB_BLOCK): + return "FORMAT_ASTC_8x5_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_8x6_UNORM_BLOCK): + return "FORMAT_ASTC_8x6_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_8x6_SRGB_BLOCK): + return "FORMAT_ASTC_8x6_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_8x8_UNORM_BLOCK): + return "FORMAT_ASTC_8x8_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_8x8_SRGB_BLOCK): + return "FORMAT_ASTC_8x8_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_10x5_UNORM_BLOCK): + return "FORMAT_ASTC_10x5_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_10x5_SRGB_BLOCK): + return "FORMAT_ASTC_10x5_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_10x6_UNORM_BLOCK): + return "FORMAT_ASTC_10x6_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_10x6_SRGB_BLOCK): + return "FORMAT_ASTC_10x6_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_10x8_UNORM_BLOCK): + return "FORMAT_ASTC_10x8_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_10x8_SRGB_BLOCK): + return "FORMAT_ASTC_10x8_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_10x10_UNORM_BLOCK): + return "FORMAT_ASTC_10x10_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_10x10_SRGB_BLOCK): + return "FORMAT_ASTC_10x10_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_12x10_UNORM_BLOCK): + return "FORMAT_ASTC_12x10_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_12x10_SRGB_BLOCK): + return "FORMAT_ASTC_12x10_SRGB_BLOCK"; + case (VK_FORMAT_ASTC_12x12_UNORM_BLOCK): + return "FORMAT_ASTC_12x12_UNORM_BLOCK"; + case (VK_FORMAT_ASTC_12x12_SRGB_BLOCK): + return "FORMAT_ASTC_12x12_SRGB_BLOCK"; + case (VK_FORMAT_G8B8G8R8_422_UNORM): + return "FORMAT_G8B8G8R8_422_UNORM"; + case (VK_FORMAT_B8G8R8G8_422_UNORM): + return "FORMAT_B8G8R8G8_422_UNORM"; + case (VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM): + return "FORMAT_G8_B8_R8_3PLANE_420_UNORM"; + case (VK_FORMAT_G8_B8R8_2PLANE_420_UNORM): + return "FORMAT_G8_B8R8_2PLANE_420_UNORM"; + case (VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM): + return "FORMAT_G8_B8_R8_3PLANE_422_UNORM"; + case (VK_FORMAT_G8_B8R8_2PLANE_422_UNORM): + return "FORMAT_G8_B8R8_2PLANE_422_UNORM"; + case (VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM): + return "FORMAT_G8_B8_R8_3PLANE_444_UNORM"; + case (VK_FORMAT_R10X6_UNORM_PACK16): + return "FORMAT_R10X6_UNORM_PACK16"; + case (VK_FORMAT_R10X6G10X6_UNORM_2PACK16): + return "FORMAT_R10X6G10X6_UNORM_2PACK16"; + case (VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16): + return "FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"; + case (VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16): + return "FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"; + case (VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16): + return "FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"; + case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16): + return "FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"; + case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16): + return "FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"; + case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16): + return "FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"; + case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16): + return "FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"; + case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16): + return "FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"; + case (VK_FORMAT_R12X4_UNORM_PACK16): + return "FORMAT_R12X4_UNORM_PACK16"; + case (VK_FORMAT_R12X4G12X4_UNORM_2PACK16): + return "FORMAT_R12X4G12X4_UNORM_2PACK16"; + case (VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16): + return "FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"; + case (VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16): + return "FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"; + case (VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16): + return "FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"; + case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16): + return "FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"; + case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16): + return "FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"; + case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16): + return "FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"; + case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16): + return "FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"; + case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16): + return "FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"; + case (VK_FORMAT_G16B16G16R16_422_UNORM): + return "FORMAT_G16B16G16R16_422_UNORM"; + case (VK_FORMAT_B16G16R16G16_422_UNORM): + return "FORMAT_B16G16R16G16_422_UNORM"; + case (VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM): + return "FORMAT_G16_B16_R16_3PLANE_420_UNORM"; + case (VK_FORMAT_G16_B16R16_2PLANE_420_UNORM): + return "FORMAT_G16_B16R16_2PLANE_420_UNORM"; + case (VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM): + return "FORMAT_G16_B16_R16_3PLANE_422_UNORM"; + case (VK_FORMAT_G16_B16R16_2PLANE_422_UNORM): + return "FORMAT_G16_B16R16_2PLANE_422_UNORM"; + case (VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM): + return "FORMAT_G16_B16_R16_3PLANE_444_UNORM"; + case (VK_FORMAT_G8_B8R8_2PLANE_444_UNORM): + return "FORMAT_G8_B8R8_2PLANE_444_UNORM"; + case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16): + return "FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16"; + case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16): + return "FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16"; + case (VK_FORMAT_G16_B16R16_2PLANE_444_UNORM): + return "FORMAT_G16_B16R16_2PLANE_444_UNORM"; + case (VK_FORMAT_A4R4G4B4_UNORM_PACK16): + return "FORMAT_A4R4G4B4_UNORM_PACK16"; + case (VK_FORMAT_A4B4G4R4_UNORM_PACK16): + return "FORMAT_A4B4G4R4_UNORM_PACK16"; + case (VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK): + return "FORMAT_ASTC_4x4_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK): + return "FORMAT_ASTC_5x4_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK): + return "FORMAT_ASTC_5x5_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK): + return "FORMAT_ASTC_6x5_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK): + return "FORMAT_ASTC_6x6_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK): + return "FORMAT_ASTC_8x5_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK): + return "FORMAT_ASTC_8x6_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK): + return "FORMAT_ASTC_8x8_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK): + return "FORMAT_ASTC_10x5_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK): + return "FORMAT_ASTC_10x6_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK): + return "FORMAT_ASTC_10x8_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK): + return "FORMAT_ASTC_10x10_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK): + return "FORMAT_ASTC_12x10_SFLOAT_BLOCK"; + case (VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK): + return "FORMAT_ASTC_12x12_SFLOAT_BLOCK"; + case (VK_FORMAT_A1B5G5R5_UNORM_PACK16): + return "FORMAT_A1B5G5R5_UNORM_PACK16"; + case (VK_FORMAT_A8_UNORM): + return "FORMAT_A8_UNORM"; + case (VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG): + return "FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"; + case (VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG): + return "FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"; + case (VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG): + return "FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"; + case (VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG): + return "FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"; + case (VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG): + return "FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"; + case (VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG): + return "FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"; + case (VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG): + return "FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"; + case (VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG): + return "FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"; + case (VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT): + return "FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT): + return "FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT"; + case (VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT): + return "FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT"; + case (VK_FORMAT_R8_BOOL_ARM): + return "FORMAT_R8_BOOL_ARM"; + case (VK_FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM): + return "FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM"; + case (VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM): + return "FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM"; + case (VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM): + return "FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM"; + case (VK_FORMAT_R16G16_SFIXED5_NV): + return "FORMAT_R16G16_SFIXED5_NV"; + case (VK_FORMAT_R10X6_UINT_PACK16_ARM): + return "FORMAT_R10X6_UINT_PACK16_ARM"; + case (VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM): + return "FORMAT_R10X6G10X6_UINT_2PACK16_ARM"; + case (VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM): + return "FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM"; + case (VK_FORMAT_R12X4_UINT_PACK16_ARM): + return "FORMAT_R12X4_UINT_PACK16_ARM"; + case (VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM): + return "FORMAT_R12X4G12X4_UINT_2PACK16_ARM"; + case (VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM): + return "FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM"; + case (VK_FORMAT_R14X2_UINT_PACK16_ARM): + return "FORMAT_R14X2_UINT_PACK16_ARM"; + case (VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM): + return "FORMAT_R14X2G14X2_UINT_2PACK16_ARM"; + case (VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM): + return "FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM"; + case (VK_FORMAT_R14X2_UNORM_PACK16_ARM): + return "FORMAT_R14X2_UNORM_PACK16_ARM"; + case (VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM): + return "FORMAT_R14X2G14X2_UNORM_2PACK16_ARM"; + case (VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM): + return "FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM"; + case (VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM): + return "FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM"; + case (VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM): + return "FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM"; + default: + return std::string("UNKNOWN_VkFormat_value") + std::to_string(value); } } -void DumpVkFormat(Printer &p, std::string name, VkFormat value) { +void DumpVkFormat(Printer& p, std::string name, VkFormat value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkFormatString(value)); else @@ -373,40 +1798,75 @@ } std::string VkImageLayoutString(VkImageLayout value) { switch (value) { - case (VK_IMAGE_LAYOUT_UNDEFINED): return "IMAGE_LAYOUT_UNDEFINED"; - case (VK_IMAGE_LAYOUT_GENERAL): return "IMAGE_LAYOUT_GENERAL"; - case (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL): return "IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"; - case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL): return "IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"; - case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL): return "IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"; - case (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL): return "IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"; - case (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL): return "IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"; - case (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL): return "IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"; - case (VK_IMAGE_LAYOUT_PREINITIALIZED): return "IMAGE_LAYOUT_PREINITIALIZED"; - case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL): return "IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"; - case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL): return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"; - case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL): return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"; - case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL): return "IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"; - case (VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL): return "IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"; - case (VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL): return "IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"; - case (VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL): return "IMAGE_LAYOUT_READ_ONLY_OPTIMAL"; - case (VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL): return "IMAGE_LAYOUT_ATTACHMENT_OPTIMAL"; - case (VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ): return "IMAGE_LAYOUT_RENDERING_LOCAL_READ"; - case (VK_IMAGE_LAYOUT_PRESENT_SRC_KHR): return "IMAGE_LAYOUT_PRESENT_SRC_KHR"; - case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR): return "IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR"; - case (VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR): return "IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR"; - case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR): return "IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR"; - case (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR): return "IMAGE_LAYOUT_SHARED_PRESENT_KHR"; - case (VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT): return "IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"; - case (VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR): return "IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"; - case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR): return "IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"; - case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR): return "IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR"; - case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR): return "IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"; - case (VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT): return "IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT"; - case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR): return "IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR"; - default: return std::string("UNKNOWN_VkImageLayout_value") + std::to_string(value); + case (VK_IMAGE_LAYOUT_UNDEFINED): + return "IMAGE_LAYOUT_UNDEFINED"; + case (VK_IMAGE_LAYOUT_GENERAL): + return "IMAGE_LAYOUT_GENERAL"; + case (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL): + return "IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"; + case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL): + return "IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"; + case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL): + return "IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"; + case (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL): + return "IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"; + case (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL): + return "IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"; + case (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL): + return "IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"; + case (VK_IMAGE_LAYOUT_PREINITIALIZED): + return "IMAGE_LAYOUT_PREINITIALIZED"; + case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL): + return "IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"; + case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL): + return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"; + case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL): + return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"; + case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL): + return "IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"; + case (VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL): + return "IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"; + case (VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL): + return "IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"; + case (VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL): + return "IMAGE_LAYOUT_READ_ONLY_OPTIMAL"; + case (VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL): + return "IMAGE_LAYOUT_ATTACHMENT_OPTIMAL"; + case (VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ): + return "IMAGE_LAYOUT_RENDERING_LOCAL_READ"; + case (VK_IMAGE_LAYOUT_PRESENT_SRC_KHR): + return "IMAGE_LAYOUT_PRESENT_SRC_KHR"; + case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR): + return "IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR"; + case (VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR): + return "IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR"; + case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR): + return "IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR"; + case (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR): + return "IMAGE_LAYOUT_SHARED_PRESENT_KHR"; + case (VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT): + return "IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"; + case (VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR): + return "IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"; + case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR): + return "IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"; + case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR): + return "IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR"; + case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR): + return "IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"; + case (VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT): + return "IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT"; + case (VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM): + return "IMAGE_LAYOUT_TENSOR_ALIASING_ARM"; + case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR): + return "IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR"; + case (VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT): + return "IMAGE_LAYOUT_ZERO_INITIALIZED_EXT"; + default: + return std::string("UNKNOWN_VkImageLayout_value") + std::to_string(value); } } -void DumpVkImageLayout(Printer &p, std::string name, VkImageLayout value) { +void DumpVkImageLayout(Printer& p, std::string name, VkImageLayout value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkImageLayoutString(value)); else @@ -414,29 +1874,57 @@ } std::string VkImageTilingString(VkImageTiling value) { switch (value) { - case (VK_IMAGE_TILING_OPTIMAL): return "IMAGE_TILING_OPTIMAL"; - case (VK_IMAGE_TILING_LINEAR): return "IMAGE_TILING_LINEAR"; - case (VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT): return "IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT"; - default: return std::string("UNKNOWN_VkImageTiling_value") + std::to_string(value); + case (VK_IMAGE_TILING_OPTIMAL): + return "IMAGE_TILING_OPTIMAL"; + case (VK_IMAGE_TILING_LINEAR): + return "IMAGE_TILING_LINEAR"; + case (VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT): + return "IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT"; + default: + return std::string("UNKNOWN_VkImageTiling_value") + std::to_string(value); } } -void DumpVkImageTiling(Printer &p, std::string name, VkImageTiling value) { +void DumpVkImageTiling(Printer& p, std::string name, VkImageTiling value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkImageTilingString(value)); else p.PrintKeyString(name, VkImageTilingString(value)); } -std::string VkPhysicalDeviceLayeredApiKHRString(VkPhysicalDeviceLayeredApiKHR value) { +std::string VkImageTypeString(VkImageType value) { switch (value) { - case (VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR): return "PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR"; - case (VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR): return "PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR"; - case (VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR): return "PHYSICAL_DEVICE_LAYERED_API_METAL_KHR"; - case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR): return "PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR"; - case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR): return "PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR"; - default: return std::string("UNKNOWN_VkPhysicalDeviceLayeredApiKHR_value") + std::to_string(value); + case (VK_IMAGE_TYPE_1D): + return "IMAGE_TYPE_1D"; + case (VK_IMAGE_TYPE_2D): + return "IMAGE_TYPE_2D"; + case (VK_IMAGE_TYPE_3D): + return "IMAGE_TYPE_3D"; + default: + return std::string("UNKNOWN_VkImageType_value") + std::to_string(value); } } -void DumpVkPhysicalDeviceLayeredApiKHR(Printer &p, std::string name, VkPhysicalDeviceLayeredApiKHR value) { +void DumpVkImageType(Printer& p, std::string name, VkImageType value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkImageTypeString(value)); + else + p.PrintKeyString(name, VkImageTypeString(value)); +} +std::string VkPhysicalDeviceLayeredApiKHRString(VkPhysicalDeviceLayeredApiKHR value) { + switch (value) { + case (VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR): + return "PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR"; + case (VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR): + return "PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR"; + case (VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR): + return "PHYSICAL_DEVICE_LAYERED_API_METAL_KHR"; + case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR): + return "PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR"; + case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR): + return "PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR"; + default: + return std::string("UNKNOWN_VkPhysicalDeviceLayeredApiKHR_value") + std::to_string(value); + } +} +void DumpVkPhysicalDeviceLayeredApiKHR(Printer& p, std::string name, VkPhysicalDeviceLayeredApiKHR value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkPhysicalDeviceLayeredApiKHRString(value)); else @@ -444,15 +1932,21 @@ } std::string VkPhysicalDeviceTypeString(VkPhysicalDeviceType value) { switch (value) { - case (VK_PHYSICAL_DEVICE_TYPE_OTHER): return "PHYSICAL_DEVICE_TYPE_OTHER"; - case (VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU): return "PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"; - case (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU): return "PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"; - case (VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU): return "PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"; - case (VK_PHYSICAL_DEVICE_TYPE_CPU): return "PHYSICAL_DEVICE_TYPE_CPU"; - default: return std::string("UNKNOWN_VkPhysicalDeviceType_value") + std::to_string(value); + case (VK_PHYSICAL_DEVICE_TYPE_OTHER): + return "PHYSICAL_DEVICE_TYPE_OTHER"; + case (VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU): + return "PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"; + case (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU): + return "PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"; + case (VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU): + return "PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"; + case (VK_PHYSICAL_DEVICE_TYPE_CPU): + return "PHYSICAL_DEVICE_TYPE_CPU"; + default: + return std::string("UNKNOWN_VkPhysicalDeviceType_value") + std::to_string(value); } } -void DumpVkPhysicalDeviceType(Printer &p, std::string name, VkPhysicalDeviceType value) { +void DumpVkPhysicalDeviceType(Printer& p, std::string name, VkPhysicalDeviceType value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkPhysicalDeviceTypeString(value)); else @@ -460,14 +1954,19 @@ } std::string VkPipelineRobustnessBufferBehaviorString(VkPipelineRobustnessBufferBehavior value) { switch (value) { - case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT): return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT"; - case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED): return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED"; - case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS): return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS"; - case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2): return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2"; - default: return std::string("UNKNOWN_VkPipelineRobustnessBufferBehavior_value") + std::to_string(value); + case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT): + return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT"; + case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED): + return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED"; + case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS): + return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS"; + case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2): + return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2"; + default: + return std::string("UNKNOWN_VkPipelineRobustnessBufferBehavior_value") + std::to_string(value); } } -void DumpVkPipelineRobustnessBufferBehavior(Printer &p, std::string name, VkPipelineRobustnessBufferBehavior value) { +void DumpVkPipelineRobustnessBufferBehavior(Printer& p, std::string name, VkPipelineRobustnessBufferBehavior value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkPipelineRobustnessBufferBehaviorString(value)); else @@ -475,14 +1974,19 @@ } std::string VkPipelineRobustnessImageBehaviorString(VkPipelineRobustnessImageBehavior value) { switch (value) { - case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT): return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT"; - case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED): return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED"; - case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS): return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS"; - case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2): return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2"; - default: return std::string("UNKNOWN_VkPipelineRobustnessImageBehavior_value") + std::to_string(value); + case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT): + return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT"; + case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED): + return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED"; + case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS): + return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS"; + case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2): + return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2"; + default: + return std::string("UNKNOWN_VkPipelineRobustnessImageBehavior_value") + std::to_string(value); } } -void DumpVkPipelineRobustnessImageBehavior(Printer &p, std::string name, VkPipelineRobustnessImageBehavior value) { +void DumpVkPipelineRobustnessImageBehavior(Printer& p, std::string name, VkPipelineRobustnessImageBehavior value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkPipelineRobustnessImageBehaviorString(value)); else @@ -490,12 +1994,15 @@ } std::string VkPointClippingBehaviorString(VkPointClippingBehavior value) { switch (value) { - case (VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES): return "POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"; - case (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY): return "POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"; - default: return std::string("UNKNOWN_VkPointClippingBehavior_value") + std::to_string(value); + case (VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES): + return "POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"; + case (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY): + return "POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"; + default: + return std::string("UNKNOWN_VkPointClippingBehavior_value") + std::to_string(value); } } -void DumpVkPointClippingBehavior(Printer &p, std::string name, VkPointClippingBehavior value) { +void DumpVkPointClippingBehavior(Printer& p, std::string name, VkPointClippingBehavior value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkPointClippingBehaviorString(value)); else @@ -503,17 +2010,25 @@ } std::string VkPresentModeKHRString(VkPresentModeKHR value) { switch (value) { - case (VK_PRESENT_MODE_IMMEDIATE_KHR): return "PRESENT_MODE_IMMEDIATE_KHR"; - case (VK_PRESENT_MODE_MAILBOX_KHR): return "PRESENT_MODE_MAILBOX_KHR"; - case (VK_PRESENT_MODE_FIFO_KHR): return "PRESENT_MODE_FIFO_KHR"; - case (VK_PRESENT_MODE_FIFO_RELAXED_KHR): return "PRESENT_MODE_FIFO_RELAXED_KHR"; - case (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR): return "PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR"; - case (VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR): return "PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR"; - case (VK_PRESENT_MODE_FIFO_LATEST_READY_EXT): return "PRESENT_MODE_FIFO_LATEST_READY_EXT"; - default: return std::string("UNKNOWN_VkPresentModeKHR_value") + std::to_string(value); + case (VK_PRESENT_MODE_IMMEDIATE_KHR): + return "PRESENT_MODE_IMMEDIATE_KHR"; + case (VK_PRESENT_MODE_MAILBOX_KHR): + return "PRESENT_MODE_MAILBOX_KHR"; + case (VK_PRESENT_MODE_FIFO_KHR): + return "PRESENT_MODE_FIFO_KHR"; + case (VK_PRESENT_MODE_FIFO_RELAXED_KHR): + return "PRESENT_MODE_FIFO_RELAXED_KHR"; + case (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR): + return "PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR"; + case (VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR): + return "PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR"; + case (VK_PRESENT_MODE_FIFO_LATEST_READY_KHR): + return "PRESENT_MODE_FIFO_LATEST_READY_KHR"; + default: + return std::string("UNKNOWN_VkPresentModeKHR_value") + std::to_string(value); } } -void DumpVkPresentModeKHR(Printer &p, std::string name, VkPresentModeKHR value) { +void DumpVkPresentModeKHR(Printer& p, std::string name, VkPresentModeKHR value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkPresentModeKHRString(value)); else @@ -521,119 +2036,264 @@ } std::string VkQueueGlobalPriorityString(VkQueueGlobalPriority value) { switch (value) { - case (VK_QUEUE_GLOBAL_PRIORITY_LOW): return "QUEUE_GLOBAL_PRIORITY_LOW"; - case (VK_QUEUE_GLOBAL_PRIORITY_MEDIUM): return "QUEUE_GLOBAL_PRIORITY_MEDIUM"; - case (VK_QUEUE_GLOBAL_PRIORITY_HIGH): return "QUEUE_GLOBAL_PRIORITY_HIGH"; - case (VK_QUEUE_GLOBAL_PRIORITY_REALTIME): return "QUEUE_GLOBAL_PRIORITY_REALTIME"; - default: return std::string("UNKNOWN_VkQueueGlobalPriority_value") + std::to_string(value); + case (VK_QUEUE_GLOBAL_PRIORITY_LOW): + return "QUEUE_GLOBAL_PRIORITY_LOW"; + case (VK_QUEUE_GLOBAL_PRIORITY_MEDIUM): + return "QUEUE_GLOBAL_PRIORITY_MEDIUM"; + case (VK_QUEUE_GLOBAL_PRIORITY_HIGH): + return "QUEUE_GLOBAL_PRIORITY_HIGH"; + case (VK_QUEUE_GLOBAL_PRIORITY_REALTIME): + return "QUEUE_GLOBAL_PRIORITY_REALTIME"; + default: + return std::string("UNKNOWN_VkQueueGlobalPriority_value") + std::to_string(value); } } -void DumpVkQueueGlobalPriority(Printer &p, std::string name, VkQueueGlobalPriority value) { +void DumpVkQueueGlobalPriority(Printer& p, std::string name, VkQueueGlobalPriority value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkQueueGlobalPriorityString(value)); else p.PrintKeyString(name, VkQueueGlobalPriorityString(value)); } -std::string VkResultString(VkResult value) { +std::string VkRayTracingInvocationReorderModeEXTString(VkRayTracingInvocationReorderModeEXT value) { switch (value) { - case (VK_SUCCESS): return "SUCCESS"; - case (VK_NOT_READY): return "NOT_READY"; - case (VK_TIMEOUT): return "TIMEOUT"; - case (VK_EVENT_SET): return "EVENT_SET"; - case (VK_EVENT_RESET): return "EVENT_RESET"; - case (VK_INCOMPLETE): return "INCOMPLETE"; - case (VK_ERROR_OUT_OF_HOST_MEMORY): return "ERROR_OUT_OF_HOST_MEMORY"; - case (VK_ERROR_OUT_OF_DEVICE_MEMORY): return "ERROR_OUT_OF_DEVICE_MEMORY"; - case (VK_ERROR_INITIALIZATION_FAILED): return "ERROR_INITIALIZATION_FAILED"; - case (VK_ERROR_DEVICE_LOST): return "ERROR_DEVICE_LOST"; - case (VK_ERROR_MEMORY_MAP_FAILED): return "ERROR_MEMORY_MAP_FAILED"; - case (VK_ERROR_LAYER_NOT_PRESENT): return "ERROR_LAYER_NOT_PRESENT"; - case (VK_ERROR_EXTENSION_NOT_PRESENT): return "ERROR_EXTENSION_NOT_PRESENT"; - case (VK_ERROR_FEATURE_NOT_PRESENT): return "ERROR_FEATURE_NOT_PRESENT"; - case (VK_ERROR_INCOMPATIBLE_DRIVER): return "ERROR_INCOMPATIBLE_DRIVER"; - case (VK_ERROR_TOO_MANY_OBJECTS): return "ERROR_TOO_MANY_OBJECTS"; - case (VK_ERROR_FORMAT_NOT_SUPPORTED): return "ERROR_FORMAT_NOT_SUPPORTED"; - case (VK_ERROR_FRAGMENTED_POOL): return "ERROR_FRAGMENTED_POOL"; - case (VK_ERROR_UNKNOWN): return "ERROR_UNKNOWN"; - case (VK_ERROR_OUT_OF_POOL_MEMORY): return "ERROR_OUT_OF_POOL_MEMORY"; - case (VK_ERROR_INVALID_EXTERNAL_HANDLE): return "ERROR_INVALID_EXTERNAL_HANDLE"; - case (VK_ERROR_FRAGMENTATION): return "ERROR_FRAGMENTATION"; - case (VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS): return "ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"; - case (VK_PIPELINE_COMPILE_REQUIRED): return "PIPELINE_COMPILE_REQUIRED"; - case (VK_ERROR_NOT_PERMITTED): return "ERROR_NOT_PERMITTED"; - case (VK_ERROR_SURFACE_LOST_KHR): return "ERROR_SURFACE_LOST_KHR"; - case (VK_ERROR_NATIVE_WINDOW_IN_USE_KHR): return "ERROR_NATIVE_WINDOW_IN_USE_KHR"; - case (VK_SUBOPTIMAL_KHR): return "SUBOPTIMAL_KHR"; - case (VK_ERROR_OUT_OF_DATE_KHR): return "ERROR_OUT_OF_DATE_KHR"; - case (VK_ERROR_INCOMPATIBLE_DISPLAY_KHR): return "ERROR_INCOMPATIBLE_DISPLAY_KHR"; - case (VK_ERROR_VALIDATION_FAILED_EXT): return "ERROR_VALIDATION_FAILED_EXT"; - case (VK_ERROR_INVALID_SHADER_NV): return "ERROR_INVALID_SHADER_NV"; - case (VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR): return "ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR"; - case (VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR): return "ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR"; - case (VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR): return "ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR"; - case (VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR): return "ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR"; - case (VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR): return "ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR"; - case (VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR): return "ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"; - case (VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT): return "ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"; - case (VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT): return "ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"; - case (VK_THREAD_IDLE_KHR): return "THREAD_IDLE_KHR"; - case (VK_THREAD_DONE_KHR): return "THREAD_DONE_KHR"; - case (VK_OPERATION_DEFERRED_KHR): return "OPERATION_DEFERRED_KHR"; - case (VK_OPERATION_NOT_DEFERRED_KHR): return "OPERATION_NOT_DEFERRED_KHR"; - case (VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR): return "ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR"; - case (VK_ERROR_COMPRESSION_EXHAUSTED_EXT): return "ERROR_COMPRESSION_EXHAUSTED_EXT"; - case (VK_INCOMPATIBLE_SHADER_BINARY_EXT): return "INCOMPATIBLE_SHADER_BINARY_EXT"; - case (VK_PIPELINE_BINARY_MISSING_KHR): return "PIPELINE_BINARY_MISSING_KHR"; - case (VK_ERROR_NOT_ENOUGH_SPACE_KHR): return "ERROR_NOT_ENOUGH_SPACE_KHR"; - default: return std::string("UNKNOWN_VkResult_value") + std::to_string(value); + case (VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT): + return "RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT"; + case (VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT): + return "RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT"; + default: + return std::string("UNKNOWN_VkRayTracingInvocationReorderModeEXT_value") + std::to_string(value); } } -void DumpVkResult(Printer &p, std::string name, VkResult value) { +void DumpVkRayTracingInvocationReorderModeEXT(Printer& p, std::string name, VkRayTracingInvocationReorderModeEXT value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkRayTracingInvocationReorderModeEXTString(value)); + else + p.PrintKeyString(name, VkRayTracingInvocationReorderModeEXTString(value)); +} +std::string VkResultString(VkResult value) { + switch (value) { + case (VK_SUCCESS): + return "SUCCESS"; + case (VK_NOT_READY): + return "NOT_READY"; + case (VK_TIMEOUT): + return "TIMEOUT"; + case (VK_EVENT_SET): + return "EVENT_SET"; + case (VK_EVENT_RESET): + return "EVENT_RESET"; + case (VK_INCOMPLETE): + return "INCOMPLETE"; + case (VK_ERROR_OUT_OF_HOST_MEMORY): + return "ERROR_OUT_OF_HOST_MEMORY"; + case (VK_ERROR_OUT_OF_DEVICE_MEMORY): + return "ERROR_OUT_OF_DEVICE_MEMORY"; + case (VK_ERROR_INITIALIZATION_FAILED): + return "ERROR_INITIALIZATION_FAILED"; + case (VK_ERROR_DEVICE_LOST): + return "ERROR_DEVICE_LOST"; + case (VK_ERROR_MEMORY_MAP_FAILED): + return "ERROR_MEMORY_MAP_FAILED"; + case (VK_ERROR_LAYER_NOT_PRESENT): + return "ERROR_LAYER_NOT_PRESENT"; + case (VK_ERROR_EXTENSION_NOT_PRESENT): + return "ERROR_EXTENSION_NOT_PRESENT"; + case (VK_ERROR_FEATURE_NOT_PRESENT): + return "ERROR_FEATURE_NOT_PRESENT"; + case (VK_ERROR_INCOMPATIBLE_DRIVER): + return "ERROR_INCOMPATIBLE_DRIVER"; + case (VK_ERROR_TOO_MANY_OBJECTS): + return "ERROR_TOO_MANY_OBJECTS"; + case (VK_ERROR_FORMAT_NOT_SUPPORTED): + return "ERROR_FORMAT_NOT_SUPPORTED"; + case (VK_ERROR_FRAGMENTED_POOL): + return "ERROR_FRAGMENTED_POOL"; + case (VK_ERROR_UNKNOWN): + return "ERROR_UNKNOWN"; + case (VK_ERROR_VALIDATION_FAILED): + return "ERROR_VALIDATION_FAILED"; + case (VK_ERROR_OUT_OF_POOL_MEMORY): + return "ERROR_OUT_OF_POOL_MEMORY"; + case (VK_ERROR_INVALID_EXTERNAL_HANDLE): + return "ERROR_INVALID_EXTERNAL_HANDLE"; + case (VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS): + return "ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"; + case (VK_ERROR_FRAGMENTATION): + return "ERROR_FRAGMENTATION"; + case (VK_PIPELINE_COMPILE_REQUIRED): + return "PIPELINE_COMPILE_REQUIRED"; + case (VK_ERROR_NOT_PERMITTED): + return "ERROR_NOT_PERMITTED"; + case (VK_ERROR_SURFACE_LOST_KHR): + return "ERROR_SURFACE_LOST_KHR"; + case (VK_ERROR_NATIVE_WINDOW_IN_USE_KHR): + return "ERROR_NATIVE_WINDOW_IN_USE_KHR"; + case (VK_SUBOPTIMAL_KHR): + return "SUBOPTIMAL_KHR"; + case (VK_ERROR_OUT_OF_DATE_KHR): + return "ERROR_OUT_OF_DATE_KHR"; + case (VK_ERROR_INCOMPATIBLE_DISPLAY_KHR): + return "ERROR_INCOMPATIBLE_DISPLAY_KHR"; + case (VK_ERROR_INVALID_SHADER_NV): + return "ERROR_INVALID_SHADER_NV"; + case (VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR): + return "ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR"; + case (VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR): + return "ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR"; + case (VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR): + return "ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR"; + case (VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR): + return "ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR"; + case (VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR): + return "ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR"; + case (VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR): + return "ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"; + case (VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT): + return "ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"; + case (VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT): + return "ERROR_PRESENT_TIMING_QUEUE_FULL_EXT"; + case (VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT): + return "ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"; + case (VK_THREAD_IDLE_KHR): + return "THREAD_IDLE_KHR"; + case (VK_THREAD_DONE_KHR): + return "THREAD_DONE_KHR"; + case (VK_OPERATION_DEFERRED_KHR): + return "OPERATION_DEFERRED_KHR"; + case (VK_OPERATION_NOT_DEFERRED_KHR): + return "OPERATION_NOT_DEFERRED_KHR"; + case (VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR): + return "ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR"; + case (VK_ERROR_COMPRESSION_EXHAUSTED_EXT): + return "ERROR_COMPRESSION_EXHAUSTED_EXT"; + case (VK_INCOMPATIBLE_SHADER_BINARY_EXT): + return "INCOMPATIBLE_SHADER_BINARY_EXT"; + case (VK_PIPELINE_BINARY_MISSING_KHR): + return "PIPELINE_BINARY_MISSING_KHR"; + case (VK_ERROR_NOT_ENOUGH_SPACE_KHR): + return "ERROR_NOT_ENOUGH_SPACE_KHR"; + default: + return std::string("UNKNOWN_VkResult_value") + std::to_string(value); + } +} +void DumpVkResult(Printer& p, std::string name, VkResult value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkResultString(value)); else p.PrintKeyString(name, VkResultString(value)); } -std::string VkShaderFloatControlsIndependenceString(VkShaderFloatControlsIndependence value) { +std::string VkScopeKHRString(VkScopeKHR value) { switch (value) { - case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"; - case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"; - case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"; - default: return std::string("UNKNOWN_VkShaderFloatControlsIndependence_value") + std::to_string(value); + case (VK_SCOPE_DEVICE_KHR): + return "SCOPE_DEVICE_KHR"; + case (VK_SCOPE_WORKGROUP_KHR): + return "SCOPE_WORKGROUP_KHR"; + case (VK_SCOPE_SUBGROUP_KHR): + return "SCOPE_SUBGROUP_KHR"; + case (VK_SCOPE_QUEUE_FAMILY_KHR): + return "SCOPE_QUEUE_FAMILY_KHR"; + default: + return std::string("UNKNOWN_VkScopeKHR_value") + std::to_string(value); } } -void DumpVkShaderFloatControlsIndependence(Printer &p, std::string name, VkShaderFloatControlsIndependence value) { +void DumpVkScopeKHR(Printer& p, std::string name, VkScopeKHR value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkScopeKHRString(value)); + else + p.PrintKeyString(name, VkScopeKHRString(value)); +} +std::string VkShaderFloatControlsIndependenceString(VkShaderFloatControlsIndependence value) { + switch (value) { + case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY): + return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"; + case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL): + return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"; + case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE): + return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"; + default: + return std::string("UNKNOWN_VkShaderFloatControlsIndependence_value") + std::to_string(value); + } +} +void DumpVkShaderFloatControlsIndependence(Printer& p, std::string name, VkShaderFloatControlsIndependence value) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + VkShaderFloatControlsIndependenceString(value)); else p.PrintKeyString(name, VkShaderFloatControlsIndependenceString(value)); } -std::vector<const char *> VkCompositeAlphaFlagBitsKHRGetStrings(VkCompositeAlphaFlagBitsKHR value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::string VkTimeDomainKHRString(VkTimeDomainKHR value) { + switch (value) { + case (VK_TIME_DOMAIN_DEVICE_KHR): + return "TIME_DOMAIN_DEVICE_KHR"; + case (VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR): + return "TIME_DOMAIN_CLOCK_MONOTONIC_KHR"; + case (VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR): + return "TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR"; + case (VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR): + return "TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR"; + case (VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT): + return "TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT"; + case (VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT): + return "TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT"; + default: + return std::string("UNKNOWN_VkTimeDomainKHR_value") + std::to_string(value); + } +} +void DumpVkTimeDomainKHR(Printer& p, std::string name, VkTimeDomainKHR value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkTimeDomainKHRString(value)); + else + p.PrintKeyString(name, VkTimeDomainKHRString(value)); +} +std::string VkVideoEncodeTuningModeKHRString(VkVideoEncodeTuningModeKHR value) { + switch (value) { + case (VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR): + return "VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR"; + case (VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR): + return "VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR"; + case (VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR): + return "VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR"; + case (VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR): + return "VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR"; + case (VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR): + return "VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR"; + default: + return std::string("UNKNOWN_VkVideoEncodeTuningModeKHR_value") + std::to_string(value); + } +} +void DumpVkVideoEncodeTuningModeKHR(Printer& p, std::string name, VkVideoEncodeTuningModeKHR value) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + VkVideoEncodeTuningModeKHRString(value)); + else + p.PrintKeyString(name, VkVideoEncodeTuningModeKHRString(value)); +} +std::vector<const char*> VkCompositeAlphaFlagBitsKHRGetStrings(VkCompositeAlphaFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_OPAQUE_BIT_KHR"); if (VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"); if (VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"); if (VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_INHERIT_BIT_KHR"); return strings; } -void DumpVkCompositeAlphaFlagsKHR(Printer &p, std::string name, VkCompositeAlphaFlagsKHR value) { +void DumpVkCompositeAlphaFlagsKHR(Printer& p, std::string name, VkCompositeAlphaFlagsKHR value) { if (static_cast<VkCompositeAlphaFlagBitsKHR>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(static_cast<VkCompositeAlphaFlagBitsKHR>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkCompositeAlphaFlagBitsKHR(Printer &p, std::string name, VkCompositeAlphaFlagBitsKHR value) { +void DumpVkCompositeAlphaFlagBitsKHR(Printer& p, std::string name, VkCompositeAlphaFlagBitsKHR value) { auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -643,32 +2303,35 @@ } } -std::vector<const char *> VkDeviceGroupPresentModeFlagBitsKHRGetStrings(VkDeviceGroupPresentModeFlagBitsKHR value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkDeviceGroupPresentModeFlagBitsKHRGetStrings(VkDeviceGroupPresentModeFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR"); if (VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR"); if (VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR"); - if (VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"); + if (VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR & value) + strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"); return strings; } -void DumpVkDeviceGroupPresentModeFlagsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagsKHR value) { +void DumpVkDeviceGroupPresentModeFlagsKHR(Printer& p, std::string name, VkDeviceGroupPresentModeFlagsKHR value) { if (static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkDeviceGroupPresentModeFlagBitsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagBitsKHR value) { +void DumpVkDeviceGroupPresentModeFlagBitsKHR(Printer& p, std::string name, VkDeviceGroupPresentModeFlagBitsKHR value) { auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -678,59 +2341,109 @@ } } -std::vector<const char *> VkFormatFeatureFlagBitsGetStrings(VkFormatFeatureFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_BIT"); - if (VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_BIT"); - if (VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"); - if (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"); - if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"); - if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"); - if (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_VERTEX_BUFFER_BIT"); - if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"); - if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"); - if (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"); - if (VK_FORMAT_FEATURE_BLIT_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_SRC_BIT"); - if (VK_FORMAT_FEATURE_BLIT_DST_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_DST_BIT"); - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"); - if (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_SRC_BIT"); - if (VK_FORMAT_FEATURE_TRANSFER_DST_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_DST_BIT"); - if (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"); - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"); - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"); - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"); - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"); - if (VK_FORMAT_FEATURE_DISJOINT_BIT & value) strings.push_back("FORMAT_FEATURE_DISJOINT_BIT"); - if (VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"); - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"); - if (VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"); - if (VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"); - if (VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"); - if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"); - if (VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"); - if (VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"); - if (VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"); - if (VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"); +std::vector<const char*> VkDisplayPlaneAlphaFlagBitsKHRGetStrings(VkDisplayPlaneAlphaFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"); + if (VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"); + if (VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"); + if (VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR & value) + strings.push_back("DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"); return strings; } -void DumpVkFormatFeatureFlags(Printer &p, std::string name, VkFormatFeatureFlags value) { - if (static_cast<VkFormatFeatureFlagBits>(value) == 0) { +void DumpVkDisplayPlaneAlphaFlagsKHR(Printer& p, std::string name, VkDisplayPlaneAlphaFlagsKHR value) { + if (static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } - auto strings = VkFormatFeatureFlagBitsGetStrings(static_cast<VkFormatFeatureFlagBits>(value)); + auto strings = VkDisplayPlaneAlphaFlagBitsKHRGetStrings(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkFormatFeatureFlagBits(Printer &p, std::string name, VkFormatFeatureFlagBits value) { +void DumpVkDisplayPlaneAlphaFlagBitsKHR(Printer& p, std::string name, VkDisplayPlaneAlphaFlagBitsKHR value) { + auto strings = VkDisplayPlaneAlphaFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkFormatFeatureFlagBitsGetStrings(VkFormatFeatureFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_BIT"); + if (VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_BIT"); + if (VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"); + if (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"); + if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"); + if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value) + strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"); + if (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_VERTEX_BUFFER_BIT"); + if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"); + if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"); + if (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"); + if (VK_FORMAT_FEATURE_BLIT_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_SRC_BIT"); + if (VK_FORMAT_FEATURE_BLIT_DST_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_DST_BIT"); + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value) + strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"); + if (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_SRC_BIT"); + if (VK_FORMAT_FEATURE_TRANSFER_DST_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_DST_BIT"); + if (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"); + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value) + strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"); + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value) + strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"); + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value) + strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"); + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value) + strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"); + if (VK_FORMAT_FEATURE_DISJOINT_BIT & value) strings.push_back("FORMAT_FEATURE_DISJOINT_BIT"); + if (VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"); + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value) + strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"); + if (VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"); + if (VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"); + if (VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"); + if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT & value) + strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"); + if (VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"); + if (VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"); + if (VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"); + if (VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"); + return strings; +} +void DumpVkFormatFeatureFlags(Printer& p, std::string name, VkFormatFeatureFlags value) { + if (static_cast<VkFormatFeatureFlagBits>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkFormatFeatureFlagBitsGetStrings(static_cast<VkFormatFeatureFlagBits>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkFormatFeatureFlagBits(Printer& p, std::string name, VkFormatFeatureFlagBits value) { auto strings = VkFormatFeatureFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -740,73 +2453,116 @@ } } -std::vector<const char *> VkFormatFeatureFlagBits2GetStrings(VkFormatFeatureFlagBits2 value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkFormatFeatureFlagBits2GetStrings(VkFormatFeatureFlagBits2 value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT"); if (VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_IMAGE_BIT"); if (VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT"); if (VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT"); if (VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT"); - if (VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"); + if (VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value) + strings.push_back("FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"); if (VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_VERTEX_BUFFER_BIT"); if (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT"); if (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT & value) strings.push_back("FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT"); - if (VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT"); + if (VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT & value) + strings.push_back("FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT"); if (VK_FORMAT_FEATURE_2_BLIT_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_2_BLIT_SRC_BIT"); if (VK_FORMAT_FEATURE_2_BLIT_DST_BIT & value) strings.push_back("FORMAT_FEATURE_2_BLIT_DST_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT"); if (VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_2_TRANSFER_SRC_BIT"); if (VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT & value) strings.push_back("FORMAT_FEATURE_2_TRANSFER_DST_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT"); if (VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"); if (VK_FORMAT_FEATURE_2_DISJOINT_BIT & value) strings.push_back("FORMAT_FEATURE_2_DISJOINT_BIT"); if (VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT"); - if (VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT"); - if (VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT"); - if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT"); + if (VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT & value) + strings.push_back("FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT"); + if (VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT & value) + strings.push_back("FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT"); + if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT & value) + strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT"); if (VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT"); if (VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"); if (VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"); - if (VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"); - if (VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"); - if (VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT & value) + strings.push_back("FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"); + if (VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"); if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"); if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"); - if (VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV"); + if (VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV & value) + strings.push_back("FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV"); + if (VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV & value) + strings.push_back("FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV"); if (VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM"); - if (VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM"); + if (VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM & value) + strings.push_back("FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM"); if (VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM"); if (VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM"); + if (VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM & value) strings.push_back("FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM"); + if (VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM & value) + strings.push_back("FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM"); if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV"); if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV"); if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV"); - if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"); - if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM & value) strings.push_back("FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM"); + if (VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR & value) + strings.push_back("FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR"); + if (VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM & value) + strings.push_back("FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM"); + if (VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM & value) + strings.push_back("FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM"); + if (VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM & value) + strings.push_back("FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM"); return strings; } -void DumpVkFormatFeatureFlags2(Printer &p, std::string name, VkFormatFeatureFlags2 value) { +void DumpVkFormatFeatureFlags2(Printer& p, std::string name, VkFormatFeatureFlags2 value) { if (static_cast<VkFormatFeatureFlagBits2>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkFormatFeatureFlagBits2GetStrings(static_cast<VkFormatFeatureFlagBits2>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkFormatFeatureFlagBits2(Printer &p, std::string name, VkFormatFeatureFlagBits2 value) { +void DumpVkFormatFeatureFlagBits2(Printer& p, std::string name, VkFormatFeatureFlagBits2 value) { auto strings = VkFormatFeatureFlagBits2GetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -816,9 +2572,72 @@ } } -std::vector<const char *> VkImageUsageFlagBitsGetStrings(VkImageUsageFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkImageCreateFlagBitsGetStrings(VkImageCreateFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_IMAGE_CREATE_SPARSE_BINDING_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_BINDING_BIT"); + if (VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_RESIDENCY_BIT"); + if (VK_IMAGE_CREATE_SPARSE_ALIASED_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_ALIASED_BIT"); + if (VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT & value) strings.push_back("IMAGE_CREATE_MUTABLE_FORMAT_BIT"); + if (VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_CUBE_COMPATIBLE_BIT"); + if (VK_IMAGE_CREATE_ALIAS_BIT & value) strings.push_back("IMAGE_CREATE_ALIAS_BIT"); + if (VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT & value) strings.push_back("IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"); + if (VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"); + if (VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"); + if (VK_IMAGE_CREATE_EXTENDED_USAGE_BIT & value) strings.push_back("IMAGE_CREATE_EXTENDED_USAGE_BIT"); + if (VK_IMAGE_CREATE_PROTECTED_BIT & value) strings.push_back("IMAGE_CREATE_PROTECTED_BIT"); + if (VK_IMAGE_CREATE_DISJOINT_BIT & value) strings.push_back("IMAGE_CREATE_DISJOINT_BIT"); + if (VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV & value) strings.push_back("IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"); + if (VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT & value) + strings.push_back("IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT"); + if (VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT & value) + strings.push_back("IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"); + if (VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT & value) strings.push_back("IMAGE_CREATE_SUBSAMPLED_BIT_EXT"); + if (VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT & value) + strings.push_back("IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT"); + if (VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT & value) strings.push_back("IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT"); + if (VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR & value) + strings.push_back("IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"); + if (VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT & value) + strings.push_back("IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT"); + if (VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR & value) + strings.push_back("IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR"); + return strings; +} +void DumpVkImageCreateFlags(Printer& p, std::string name, VkImageCreateFlags value) { + if (static_cast<VkImageCreateFlagBits>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkImageCreateFlagBitsGetStrings(static_cast<VkImageCreateFlagBits>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkImageCreateFlagBits(Printer& p, std::string name, VkImageCreateFlagBits value) { + auto strings = VkImageCreateFlagBitsGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkImageUsageFlagBitsGetStrings(VkImageUsageFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_IMAGE_USAGE_TRANSFER_SRC_BIT & value) strings.push_back("IMAGE_USAGE_TRANSFER_SRC_BIT"); if (VK_IMAGE_USAGE_TRANSFER_DST_BIT & value) strings.push_back("IMAGE_USAGE_TRANSFER_DST_BIT"); if (VK_IMAGE_USAGE_SAMPLED_BIT & value) strings.push_back("IMAGE_USAGE_SAMPLED_BIT"); @@ -832,7 +2651,8 @@ if (VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"); if (VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"); if (VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"); - if (VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value) strings.push_back("IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"); + if (VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value) + strings.push_back("IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"); if (VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"); if (VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"); if (VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"); @@ -840,27 +2660,30 @@ if (VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI & value) strings.push_back("IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"); if (VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM"); if (VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM"); - if (VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"); - if (VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"); + if (VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM & value) strings.push_back("IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM"); + if (VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_TILE_MEMORY_BIT_QCOM"); + if (VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value) + strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"); + if (VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value) + strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"); return strings; } -void DumpVkImageUsageFlags(Printer &p, std::string name, VkImageUsageFlags value) { +void DumpVkImageUsageFlags(Printer& p, std::string name, VkImageUsageFlags value) { if (static_cast<VkImageUsageFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkImageUsageFlagBitsGetStrings(static_cast<VkImageUsageFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkImageUsageFlagBits(Printer &p, std::string name, VkImageUsageFlagBits value) { +void DumpVkImageUsageFlagBits(Printer& p, std::string name, VkImageUsageFlagBits value) { auto strings = VkImageUsageFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -870,30 +2693,34 @@ } } -std::vector<const char *> VkIndirectCommandsInputModeFlagBitsEXTGetStrings(VkIndirectCommandsInputModeFlagBitsEXT value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } - if (VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT & value) strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"); - if (VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT & value) strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"); +std::vector<const char*> VkIndirectCommandsInputModeFlagBitsEXTGetStrings(VkIndirectCommandsInputModeFlagBitsEXT value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT & value) + strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"); + if (VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT & value) + strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"); return strings; } -void DumpVkIndirectCommandsInputModeFlagsEXT(Printer &p, std::string name, VkIndirectCommandsInputModeFlagsEXT value) { +void DumpVkIndirectCommandsInputModeFlagsEXT(Printer& p, std::string name, VkIndirectCommandsInputModeFlagsEXT value) { if (static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkIndirectCommandsInputModeFlagBitsEXTGetStrings(static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkIndirectCommandsInputModeFlagBitsEXT(Printer &p, std::string name, VkIndirectCommandsInputModeFlagBitsEXT value) { +void DumpVkIndirectCommandsInputModeFlagBitsEXT(Printer& p, std::string name, VkIndirectCommandsInputModeFlagBitsEXT value) { auto strings = VkIndirectCommandsInputModeFlagBitsEXTGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -903,30 +2730,68 @@ } } -std::vector<const char *> VkMemoryHeapFlagBitsGetStrings(VkMemoryHeapFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } - if (VK_MEMORY_HEAP_DEVICE_LOCAL_BIT & value) strings.push_back("MEMORY_HEAP_DEVICE_LOCAL_BIT"); - if (VK_MEMORY_HEAP_MULTI_INSTANCE_BIT & value) strings.push_back("MEMORY_HEAP_MULTI_INSTANCE_BIT"); +std::vector<const char*> VkMemoryDecompressionMethodFlagBitsEXTGetStrings(VkMemoryDecompressionMethodFlagBitsEXT value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT & value) + strings.push_back("MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT"); return strings; } -void DumpVkMemoryHeapFlags(Printer &p, std::string name, VkMemoryHeapFlags value) { - if (static_cast<VkMemoryHeapFlagBits>(value) == 0) { +void DumpVkMemoryDecompressionMethodFlagsEXT(Printer& p, std::string name, VkMemoryDecompressionMethodFlagsEXT value) { + if (static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } - auto strings = VkMemoryHeapFlagBitsGetStrings(static_cast<VkMemoryHeapFlagBits>(value)); + auto strings = VkMemoryDecompressionMethodFlagBitsEXTGetStrings(static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkMemoryHeapFlagBits(Printer &p, std::string name, VkMemoryHeapFlagBits value) { +void DumpVkMemoryDecompressionMethodFlagBitsEXT(Printer& p, std::string name, VkMemoryDecompressionMethodFlagBitsEXT value) { + auto strings = VkMemoryDecompressionMethodFlagBitsEXTGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkMemoryHeapFlagBitsGetStrings(VkMemoryHeapFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_MEMORY_HEAP_DEVICE_LOCAL_BIT & value) strings.push_back("MEMORY_HEAP_DEVICE_LOCAL_BIT"); + if (VK_MEMORY_HEAP_MULTI_INSTANCE_BIT & value) strings.push_back("MEMORY_HEAP_MULTI_INSTANCE_BIT"); + if (VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM & value) strings.push_back("MEMORY_HEAP_TILE_MEMORY_BIT_QCOM"); + return strings; +} +void DumpVkMemoryHeapFlags(Printer& p, std::string name, VkMemoryHeapFlags value) { + if (static_cast<VkMemoryHeapFlagBits>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkMemoryHeapFlagBitsGetStrings(static_cast<VkMemoryHeapFlagBits>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkMemoryHeapFlagBits(Printer& p, std::string name, VkMemoryHeapFlagBits value) { auto strings = VkMemoryHeapFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -936,9 +2801,12 @@ } } -std::vector<const char *> VkMemoryPropertyFlagBitsGetStrings(VkMemoryPropertyFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkMemoryPropertyFlagBitsGetStrings(VkMemoryPropertyFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT & value) strings.push_back("MEMORY_PROPERTY_DEVICE_LOCAL_BIT"); if (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_VISIBLE_BIT"); if (VK_MEMORY_PROPERTY_HOST_COHERENT_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_COHERENT_BIT"); @@ -950,23 +2818,22 @@ if (VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV & value) strings.push_back("MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"); return strings; } -void DumpVkMemoryPropertyFlags(Printer &p, std::string name, VkMemoryPropertyFlags value) { +void DumpVkMemoryPropertyFlags(Printer& p, std::string name, VkMemoryPropertyFlags value) { if (static_cast<VkMemoryPropertyFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkMemoryPropertyFlagBitsGetStrings(static_cast<VkMemoryPropertyFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkMemoryPropertyFlagBits(Printer &p, std::string name, VkMemoryPropertyFlagBits value) { +void DumpVkMemoryPropertyFlagBits(Printer& p, std::string name, VkMemoryPropertyFlagBits value) { auto strings = VkMemoryPropertyFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -976,32 +2843,34 @@ } } -std::vector<const char *> VkPresentGravityFlagBitsEXTGetStrings(VkPresentGravityFlagBitsEXT value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } - if (VK_PRESENT_GRAVITY_MIN_BIT_EXT & value) strings.push_back("PRESENT_GRAVITY_MIN_BIT_EXT"); - if (VK_PRESENT_GRAVITY_MAX_BIT_EXT & value) strings.push_back("PRESENT_GRAVITY_MAX_BIT_EXT"); - if (VK_PRESENT_GRAVITY_CENTERED_BIT_EXT & value) strings.push_back("PRESENT_GRAVITY_CENTERED_BIT_EXT"); +std::vector<const char*> VkPresentGravityFlagBitsKHRGetStrings(VkPresentGravityFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_PRESENT_GRAVITY_MIN_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_MIN_BIT_KHR"); + if (VK_PRESENT_GRAVITY_MAX_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_MAX_BIT_KHR"); + if (VK_PRESENT_GRAVITY_CENTERED_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_CENTERED_BIT_KHR"); return strings; } -void DumpVkPresentGravityFlagsEXT(Printer &p, std::string name, VkPresentGravityFlagsEXT value) { - if (static_cast<VkPresentGravityFlagBitsEXT>(value) == 0) { +void DumpVkPresentGravityFlagsKHR(Printer& p, std::string name, VkPresentGravityFlagsKHR value) { + if (static_cast<VkPresentGravityFlagBitsKHR>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } - auto strings = VkPresentGravityFlagBitsEXTGetStrings(static_cast<VkPresentGravityFlagBitsEXT>(value)); + auto strings = VkPresentGravityFlagBitsKHRGetStrings(static_cast<VkPresentGravityFlagBitsKHR>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkPresentGravityFlagBitsEXT(Printer &p, std::string name, VkPresentGravityFlagBitsEXT value) { - auto strings = VkPresentGravityFlagBitsEXTGetStrings(value); +void DumpVkPresentGravityFlagBitsKHR(Printer& p, std::string name, VkPresentGravityFlagBitsKHR value) { + auto strings = VkPresentGravityFlagBitsKHRGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + strings.at(0)); @@ -1010,32 +2879,34 @@ } } -std::vector<const char *> VkPresentScalingFlagBitsEXTGetStrings(VkPresentScalingFlagBitsEXT value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } - if (VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT & value) strings.push_back("PRESENT_SCALING_ONE_TO_ONE_BIT_EXT"); - if (VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT & value) strings.push_back("PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT"); - if (VK_PRESENT_SCALING_STRETCH_BIT_EXT & value) strings.push_back("PRESENT_SCALING_STRETCH_BIT_EXT"); +std::vector<const char*> VkPresentScalingFlagBitsKHRGetStrings(VkPresentScalingFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR & value) strings.push_back("PRESENT_SCALING_ONE_TO_ONE_BIT_KHR"); + if (VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR & value) strings.push_back("PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR"); + if (VK_PRESENT_SCALING_STRETCH_BIT_KHR & value) strings.push_back("PRESENT_SCALING_STRETCH_BIT_KHR"); return strings; } -void DumpVkPresentScalingFlagsEXT(Printer &p, std::string name, VkPresentScalingFlagsEXT value) { - if (static_cast<VkPresentScalingFlagBitsEXT>(value) == 0) { +void DumpVkPresentScalingFlagsKHR(Printer& p, std::string name, VkPresentScalingFlagsKHR value) { + if (static_cast<VkPresentScalingFlagBitsKHR>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } - auto strings = VkPresentScalingFlagBitsEXTGetStrings(static_cast<VkPresentScalingFlagBitsEXT>(value)); + auto strings = VkPresentScalingFlagBitsKHRGetStrings(static_cast<VkPresentScalingFlagBitsKHR>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkPresentScalingFlagBitsEXT(Printer &p, std::string name, VkPresentScalingFlagBitsEXT value) { - auto strings = VkPresentScalingFlagBitsEXTGetStrings(value); +void DumpVkPresentScalingFlagBitsKHR(Printer& p, std::string name, VkPresentScalingFlagBitsKHR value) { + auto strings = VkPresentScalingFlagBitsKHRGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) p.PrintKeyString(name, std::string("VK_") + strings.at(0)); @@ -1044,9 +2915,50 @@ } } -std::vector<const char *> VkQueueFlagBitsGetStrings(VkQueueFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkPresentStageFlagBitsEXTGetStrings(VkPresentStageFlagBitsEXT value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT & value) strings.push_back("PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT"); + if (VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT & value) strings.push_back("PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT"); + if (VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT & value) strings.push_back("PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT"); + if (VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT & value) + strings.push_back("PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT"); + return strings; +} +void DumpVkPresentStageFlagsEXT(Printer& p, std::string name, VkPresentStageFlagsEXT value) { + if (static_cast<VkPresentStageFlagBitsEXT>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkPresentStageFlagBitsEXTGetStrings(static_cast<VkPresentStageFlagBitsEXT>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkPresentStageFlagBitsEXT(Printer& p, std::string name, VkPresentStageFlagBitsEXT value) { + auto strings = VkPresentStageFlagBitsEXTGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkQueueFlagBitsGetStrings(VkQueueFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_QUEUE_GRAPHICS_BIT & value) strings.push_back("QUEUE_GRAPHICS_BIT"); if (VK_QUEUE_COMPUTE_BIT & value) strings.push_back("QUEUE_COMPUTE_BIT"); if (VK_QUEUE_TRANSFER_BIT & value) strings.push_back("QUEUE_TRANSFER_BIT"); @@ -1055,25 +2967,25 @@ if (VK_QUEUE_VIDEO_DECODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_DECODE_BIT_KHR"); if (VK_QUEUE_VIDEO_ENCODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_ENCODE_BIT_KHR"); if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) strings.push_back("QUEUE_OPTICAL_FLOW_BIT_NV"); + if (VK_QUEUE_DATA_GRAPH_BIT_ARM & value) strings.push_back("QUEUE_DATA_GRAPH_BIT_ARM"); return strings; } -void DumpVkQueueFlags(Printer &p, std::string name, VkQueueFlags value) { +void DumpVkQueueFlags(Printer& p, std::string name, VkQueueFlags value) { if (static_cast<VkQueueFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkQueueFlagBitsGetStrings(static_cast<VkQueueFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkQueueFlagBits(Printer &p, std::string name, VkQueueFlagBits value) { +void DumpVkQueueFlagBits(Printer& p, std::string name, VkQueueFlagBits value) { auto strings = VkQueueFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1087,66 +2999,110 @@ std::string out; bool is_first = true; if (VK_QUEUE_GRAPHICS_BIT & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_GRAPHICS_BIT"; } if (VK_QUEUE_COMPUTE_BIT & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_COMPUTE_BIT"; } if (VK_QUEUE_TRANSFER_BIT & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_TRANSFER_BIT"; } if (VK_QUEUE_SPARSE_BINDING_BIT & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_SPARSE_BINDING_BIT"; } if (VK_QUEUE_PROTECTED_BIT & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_PROTECTED_BIT"; } if (VK_QUEUE_VIDEO_DECODE_BIT_KHR & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_VIDEO_DECODE_BIT_KHR"; } if (VK_QUEUE_VIDEO_ENCODE_BIT_KHR & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_VIDEO_ENCODE_BIT_KHR"; } if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) { - if (is_first) { is_first = false; } else { out += " | "; } + if (is_first) { + is_first = false; + } else { + out += " | "; + } out += "QUEUE_OPTICAL_FLOW_BIT_NV"; } + if (VK_QUEUE_DATA_GRAPH_BIT_ARM & value) { + if (is_first) { + is_first = false; + } else { + out += " | "; + } + out += "QUEUE_DATA_GRAPH_BIT_ARM"; + } return out; } -std::vector<const char *> VkResolveModeFlagBitsGetStrings(VkResolveModeFlagBits value) { - std::vector<const char *> strings; - if (VK_RESOLVE_MODE_NONE & value) strings.push_back("RESOLVE_MODE_NONE"); +std::vector<const char*> VkResolveModeFlagBitsGetStrings(VkResolveModeFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("RESOLVE_MODE_NONE"); + return strings; + } if (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT & value) strings.push_back("RESOLVE_MODE_SAMPLE_ZERO_BIT"); if (VK_RESOLVE_MODE_AVERAGE_BIT & value) strings.push_back("RESOLVE_MODE_AVERAGE_BIT"); if (VK_RESOLVE_MODE_MIN_BIT & value) strings.push_back("RESOLVE_MODE_MIN_BIT"); if (VK_RESOLVE_MODE_MAX_BIT & value) strings.push_back("RESOLVE_MODE_MAX_BIT"); - if (VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID & value) strings.push_back("RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID"); + if (VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID & value) + strings.push_back("RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID"); + if (VK_RESOLVE_MODE_CUSTOM_BIT_EXT & value) strings.push_back("RESOLVE_MODE_CUSTOM_BIT_EXT"); return strings; } -void DumpVkResolveModeFlags(Printer &p, std::string name, VkResolveModeFlags value) { +void DumpVkResolveModeFlags(Printer& p, std::string name, VkResolveModeFlags value) { if (static_cast<VkResolveModeFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkResolveModeFlagBitsGetStrings(static_cast<VkResolveModeFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkResolveModeFlagBits(Printer &p, std::string name, VkResolveModeFlagBits value) { +void DumpVkResolveModeFlagBits(Printer& p, std::string name, VkResolveModeFlagBits value) { auto strings = VkResolveModeFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1156,9 +3112,12 @@ } } -std::vector<const char *> VkSampleCountFlagBitsGetStrings(VkSampleCountFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkSampleCountFlagBitsGetStrings(VkSampleCountFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_SAMPLE_COUNT_1_BIT & value) strings.push_back("SAMPLE_COUNT_1_BIT"); if (VK_SAMPLE_COUNT_2_BIT & value) strings.push_back("SAMPLE_COUNT_2_BIT"); if (VK_SAMPLE_COUNT_4_BIT & value) strings.push_back("SAMPLE_COUNT_4_BIT"); @@ -1168,23 +3127,22 @@ if (VK_SAMPLE_COUNT_64_BIT & value) strings.push_back("SAMPLE_COUNT_64_BIT"); return strings; } -void DumpVkSampleCountFlags(Printer &p, std::string name, VkSampleCountFlags value) { +void DumpVkSampleCountFlags(Printer& p, std::string name, VkSampleCountFlags value) { if (static_cast<VkSampleCountFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkSampleCountFlagBitsGetStrings(static_cast<VkSampleCountFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkSampleCountFlagBits(Printer &p, std::string name, VkSampleCountFlagBits value) { +void DumpVkSampleCountFlagBits(Printer& p, std::string name, VkSampleCountFlagBits value) { auto strings = VkSampleCountFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1194,9 +3152,12 @@ } } -std::vector<const char *> VkShaderStageFlagBitsGetStrings(VkShaderStageFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkShaderStageFlagBitsGetStrings(VkShaderStageFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_SHADER_STAGE_VERTEX_BIT & value) strings.push_back("SHADER_STAGE_VERTEX_BIT"); if (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT & value) strings.push_back("SHADER_STAGE_TESSELLATION_CONTROL_BIT"); if (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT & value) strings.push_back("SHADER_STAGE_TESSELLATION_EVALUATION_BIT"); @@ -1215,23 +3176,22 @@ if (VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI & value) strings.push_back("SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI"); return strings; } -void DumpVkShaderStageFlags(Printer &p, std::string name, VkShaderStageFlags value) { +void DumpVkShaderStageFlags(Printer& p, std::string name, VkShaderStageFlags value) { if (static_cast<VkShaderStageFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkShaderStageFlagBitsGetStrings(static_cast<VkShaderStageFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkShaderStageFlagBits(Printer &p, std::string name, VkShaderStageFlagBits value) { +void DumpVkShaderStageFlagBits(Printer& p, std::string name, VkShaderStageFlagBits value) { auto strings = VkShaderStageFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1241,9 +3201,12 @@ } } -std::vector<const char *> VkSubgroupFeatureFlagBitsGetStrings(VkSubgroupFeatureFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkSubgroupFeatureFlagBitsGetStrings(VkSubgroupFeatureFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_SUBGROUP_FEATURE_BASIC_BIT & value) strings.push_back("SUBGROUP_FEATURE_BASIC_BIT"); if (VK_SUBGROUP_FEATURE_VOTE_BIT & value) strings.push_back("SUBGROUP_FEATURE_VOTE_BIT"); if (VK_SUBGROUP_FEATURE_ARITHMETIC_BIT & value) strings.push_back("SUBGROUP_FEATURE_ARITHMETIC_BIT"); @@ -1254,26 +3217,25 @@ if (VK_SUBGROUP_FEATURE_QUAD_BIT & value) strings.push_back("SUBGROUP_FEATURE_QUAD_BIT"); if (VK_SUBGROUP_FEATURE_ROTATE_BIT & value) strings.push_back("SUBGROUP_FEATURE_ROTATE_BIT"); if (VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT & value) strings.push_back("SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT"); - if (VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV & value) strings.push_back("SUBGROUP_FEATURE_PARTITIONED_BIT_NV"); + if (VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT & value) strings.push_back("SUBGROUP_FEATURE_PARTITIONED_BIT_EXT"); return strings; } -void DumpVkSubgroupFeatureFlags(Printer &p, std::string name, VkSubgroupFeatureFlags value) { +void DumpVkSubgroupFeatureFlags(Printer& p, std::string name, VkSubgroupFeatureFlags value) { if (static_cast<VkSubgroupFeatureFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkSubgroupFeatureFlagBitsGetStrings(static_cast<VkSubgroupFeatureFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkSubgroupFeatureFlagBits(Printer &p, std::string name, VkSubgroupFeatureFlagBits value) { +void DumpVkSubgroupFeatureFlagBits(Printer& p, std::string name, VkSubgroupFeatureFlagBits value) { auto strings = VkSubgroupFeatureFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1283,29 +3245,31 @@ } } -std::vector<const char *> VkSurfaceCounterFlagBitsEXTGetStrings(VkSurfaceCounterFlagBitsEXT value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkSurfaceCounterFlagBitsEXTGetStrings(VkSurfaceCounterFlagBitsEXT value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_SURFACE_COUNTER_VBLANK_BIT_EXT & value) strings.push_back("SURFACE_COUNTER_VBLANK_BIT_EXT"); return strings; } -void DumpVkSurfaceCounterFlagsEXT(Printer &p, std::string name, VkSurfaceCounterFlagsEXT value) { +void DumpVkSurfaceCounterFlagsEXT(Printer& p, std::string name, VkSurfaceCounterFlagsEXT value) { if (static_cast<VkSurfaceCounterFlagBitsEXT>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(static_cast<VkSurfaceCounterFlagBitsEXT>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkSurfaceCounterFlagBitsEXT(Printer &p, std::string name, VkSurfaceCounterFlagBitsEXT value) { +void DumpVkSurfaceCounterFlagBitsEXT(Printer& p, std::string name, VkSurfaceCounterFlagBitsEXT value) { auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1315,37 +3279,42 @@ } } -std::vector<const char *> VkSurfaceTransformFlagBitsKHRGetStrings(VkSurfaceTransformFlagBitsKHR value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkSurfaceTransformFlagBitsKHRGetStrings(VkSurfaceTransformFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_IDENTITY_BIT_KHR"); if (VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"); if (VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"); if (VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"); if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"); - if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"); - if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"); - if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"); + if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR & value) + strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"); + if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR & value) + strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"); + if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR & value) + strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"); if (VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_INHERIT_BIT_KHR"); return strings; } -void DumpVkSurfaceTransformFlagsKHR(Printer &p, std::string name, VkSurfaceTransformFlagsKHR value) { +void DumpVkSurfaceTransformFlagsKHR(Printer& p, std::string name, VkSurfaceTransformFlagsKHR value) { if (static_cast<VkSurfaceTransformFlagBitsKHR>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(static_cast<VkSurfaceTransformFlagBitsKHR>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkSurfaceTransformFlagBitsKHR(Printer &p, std::string name, VkSurfaceTransformFlagBitsKHR value) { +void DumpVkSurfaceTransformFlagBitsKHR(Printer& p, std::string name, VkSurfaceTransformFlagBitsKHR value) { auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1355,9 +3324,12 @@ } } -std::vector<const char *> VkToolPurposeFlagBitsGetStrings(VkToolPurposeFlagBits value) { - std::vector<const char *> strings; - if (value == 0) { strings.push_back("None"); return strings; } +std::vector<const char*> VkToolPurposeFlagBitsGetStrings(VkToolPurposeFlagBits value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } if (VK_TOOL_PURPOSE_VALIDATION_BIT & value) strings.push_back("TOOL_PURPOSE_VALIDATION_BIT"); if (VK_TOOL_PURPOSE_PROFILING_BIT & value) strings.push_back("TOOL_PURPOSE_PROFILING_BIT"); if (VK_TOOL_PURPOSE_TRACING_BIT & value) strings.push_back("TOOL_PURPOSE_TRACING_BIT"); @@ -1367,23 +3339,22 @@ if (VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT & value) strings.push_back("TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT"); return strings; } -void DumpVkToolPurposeFlags(Printer &p, std::string name, VkToolPurposeFlags value) { +void DumpVkToolPurposeFlags(Printer& p, std::string name, VkToolPurposeFlags value) { if (static_cast<VkToolPurposeFlagBits>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } auto strings = VkToolPurposeFlagBitsGetStrings(static_cast<VkToolPurposeFlagBits>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkToolPurposeFlagBits(Printer &p, std::string name, VkToolPurposeFlagBits value) { +void DumpVkToolPurposeFlagBits(Printer& p, std::string name, VkToolPurposeFlagBits value) { auto strings = VkToolPurposeFlagBitsGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1393,34 +3364,110 @@ } } -std::vector<const char *> VkVideoCodecOperationFlagBitsKHRGetStrings(VkVideoCodecOperationFlagBitsKHR value) { - std::vector<const char *> strings; - if (VK_VIDEO_CODEC_OPERATION_NONE_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_NONE_KHR"); - if (VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR"); - if (VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR"); - if (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR"); - if (VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR"); - if (VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR"); - if (VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR"); +std::vector<const char*> VkVideoCapabilityFlagBitsKHRGetStrings(VkVideoCapabilityFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR & value) strings.push_back("VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR"); + if (VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR & value) + strings.push_back("VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR"); return strings; } -void DumpVkVideoCodecOperationFlagsKHR(Printer &p, std::string name, VkVideoCodecOperationFlagsKHR value) { - if (static_cast<VkVideoCodecOperationFlagBitsKHR>(value) == 0) { +void DumpVkVideoCapabilityFlagsKHR(Printer& p, std::string name, VkVideoCapabilityFlagsKHR value) { + if (static_cast<VkVideoCapabilityFlagBitsKHR>(value) == 0) { ArrayWrapper arr(p, name, 0); - if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) - p.SetAsType().PrintString("None"); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); return; } - auto strings = VkVideoCodecOperationFlagBitsKHRGetStrings(static_cast<VkVideoCodecOperationFlagBitsKHR>(value)); + auto strings = VkVideoCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoCapabilityFlagBitsKHR>(value)); ArrayWrapper arr(p, name, strings.size()); - for(auto& str : strings){ + for (auto& str : strings) { if (p.Type() == OutputType::json) p.SetAsType().PrintString(std::string("VK_") + str); else p.SetAsType().PrintString(str); } } -void DumpVkVideoCodecOperationFlagBitsKHR(Printer &p, std::string name, VkVideoCodecOperationFlagBitsKHR value) { +void DumpVkVideoCapabilityFlagBitsKHR(Printer& p, std::string name, VkVideoCapabilityFlagBitsKHR value) { + auto strings = VkVideoCapabilityFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoChromaSubsamplingFlagBitsKHRGetStrings(VkVideoChromaSubsamplingFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR"); + return strings; + } + if (VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR"); + if (VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR"); + if (VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR"); + if (VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR"); + return strings; +} +void DumpVkVideoChromaSubsamplingFlagsKHR(Printer& p, std::string name, VkVideoChromaSubsamplingFlagsKHR value) { + if (static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoChromaSubsamplingFlagBitsKHRGetStrings(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoChromaSubsamplingFlagBitsKHR(Printer& p, std::string name, VkVideoChromaSubsamplingFlagBitsKHR value) { + auto strings = VkVideoChromaSubsamplingFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoCodecOperationFlagBitsKHRGetStrings(VkVideoCodecOperationFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_CODEC_OPERATION_NONE_KHR"); + return strings; + } + if (VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR"); + if (VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR"); + if (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR"); + if (VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR"); + if (VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR"); + if (VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR"); + if (VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR"); + return strings; +} +void DumpVkVideoCodecOperationFlagsKHR(Printer& p, std::string name, VkVideoCodecOperationFlagsKHR value) { + if (static_cast<VkVideoCodecOperationFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoCodecOperationFlagBitsKHRGetStrings(static_cast<VkVideoCodecOperationFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoCodecOperationFlagBitsKHR(Printer& p, std::string name, VkVideoCodecOperationFlagBitsKHR value) { auto strings = VkVideoCodecOperationFlagBitsKHRGetStrings(value); if (strings.size() > 0) { if (p.Type() == OutputType::json) @@ -1430,7 +3477,1522 @@ } } -void DumpVkConformanceVersion(Printer &p, std::string name, const VkConformanceVersion &obj) { +std::vector<const char*> VkVideoComponentBitDepthFlagBitsKHRGetStrings(VkVideoComponentBitDepthFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR"); + return strings; + } + if (VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR"); + if (VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR"); + if (VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR"); + return strings; +} +void DumpVkVideoComponentBitDepthFlagsKHR(Printer& p, std::string name, VkVideoComponentBitDepthFlagsKHR value) { + if (static_cast<VkVideoComponentBitDepthFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoComponentBitDepthFlagBitsKHRGetStrings(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoComponentBitDepthFlagBitsKHR(Printer& p, std::string name, VkVideoComponentBitDepthFlagBitsKHR value) { + auto strings = VkVideoComponentBitDepthFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoDecodeCapabilityFlagBitsKHRGetStrings(VkVideoDecodeCapabilityFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR & value) + strings.push_back("VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR"); + if (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR & value) + strings.push_back("VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR"); + return strings; +} +void DumpVkVideoDecodeCapabilityFlagsKHR(Printer& p, std::string name, VkVideoDecodeCapabilityFlagsKHR value) { + if (static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoDecodeCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoDecodeCapabilityFlagBitsKHR(Printer& p, std::string name, VkVideoDecodeCapabilityFlagBitsKHR value) { + auto strings = VkVideoDecodeCapabilityFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(VkVideoDecodeH264PictureLayoutFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR"); + return strings; + } + if (VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR & value) + strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR"); + if (VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR & value) + strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR"); + return strings; +} +void DumpVkVideoDecodeH264PictureLayoutFlagsKHR(Printer& p, std::string name, VkVideoDecodeH264PictureLayoutFlagsKHR value) { + if (static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = + VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoDecodeH264PictureLayoutFlagBitsKHR(Printer& p, std::string name, VkVideoDecodeH264PictureLayoutFlagBitsKHR value) { + auto strings = VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoDecodeUsageFlagBitsKHRGetStrings(VkVideoDecodeUsageFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_DECODE_USAGE_DEFAULT_KHR"); + return strings; + } + if (VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR"); + if (VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR"); + if (VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_STREAMING_BIT_KHR"); + return strings; +} +void DumpVkVideoDecodeUsageFlagsKHR(Printer& p, std::string name, VkVideoDecodeUsageFlagsKHR value) { + if (static_cast<VkVideoDecodeUsageFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoDecodeUsageFlagBitsKHRGetStrings(static_cast<VkVideoDecodeUsageFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoDecodeUsageFlagBitsKHR(Printer& p, std::string name, VkVideoDecodeUsageFlagBitsKHR value) { + auto strings = VkVideoDecodeUsageFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(VkVideoEncodeAV1CapabilityFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeAV1CapabilityFlagsKHR(Printer& p, std::string name, VkVideoEncodeAV1CapabilityFlagsKHR value) { + if (static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeAV1CapabilityFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeAV1CapabilityFlagBitsKHR value) { + auto strings = VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeAV1StdFlagBitsKHRGetStrings(VkVideoEncodeAV1StdFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeAV1StdFlagsKHR(Printer& p, std::string name, VkVideoEncodeAV1StdFlagsKHR value) { + if (static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeAV1StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeAV1StdFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeAV1StdFlagBitsKHR value) { + auto strings = VkVideoEncodeAV1StdFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(VkVideoEncodeAV1SuperblockSizeFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR"); + if (VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(Printer& p, std::string name, VkVideoEncodeAV1SuperblockSizeFlagsKHR value) { + if (static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = + VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeAV1SuperblockSizeFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeAV1SuperblockSizeFlagBitsKHR value) { + auto strings = VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeCapabilityFlagBitsKHRGetStrings(VkVideoEncodeCapabilityFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR"); + if (VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR"); + if (VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR"); + if (VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeCapabilityFlagsKHR(Printer& p, std::string name, VkVideoEncodeCapabilityFlagsKHR value) { + if (static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeCapabilityFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeCapabilityFlagBitsKHR value) { + auto strings = VkVideoEncodeCapabilityFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeContentFlagBitsKHRGetStrings(VkVideoEncodeContentFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_ENCODE_CONTENT_DEFAULT_KHR"); + return strings; + } + if (VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR"); + if (VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR"); + if (VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeContentFlagsKHR(Printer& p, std::string name, VkVideoEncodeContentFlagsKHR value) { + if (static_cast<VkVideoEncodeContentFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeContentFlagBitsKHRGetStrings(static_cast<VkVideoEncodeContentFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeContentFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeContentFlagBitsKHR value) { + auto strings = VkVideoEncodeContentFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeFeedbackFlagBitsKHRGetStrings(VkVideoEncodeFeedbackFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR"); + if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeFeedbackFlagsKHR(Printer& p, std::string name, VkVideoEncodeFeedbackFlagsKHR value) { + if (static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeFeedbackFlagBitsKHRGetStrings(static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeFeedbackFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeFeedbackFlagBitsKHR value) { + auto strings = VkVideoEncodeFeedbackFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(VkVideoEncodeH264CapabilityFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeH264CapabilityFlagsKHR(Printer& p, std::string name, VkVideoEncodeH264CapabilityFlagsKHR value) { + if (static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeH264CapabilityFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeH264CapabilityFlagBitsKHR value) { + auto strings = VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeH264StdFlagBitsKHRGetStrings(VkVideoEncodeH264StdFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR"); + if (VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeH264StdFlagsKHR(Printer& p, std::string name, VkVideoEncodeH264StdFlagsKHR value) { + if (static_cast<VkVideoEncodeH264StdFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeH264StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH264StdFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeH264StdFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeH264StdFlagBitsKHR value) { + auto strings = VkVideoEncodeH264StdFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(VkVideoEncodeH265CapabilityFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeH265CapabilityFlagsKHR(Printer& p, std::string name, VkVideoEncodeH265CapabilityFlagsKHR value) { + if (static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeH265CapabilityFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeH265CapabilityFlagBitsKHR value) { + auto strings = VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(VkVideoEncodeH265CtbSizeFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeH265CtbSizeFlagsKHR(Printer& p, std::string name, VkVideoEncodeH265CtbSizeFlagsKHR value) { + if (static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeH265CtbSizeFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeH265CtbSizeFlagBitsKHR value) { + auto strings = VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeH265StdFlagBitsKHRGetStrings(VkVideoEncodeH265StdFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeH265StdFlagsKHR(Printer& p, std::string name, VkVideoEncodeH265StdFlagsKHR value) { + if (static_cast<VkVideoEncodeH265StdFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeH265StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265StdFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeH265StdFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeH265StdFlagBitsKHR value) { + auto strings = VkVideoEncodeH265StdFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings( + VkVideoEncodeH265TransformBlockSizeFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR"); + if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeH265TransformBlockSizeFlagsKHR(Printer& p, std::string name, + VkVideoEncodeH265TransformBlockSizeFlagsKHR value) { + if (static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings( + static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeH265TransformBlockSizeFlagBitsKHR(Printer& p, std::string name, + VkVideoEncodeH265TransformBlockSizeFlagBitsKHR value) { + auto strings = VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(VkVideoEncodeIntraRefreshModeFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR"); + return strings; + } + if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR"); + if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR"); + if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR"); + if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeIntraRefreshModeFlagsKHR(Printer& p, std::string name, VkVideoEncodeIntraRefreshModeFlagsKHR value) { + if (static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeIntraRefreshModeFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeIntraRefreshModeFlagBitsKHR value) { + auto strings = VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(VkVideoEncodeRateControlModeFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR"); + return strings; + } + if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR & value) + strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR"); + if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR"); + if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeRateControlModeFlagsKHR(Printer& p, std::string name, VkVideoEncodeRateControlModeFlagsKHR value) { + if (static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeRateControlModeFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeRateControlModeFlagBitsKHR value) { + auto strings = VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE"); + if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE"); + return strings; +} +void DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(Printer& p, std::string name, VkVideoEncodeRgbChromaOffsetFlagsVALVE value) { + if (static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = + VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeRgbChromaOffsetFlagBitsVALVE(Printer& p, std::string name, VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) { + auto strings = VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings( + VkVideoEncodeRgbModelConversionFlagBitsVALVE value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE"); + if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE"); + if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE"); + if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE"); + if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE"); + return strings; +} +void DumpVkVideoEncodeRgbModelConversionFlagsVALVE(Printer& p, std::string name, VkVideoEncodeRgbModelConversionFlagsVALVE value) { + if (static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = + VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeRgbModelConversionFlagBitsVALVE(Printer& p, std::string name, + VkVideoEncodeRgbModelConversionFlagBitsVALVE value) { + auto strings = VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings( + VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("None"); + return strings; + } + if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE"); + if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE & value) + strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE"); + return strings; +} +void DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(Printer& p, std::string name, + VkVideoEncodeRgbRangeCompressionFlagsVALVE value) { + if (static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = + VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeRgbRangeCompressionFlagBitsVALVE(Printer& p, std::string name, + VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) { + auto strings = VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +std::vector<const char*> VkVideoEncodeUsageFlagBitsKHRGetStrings(VkVideoEncodeUsageFlagBitsKHR value) { + std::vector<const char*> strings; + if (value == 0) { + strings.push_back("VIDEO_ENCODE_USAGE_DEFAULT_KHR"); + return strings; + } + if (VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR"); + if (VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR"); + if (VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR"); + if (VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR"); + return strings; +} +void DumpVkVideoEncodeUsageFlagsKHR(Printer& p, std::string name, VkVideoEncodeUsageFlagsKHR value) { + if (static_cast<VkVideoEncodeUsageFlagBitsKHR>(value) == 0) { + ArrayWrapper arr(p, name, 0); + if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None"); + return; + } + auto strings = VkVideoEncodeUsageFlagBitsKHRGetStrings(static_cast<VkVideoEncodeUsageFlagBitsKHR>(value)); + ArrayWrapper arr(p, name, strings.size()); + for (auto& str : strings) { + if (p.Type() == OutputType::json) + p.SetAsType().PrintString(std::string("VK_") + str); + else + p.SetAsType().PrintString(str); + } +} +void DumpVkVideoEncodeUsageFlagBitsKHR(Printer& p, std::string name, VkVideoEncodeUsageFlagBitsKHR value) { + auto strings = VkVideoEncodeUsageFlagBitsKHRGetStrings(value); + if (strings.size() > 0) { + if (p.Type() == OutputType::json) + p.PrintKeyString(name, std::string("VK_") + strings.at(0)); + else + p.PrintKeyString(name, strings.at(0)); + } +} + +void DumpVkComponentMapping(Printer& p, std::string name, const VkComponentMapping& obj); +void DumpVkConformanceVersion(Printer& p, std::string name, const VkConformanceVersion& obj); +void DumpVkCooperativeMatrixPropertiesKHR(Printer& p, std::string name, const VkCooperativeMatrixPropertiesKHR& obj); +void DumpVkDisplayModeParametersKHR(Printer& p, std::string name, const VkDisplayModeParametersKHR& obj); +void DumpVkDisplayModePropertiesKHR(Printer& p, std::string name, const VkDisplayModePropertiesKHR& obj); +void DumpVkDisplayPlaneCapabilitiesKHR(Printer& p, std::string name, const VkDisplayPlaneCapabilitiesKHR& obj); +void DumpVkDisplayPlanePropertiesKHR(Printer& p, std::string name, const VkDisplayPlanePropertiesKHR& obj); +void DumpVkDisplayPropertiesKHR(Printer& p, std::string name, const VkDisplayPropertiesKHR& obj); +void DumpVkDrmFormatModifierProperties2EXT(Printer& p, std::string name, const VkDrmFormatModifierProperties2EXT& obj); +void DumpVkExtensionProperties(Printer& p, std::string name, const VkExtensionProperties& obj); +void DumpVkExtent2D(Printer& p, std::string name, const VkExtent2D& obj); +void DumpVkExtent3D(Printer& p, std::string name, const VkExtent3D& obj); +void DumpVkFormatProperties(Printer& p, std::string name, const VkFormatProperties& obj); +void DumpVkFormatProperties3(Printer& p, std::string name, const VkFormatProperties3& obj); +void DumpVkLayerProperties(Printer& p, std::string name, const VkLayerProperties& obj); +void DumpVkMultisamplePropertiesEXT(Printer& p, std::string name, const VkMultisamplePropertiesEXT& obj); +void DumpVkOffset2D(Printer& p, std::string name, const VkOffset2D& obj); +void DumpVkPhysicalDevice16BitStorageFeatures(Printer& p, std::string name, const VkPhysicalDevice16BitStorageFeatures& obj); +void DumpVkPhysicalDevice4444FormatsFeaturesEXT(Printer& p, std::string name, const VkPhysicalDevice4444FormatsFeaturesEXT& obj); +void DumpVkPhysicalDevice8BitStorageFeatures(Printer& p, std::string name, const VkPhysicalDevice8BitStorageFeatures& obj); +void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceASTCDecodeFeaturesEXT& obj); +void DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceAccelerationStructureFeaturesKHR& obj); +void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceAccelerationStructurePropertiesKHR& obj); +void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceAddressBindingReportFeaturesEXT& obj); +void DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& obj); +void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& obj); +void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& obj); +void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& obj); +void DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& obj); +void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer& p, std::string name, + const VkPhysicalDeviceBufferDeviceAddressFeatures& obj); +void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& obj); +void DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceColorWriteEnableFeaturesEXT& obj); +void DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& obj); +void DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& obj); +void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceConditionalRenderingFeaturesEXT& obj); +void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& obj); +void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& obj); +void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& obj); +void DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& obj); +void DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& obj); +void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceCustomBorderColorFeaturesEXT& obj); +void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceCustomBorderColorPropertiesEXT& obj); +void DumpVkPhysicalDeviceCustomResolveFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceCustomResolveFeaturesEXT& obj); +void DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthBiasControlFeaturesEXT& obj); +void DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthClampControlFeaturesEXT& obj); +void DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& obj); +void DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthClipControlFeaturesEXT& obj); +void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthClipEnableFeaturesEXT& obj); +void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer& p, std::string name, + const VkPhysicalDeviceDepthStencilResolveProperties& obj); +void DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( + Printer& p, std::string name, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& obj); +void DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorBufferFeaturesEXT& obj); +void DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorBufferPropertiesEXT& obj); +void DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorHeapFeaturesEXT& obj); +void DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorHeapPropertiesEXT& obj); +void DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM& obj); +void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorIndexingFeatures& obj); +void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorIndexingProperties& obj); +void DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR& obj); +void DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& obj); +void DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& obj); +void DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& obj); +void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDiscardRectanglePropertiesEXT& obj); +void DumpVkPhysicalDeviceDriverProperties(Printer& p, std::string name, const VkPhysicalDeviceDriverProperties& obj); +void DumpVkPhysicalDeviceDrmPropertiesEXT(Printer& p, std::string name, const VkPhysicalDeviceDrmPropertiesEXT& obj); +void DumpVkPhysicalDeviceDynamicRenderingFeatures(Printer& p, std::string name, + const VkPhysicalDeviceDynamicRenderingFeatures& obj); +void DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(Printer& p, std::string name, + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures& obj); +void DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& obj); +void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& obj); +void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& obj); +void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& obj); +void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& obj); +void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& obj); +void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT& obj); +void DumpVkPhysicalDeviceFaultFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceFaultFeaturesKHR& obj); +void DumpVkPhysicalDeviceFaultPropertiesKHR(Printer& p, std::string name, const VkPhysicalDeviceFaultPropertiesKHR& obj); +void DumpVkPhysicalDeviceFeatures(Printer& p, std::string name, const VkPhysicalDeviceFeatures& obj); +void DumpVkPhysicalDeviceFloatControlsProperties(Printer& p, std::string name, const VkPhysicalDeviceFloatControlsProperties& obj); +void DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& obj); +void DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& obj); +void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& obj); +void DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& obj); +void DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& obj); +void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& obj); +void DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& obj); +void DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& obj); +void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& obj); +void DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& obj); +void DumpVkPhysicalDeviceFragmentShadingRateKHR(Printer& p, std::string name, const VkPhysicalDeviceFragmentShadingRateKHR& obj); +void DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& obj); +void DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFrameBoundaryFeaturesEXT& obj); +void DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(Printer& p, std::string name, + const VkPhysicalDeviceGlobalPriorityQueryFeatures& obj); +void DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& obj); +void DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& obj); +void DumpVkPhysicalDeviceHostImageCopyFeatures(Printer& p, std::string name, const VkPhysicalDeviceHostImageCopyFeatures& obj); +void DumpVkPhysicalDeviceHostImageCopyProperties(Printer& p, std::string name, const VkPhysicalDeviceHostImageCopyProperties& obj); +void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer& p, std::string name, const VkPhysicalDeviceHostQueryResetFeatures& obj); +void DumpVkPhysicalDeviceIDProperties(Printer& p, std::string name, const VkPhysicalDeviceIDProperties& obj); +void DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& obj); +void DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImageCompressionControlFeaturesEXT& obj); +void DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& obj); +void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer& p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures& obj); +void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& obj); +void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImageViewMinLodFeaturesEXT& obj); +void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer& p, std::string name, + const VkPhysicalDeviceImagelessFramebufferFeatures& obj); +void DumpVkPhysicalDeviceIndexTypeUint8Features(Printer& p, std::string name, const VkPhysicalDeviceIndexTypeUint8Features& obj); +void DumpVkPhysicalDeviceInlineUniformBlockFeatures(Printer& p, std::string name, + const VkPhysicalDeviceInlineUniformBlockFeatures& obj); +void DumpVkPhysicalDeviceInlineUniformBlockProperties(Printer& p, std::string name, + const VkPhysicalDeviceInlineUniformBlockProperties& obj); +void DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR& obj); +void DumpVkPhysicalDeviceLayeredApiPropertiesKHR(Printer& p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesKHR& obj); +void DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(Printer& p, std::string name, + const VkPhysicalDeviceLayeredApiPropertiesListKHR& obj); +void DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceLegacyDitheringFeaturesEXT& obj); +void DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& obj); +void DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& obj); +void DumpVkPhysicalDeviceLimits(Printer& p, std::string name, const VkPhysicalDeviceLimits& obj); +void DumpVkPhysicalDeviceLineRasterizationFeatures(Printer& p, std::string name, + const VkPhysicalDeviceLineRasterizationFeatures& obj); +void DumpVkPhysicalDeviceLineRasterizationProperties(Printer& p, std::string name, + const VkPhysicalDeviceLineRasterizationProperties& obj); +void DumpVkPhysicalDeviceMaintenance10FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance10FeaturesKHR& obj); +void DumpVkPhysicalDeviceMaintenance10PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance10PropertiesKHR& obj); +void DumpVkPhysicalDeviceMaintenance11FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance11FeaturesKHR& obj); +void DumpVkPhysicalDeviceMaintenance3Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance3Properties& obj); +void DumpVkPhysicalDeviceMaintenance4Features(Printer& p, std::string name, const VkPhysicalDeviceMaintenance4Features& obj); +void DumpVkPhysicalDeviceMaintenance4Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance4Properties& obj); +void DumpVkPhysicalDeviceMaintenance5Features(Printer& p, std::string name, const VkPhysicalDeviceMaintenance5Features& obj); +void DumpVkPhysicalDeviceMaintenance5Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance5Properties& obj); +void DumpVkPhysicalDeviceMaintenance6Features(Printer& p, std::string name, const VkPhysicalDeviceMaintenance6Features& obj); +void DumpVkPhysicalDeviceMaintenance6Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance6Properties& obj); +void DumpVkPhysicalDeviceMaintenance7FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceMaintenance7FeaturesKHR& obj); +void DumpVkPhysicalDeviceMaintenance7PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance7PropertiesKHR& obj); +void DumpVkPhysicalDeviceMaintenance8FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceMaintenance8FeaturesKHR& obj); +void DumpVkPhysicalDeviceMaintenance9FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceMaintenance9FeaturesKHR& obj); +void DumpVkPhysicalDeviceMaintenance9PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance9PropertiesKHR& obj); +void DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& obj); +void DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& obj); +void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryBudgetPropertiesEXT& obj); +void DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryDecompressionFeaturesEXT& obj); +void DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryDecompressionPropertiesEXT& obj); +void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryPriorityFeaturesEXT& obj); +void DumpVkPhysicalDeviceMeshShaderFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceMeshShaderFeaturesEXT& obj); +void DumpVkPhysicalDeviceMeshShaderPropertiesEXT(Printer& p, std::string name, const VkPhysicalDeviceMeshShaderPropertiesEXT& obj); +void DumpVkPhysicalDeviceMultiDrawFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceMultiDrawFeaturesEXT& obj); +void DumpVkPhysicalDeviceMultiDrawPropertiesEXT(Printer& p, std::string name, const VkPhysicalDeviceMultiDrawPropertiesEXT& obj); +void DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& obj); +void DumpVkPhysicalDeviceMultiviewFeatures(Printer& p, std::string name, const VkPhysicalDeviceMultiviewFeatures& obj); +void DumpVkPhysicalDeviceMultiviewProperties(Printer& p, std::string name, const VkPhysicalDeviceMultiviewProperties& obj); +void DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& obj); +void DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT& obj); +void DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceNestedCommandBufferPropertiesEXT& obj); +void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& obj); +void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceOpacityMicromapFeaturesEXT& obj); +void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceOpacityMicromapPropertiesEXT& obj); +void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer& p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT& obj); +void DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& obj); +void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePerformanceQueryFeaturesKHR& obj); +void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDevicePerformanceQueryPropertiesKHR& obj); +void DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePipelineBinaryFeaturesKHR& obj); +void DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDevicePipelineBinaryPropertiesKHR& obj); +void DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(Printer& p, std::string name, + const VkPhysicalDevicePipelineCreationCacheControlFeatures& obj); +void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& obj); +void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& obj); +void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePipelinePropertiesFeaturesEXT& obj); +void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer& p, std::string name, + const VkPhysicalDevicePipelineProtectedAccessFeatures& obj); +void DumpVkPhysicalDevicePipelineRobustnessFeatures(Printer& p, std::string name, + const VkPhysicalDevicePipelineRobustnessFeatures& obj); +void DumpVkPhysicalDevicePipelineRobustnessProperties(Printer& p, std::string name, + const VkPhysicalDevicePipelineRobustnessProperties& obj); +void DumpVkPhysicalDevicePointClippingProperties(Printer& p, std::string name, const VkPhysicalDevicePointClippingProperties& obj); +#ifdef VK_ENABLE_BETA_EXTENSIONS +void DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePortabilitySubsetFeaturesKHR& obj); +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +void DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDevicePortabilitySubsetPropertiesKHR& obj); +#endif // VK_ENABLE_BETA_EXTENSIONS +void DumpVkPhysicalDevicePresentId2FeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentId2FeaturesKHR& obj); +void DumpVkPhysicalDevicePresentIdFeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentIdFeaturesKHR& obj); +void DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& obj); +void DumpVkPhysicalDevicePresentTimingFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePresentTimingFeaturesEXT& obj); +void DumpVkPhysicalDevicePresentWait2FeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentWait2FeaturesKHR& obj); +void DumpVkPhysicalDevicePresentWaitFeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentWaitFeaturesKHR& obj); +void DumpVkPhysicalDevicePrimitiveRestartIndexFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT& obj); +void DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& obj); +void DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& obj); +void DumpVkPhysicalDevicePrivateDataFeatures(Printer& p, std::string name, const VkPhysicalDevicePrivateDataFeatures& obj); +void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer& p, std::string name, const VkPhysicalDeviceProtectedMemoryFeatures& obj); +void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer& p, std::string name, + const VkPhysicalDeviceProtectedMemoryProperties& obj); +void DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceProvokingVertexFeaturesEXT& obj); +void DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceProvokingVertexPropertiesEXT& obj); +void DumpVkPhysicalDevicePushDescriptorProperties(Printer& p, std::string name, + const VkPhysicalDevicePushDescriptorProperties& obj); +void DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& obj); +void DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& obj); +void DumpVkPhysicalDeviceRayQueryFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceRayQueryFeaturesKHR& obj); +void DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT& obj); +void DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT( + Printer& p, std::string name, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT& obj); +void DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& obj); +void DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& obj); +void DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& obj); +void DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& obj); +void DumpVkPhysicalDeviceRobustness2FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceRobustness2FeaturesKHR& obj); +void DumpVkPhysicalDeviceRobustness2PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRobustness2PropertiesKHR& obj); +void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceSampleLocationsPropertiesEXT& obj); +void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer& p, std::string name, + const VkPhysicalDeviceSamplerFilterMinmaxProperties& obj); +void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer& p, std::string name, + const VkPhysicalDeviceSamplerYcbcrConversionFeatures& obj); +void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer& p, std::string name, + const VkPhysicalDeviceScalarBlockLayoutFeatures& obj); +void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer& p, std::string name, + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& obj); +void DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShader64BitIndexingFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderAbortFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceShaderAbortFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderAbortPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderAbortPropertiesKHR& obj); +void DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer& p, std::string name, + const VkPhysicalDeviceShaderAtomicInt64Features& obj); +void DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderBfloat16FeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceShaderClockFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderConstantDataFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& obj); +void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderDrawParametersFeatures& obj); +void DumpVkPhysicalDeviceShaderExpectAssumeFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderExpectAssumeFeatures& obj); +void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer& p, std::string name, + const VkPhysicalDeviceShaderFloat16Int8Features& obj); +void DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceShaderFloat8FeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderFloatControls2Features(Printer& p, std::string name, + const VkPhysicalDeviceShaderFloatControls2Features& obj); +void DumpVkPhysicalDeviceShaderFmaFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceShaderFmaFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderIntegerDotProductFeatures& obj); +void DumpVkPhysicalDeviceShaderIntegerDotProductProperties(Printer& p, std::string name, + const VkPhysicalDeviceShaderIntegerDotProductProperties& obj); +void DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderLongVectorFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderLongVectorPropertiesEXT& obj); +void DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& obj); +void DumpVkPhysicalDeviceShaderObjectFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceShaderObjectFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderObjectPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderObjectPropertiesEXT& obj); +void DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderQuadControlFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& obj); +void DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderSubgroupRotateFeatures& obj); +void DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& obj); +void DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderTerminateInvocationFeatures& obj); +void DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderTileImageFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderTileImagePropertiesEXT& obj); +void DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT& obj); +void DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& obj); +void DumpVkPhysicalDeviceSparseProperties(Printer& p, std::string name, const VkPhysicalDeviceSparseProperties& obj); +void DumpVkPhysicalDeviceSubgroupProperties(Printer& p, std::string name, const VkPhysicalDeviceSubgroupProperties& obj); +void DumpVkPhysicalDeviceSubgroupSizeControlFeatures(Printer& p, std::string name, + const VkPhysicalDeviceSubgroupSizeControlFeatures& obj); +void DumpVkPhysicalDeviceSubgroupSizeControlProperties(Printer& p, std::string name, + const VkPhysicalDeviceSubgroupSizeControlProperties& obj); +void DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& obj); +void DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& obj); +void DumpVkPhysicalDeviceSynchronization2Features(Printer& p, std::string name, + const VkPhysicalDeviceSynchronization2Features& obj); +void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& obj); +void DumpVkPhysicalDeviceTexelBufferAlignmentProperties(Printer& p, std::string name, + const VkPhysicalDeviceTexelBufferAlignmentProperties& obj); +void DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT& obj); +void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(Printer& p, std::string name, + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& obj); +void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer& p, std::string name, + const VkPhysicalDeviceTimelineSemaphoreFeatures& obj); +void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer& p, std::string name, + const VkPhysicalDeviceTimelineSemaphoreProperties& obj); +void DumpVkPhysicalDeviceToolProperties(Printer& p, std::string name, const VkPhysicalDeviceToolProperties& obj); +void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTransformFeedbackFeaturesEXT& obj); +void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTransformFeedbackPropertiesEXT& obj); +void DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& obj); +void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer& p, std::string name, + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& obj); +void DumpVkPhysicalDeviceVariablePointersFeatures(Printer& p, std::string name, + const VkPhysicalDeviceVariablePointersFeatures& obj); +void DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeDivisorFeatures& obj); +void DumpVkPhysicalDeviceVertexAttributeDivisorProperties(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeDivisorProperties& obj); +void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& obj); +void DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& obj); +void DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& obj); +void DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& obj); +void DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& obj); +void DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& obj); +void DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& obj); +void DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& obj); +void DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoMaintenance2FeaturesKHR& obj); +void DumpVkPhysicalDeviceVulkan11Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan11Features& obj); +void DumpVkPhysicalDeviceVulkan11Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan11Properties& obj); +void DumpVkPhysicalDeviceVulkan12Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan12Features& obj); +void DumpVkPhysicalDeviceVulkan12Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan12Properties& obj); +void DumpVkPhysicalDeviceVulkan13Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan13Features& obj); +void DumpVkPhysicalDeviceVulkan13Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan13Properties& obj); +void DumpVkPhysicalDeviceVulkan14Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan14Features& obj); +void DumpVkPhysicalDeviceVulkan14Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan14Properties& obj); +void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer& p, std::string name, + const VkPhysicalDeviceVulkanMemoryModelFeatures& obj); +void DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& obj); +void DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& obj); +void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& obj); +void DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& obj); +void DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(Printer& p, std::string name, + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& obj); +void DumpVkPresentTimingSurfaceCapabilitiesEXT(Printer& p, std::string name, const VkPresentTimingSurfaceCapabilitiesEXT& obj); +void DumpVkQueueFamilyGlobalPriorityProperties(Printer& p, std::string name, const VkQueueFamilyGlobalPriorityProperties& obj); +void DumpVkQueueFamilyOptimalImageTransferGranularityPropertiesKHR( + Printer& p, std::string name, const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR& obj); +void DumpVkQueueFamilyOwnershipTransferPropertiesKHR(Printer& p, std::string name, + const VkQueueFamilyOwnershipTransferPropertiesKHR& obj); +void DumpVkQueueFamilyQueryResultStatusPropertiesKHR(Printer& p, std::string name, + const VkQueueFamilyQueryResultStatusPropertiesKHR& obj); +void DumpVkQueueFamilyVideoPropertiesKHR(Printer& p, std::string name, const VkQueueFamilyVideoPropertiesKHR& obj); +void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer& p, std::string name, const VkSharedPresentSurfaceCapabilitiesKHR& obj); +void DumpVkSubpassResolvePerformanceQueryEXT(Printer& p, std::string name, const VkSubpassResolvePerformanceQueryEXT& obj); +#ifdef VK_USE_PLATFORM_WIN32_KHR +void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer& p, std::string name, + const VkSurfaceCapabilitiesFullScreenExclusiveEXT& obj); +#endif // VK_USE_PLATFORM_WIN32_KHR +void DumpVkSurfaceCapabilitiesKHR(Printer& p, std::string name, const VkSurfaceCapabilitiesKHR& obj); +void DumpVkSurfaceCapabilitiesPresentId2KHR(Printer& p, std::string name, const VkSurfaceCapabilitiesPresentId2KHR& obj); +void DumpVkSurfaceCapabilitiesPresentWait2KHR(Printer& p, std::string name, const VkSurfaceCapabilitiesPresentWait2KHR& obj); +void DumpVkSurfaceFormatKHR(Printer& p, std::string name, const VkSurfaceFormatKHR& obj); +void DumpVkSurfacePresentModeCompatibilityKHR(Printer& p, std::string name, const VkSurfacePresentModeCompatibilityKHR& obj); +void DumpVkSurfacePresentScalingCapabilitiesKHR(Printer& p, std::string name, const VkSurfacePresentScalingCapabilitiesKHR& obj); +void DumpVkSurfaceProtectedCapabilitiesKHR(Printer& p, std::string name, const VkSurfaceProtectedCapabilitiesKHR& obj); +void DumpVkVideoCapabilitiesKHR(Printer& p, std::string name, const VkVideoCapabilitiesKHR& obj); +void DumpVkVideoDecodeAV1CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeAV1CapabilitiesKHR& obj); +void DumpVkVideoDecodeAV1ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeAV1ProfileInfoKHR& obj); +void DumpVkVideoDecodeCapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeCapabilitiesKHR& obj); +void DumpVkVideoDecodeH264CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeH264CapabilitiesKHR& obj); +void DumpVkVideoDecodeH264ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeH264ProfileInfoKHR& obj); +void DumpVkVideoDecodeH265CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeH265CapabilitiesKHR& obj); +void DumpVkVideoDecodeH265ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeH265ProfileInfoKHR& obj); +void DumpVkVideoDecodeUsageInfoKHR(Printer& p, std::string name, const VkVideoDecodeUsageInfoKHR& obj); +void DumpVkVideoDecodeVP9CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeVP9CapabilitiesKHR& obj); +void DumpVkVideoDecodeVP9ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeVP9ProfileInfoKHR& obj); +void DumpVkVideoEncodeAV1CapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeAV1CapabilitiesKHR& obj); +void DumpVkVideoEncodeAV1ProfileInfoKHR(Printer& p, std::string name, const VkVideoEncodeAV1ProfileInfoKHR& obj); +void DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& obj); +void DumpVkVideoEncodeCapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeCapabilitiesKHR& obj); +void DumpVkVideoEncodeH264CapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeH264CapabilitiesKHR& obj); +void DumpVkVideoEncodeH264ProfileInfoKHR(Printer& p, std::string name, const VkVideoEncodeH264ProfileInfoKHR& obj); +void DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeH264QuantizationMapCapabilitiesKHR& obj); +void DumpVkVideoEncodeH265CapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeH265CapabilitiesKHR& obj); +void DumpVkVideoEncodeH265ProfileInfoKHR(Printer& p, std::string name, const VkVideoEncodeH265ProfileInfoKHR& obj); +void DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeH265QuantizationMapCapabilitiesKHR& obj); +void DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeIntraRefreshCapabilitiesKHR& obj); +void DumpVkVideoEncodeProfileRgbConversionInfoVALVE(Printer& p, std::string name, + const VkVideoEncodeProfileRgbConversionInfoVALVE& obj); +void DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeQuantizationMapCapabilitiesKHR& obj); +void DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(Printer& p, std::string name, + const VkVideoEncodeRgbConversionCapabilitiesVALVE& obj); +void DumpVkVideoEncodeUsageInfoKHR(Printer& p, std::string name, const VkVideoEncodeUsageInfoKHR& obj); +void DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(Printer& p, std::string name, + const VkVideoFormatAV1QuantizationMapPropertiesKHR& obj); +void DumpVkVideoFormatH265QuantizationMapPropertiesKHR(Printer& p, std::string name, + const VkVideoFormatH265QuantizationMapPropertiesKHR& obj); +void DumpVkVideoFormatPropertiesKHR(Printer& p, std::string name, const VkVideoFormatPropertiesKHR& obj); +void DumpVkVideoFormatQuantizationMapPropertiesKHR(Printer& p, std::string name, + const VkVideoFormatQuantizationMapPropertiesKHR& obj); +void DumpVkVideoProfileInfoKHR(Printer& p, std::string name, const VkVideoProfileInfoKHR& obj); +void DumpVkComponentMapping(Printer& p, std::string name, const VkComponentMapping& obj) { + ObjectWrapper object{p, name}; + DumpVkComponentSwizzle(p, "r", obj.r); + DumpVkComponentSwizzle(p, "g", obj.g); + DumpVkComponentSwizzle(p, "b", obj.b); + DumpVkComponentSwizzle(p, "a", obj.a); +} +void DumpVkConformanceVersion(Printer& p, std::string name, const VkConformanceVersion& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(8); p.PrintKeyValue("major", static_cast<uint32_t>(obj.major)); @@ -1438,7 +5000,61 @@ p.PrintKeyValue("subminor", static_cast<uint32_t>(obj.subminor)); p.PrintKeyValue("patch", static_cast<uint32_t>(obj.patch)); } -void DumpVkDrmFormatModifierProperties2EXT(Printer &p, std::string name, const VkDrmFormatModifierProperties2EXT &obj) { +void DumpVkCooperativeMatrixPropertiesKHR(Printer& p, std::string name, const VkCooperativeMatrixPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(22); + p.PrintKeyValue("MSize", obj.MSize); + p.PrintKeyValue("NSize", obj.NSize); + p.PrintKeyValue("KSize", obj.KSize); + DumpVkComponentTypeKHR(p, "AType", obj.AType); + DumpVkComponentTypeKHR(p, "BType", obj.BType); + DumpVkComponentTypeKHR(p, "CType", obj.CType); + DumpVkComponentTypeKHR(p, "ResultType", obj.ResultType); + p.PrintKeyBool("saturatingAccumulation", static_cast<bool>(obj.saturatingAccumulation)); + DumpVkScopeKHR(p, "scope", obj.scope); +} +void DumpVkDisplayModeParametersKHR(Printer& p, std::string name, const VkDisplayModeParametersKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(11); + DumpVkExtent2D(p, "visibleRegion", obj.visibleRegion); + p.PrintKeyValue("refreshRate", obj.refreshRate); +} +void DumpVkDisplayModePropertiesKHR(Printer& p, std::string name, const VkDisplayModePropertiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkDisplayModeParametersKHR(p, "parameters", obj.parameters); +} +void DumpVkDisplayPlaneCapabilitiesKHR(Printer& p, std::string name, const VkDisplayPlaneCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkDisplayPlaneAlphaFlagsKHR(p, "supportedAlpha", obj.supportedAlpha); + DumpVkOffset2D(p, "minSrcPosition", obj.minSrcPosition); + DumpVkOffset2D(p, "maxSrcPosition", obj.maxSrcPosition); + DumpVkExtent2D(p, "minSrcExtent", obj.minSrcExtent); + DumpVkExtent2D(p, "maxSrcExtent", obj.maxSrcExtent); + DumpVkOffset2D(p, "minDstPosition", obj.minDstPosition); + DumpVkOffset2D(p, "maxDstPosition", obj.maxDstPosition); + DumpVkExtent2D(p, "minDstExtent", obj.minDstExtent); + DumpVkExtent2D(p, "maxDstExtent", obj.maxDstExtent); +} +void DumpVkDisplayPlanePropertiesKHR(Printer& p, std::string name, const VkDisplayPlanePropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(17); + p.PrintKeyValue("currentStackIndex", obj.currentStackIndex); +} +void DumpVkDisplayPropertiesKHR(Printer& p, std::string name, const VkDisplayPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(20); + if (obj.displayName == nullptr) { + p.PrintKeyString("displayName", "NULL"); + } else { + p.PrintKeyString("displayName", obj.displayName); + } + DumpVkExtent2D(p, "physicalDimensions", obj.physicalDimensions); + DumpVkExtent2D(p, "physicalResolution", obj.physicalResolution); + DumpVkSurfaceTransformFlagsKHR(p, "supportedTransforms", obj.supportedTransforms); + p.PrintKeyBool("planeReorderPossible", static_cast<bool>(obj.planeReorderPossible)); + p.PrintKeyBool("persistentContent", static_cast<bool>(obj.persistentContent)); +} +void DumpVkDrmFormatModifierProperties2EXT(Printer& p, std::string name, const VkDrmFormatModifierProperties2EXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyValue("drmFormatModifier", obj.drmFormatModifier); @@ -1446,20 +5062,26 @@ p.SetOpenDetails(); DumpVkFormatFeatureFlags2(p, "drmFormatModifierTilingFeatures", obj.drmFormatModifierTilingFeatures); } -void DumpVkExtent2D(Printer &p, std::string name, const VkExtent2D &obj) { +void DumpVkExtensionProperties(Printer& p, std::string name, const VkExtensionProperties& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(13); + p.PrintKeyString("extensionName", obj.extensionName); + p.PrintKeyValue("specVersion", obj.specVersion); +} +void DumpVkExtent2D(Printer& p, std::string name, const VkExtent2D& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(6); p.PrintKeyValue("width", obj.width); p.PrintKeyValue("height", obj.height); } -void DumpVkExtent3D(Printer &p, std::string name, const VkExtent3D &obj) { +void DumpVkExtent3D(Printer& p, std::string name, const VkExtent3D& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(6); p.PrintKeyValue("width", obj.width); p.PrintKeyValue("height", obj.height); p.PrintKeyValue("depth", obj.depth); } -void DumpVkFormatProperties(Printer &p, std::string name, const VkFormatProperties &obj) { +void DumpVkFormatProperties(Printer& p, std::string name, const VkFormatProperties& obj) { ObjectWrapper object{p, name}; p.SetOpenDetails(); DumpVkFormatFeatureFlags(p, "linearTilingFeatures", obj.linearTilingFeatures); @@ -1468,7 +5090,7 @@ p.SetOpenDetails(); DumpVkFormatFeatureFlags(p, "bufferFeatures", obj.bufferFeatures); } -void DumpVkFormatProperties3(Printer &p, std::string name, const VkFormatProperties3 &obj) { +void DumpVkFormatProperties3(Printer& p, std::string name, const VkFormatProperties3& obj) { ObjectWrapper object{p, name}; p.SetOpenDetails(); DumpVkFormatFeatureFlags2(p, "linearTilingFeatures", obj.linearTilingFeatures); @@ -1477,7 +5099,7 @@ p.SetOpenDetails(); DumpVkFormatFeatureFlags2(p, "bufferFeatures", obj.bufferFeatures); } -void DumpVkLayerProperties(Printer &p, std::string name, const VkLayerProperties &obj) { +void DumpVkLayerProperties(Printer& p, std::string name, const VkLayerProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(21); p.PrintKeyString("layerName", obj.layerName); @@ -1485,7 +5107,17 @@ p.PrintKeyValue("implementationVersion", obj.implementationVersion); p.PrintKeyString("description", obj.description); } -void DumpVkPhysicalDevice16BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice16BitStorageFeatures &obj) { +void DumpVkMultisamplePropertiesEXT(Printer& p, std::string name, const VkMultisamplePropertiesEXT& obj) { + ObjectWrapper object{p, name}; + DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize); +} +void DumpVkOffset2D(Printer& p, std::string name, const VkOffset2D& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(1); + p.PrintKeyValue("x", obj.x); + p.PrintKeyValue("y", obj.y); +} +void DumpVkPhysicalDevice16BitStorageFeatures(Printer& p, std::string name, const VkPhysicalDevice16BitStorageFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess)); @@ -1493,66 +5125,76 @@ p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16)); p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16)); } -void DumpVkPhysicalDevice4444FormatsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevice4444FormatsFeaturesEXT &obj) { +void DumpVkPhysicalDevice4444FormatsFeaturesEXT(Printer& p, std::string name, const VkPhysicalDevice4444FormatsFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(14); p.PrintKeyBool("formatA4R4G4B4", static_cast<bool>(obj.formatA4R4G4B4)); p.PrintKeyBool("formatA4B4G4R4", static_cast<bool>(obj.formatA4B4G4R4)); } -void DumpVkPhysicalDevice8BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice8BitStorageFeatures &obj) { +void DumpVkPhysicalDevice8BitStorageFeatures(Printer& p, std::string name, const VkPhysicalDevice8BitStorageFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(33); p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess)); p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess)); p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8)); } -void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceASTCDecodeFeaturesEXT &obj) { +void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceASTCDecodeFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(24); p.PrintKeyBool("decodeModeSharedExponent", static_cast<bool>(obj.decodeModeSharedExponent)); } -void DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceAccelerationStructureFeaturesKHR &obj) { +void DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceAccelerationStructureFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(53); p.PrintKeyBool("accelerationStructure", static_cast<bool>(obj.accelerationStructure)); p.PrintKeyBool("accelerationStructureCaptureReplay", static_cast<bool>(obj.accelerationStructureCaptureReplay)); p.PrintKeyBool("accelerationStructureIndirectBuild", static_cast<bool>(obj.accelerationStructureIndirectBuild)); p.PrintKeyBool("accelerationStructureHostCommands", static_cast<bool>(obj.accelerationStructureHostCommands)); - p.PrintKeyBool("descriptorBindingAccelerationStructureUpdateAfterBind", static_cast<bool>(obj.descriptorBindingAccelerationStructureUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingAccelerationStructureUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingAccelerationStructureUpdateAfterBind)); } -void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceAccelerationStructurePropertiesKHR &obj) { +void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceAccelerationStructurePropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(58); p.PrintKeyValue("maxGeometryCount", obj.maxGeometryCount); p.PrintKeyValue("maxInstanceCount", obj.maxInstanceCount); p.PrintKeyValue("maxPrimitiveCount", obj.maxPrimitiveCount); p.PrintKeyValue("maxPerStageDescriptorAccelerationStructures", obj.maxPerStageDescriptorAccelerationStructures); - p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindAccelerationStructures", obj.maxPerStageDescriptorUpdateAfterBindAccelerationStructures); + p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindAccelerationStructures", + obj.maxPerStageDescriptorUpdateAfterBindAccelerationStructures); p.PrintKeyValue("maxDescriptorSetAccelerationStructures", obj.maxDescriptorSetAccelerationStructures); - p.PrintKeyValue("maxDescriptorSetUpdateAfterBindAccelerationStructures", obj.maxDescriptorSetUpdateAfterBindAccelerationStructures); + p.PrintKeyValue("maxDescriptorSetUpdateAfterBindAccelerationStructures", + obj.maxDescriptorSetUpdateAfterBindAccelerationStructures); p.PrintKeyValue("minAccelerationStructureScratchOffsetAlignment", obj.minAccelerationStructureScratchOffsetAlignment); } -void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceAddressBindingReportFeaturesEXT &obj) { +void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceAddressBindingReportFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("reportAddressBinding", static_cast<bool>(obj.reportAddressBinding)); } -void DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT &obj) { +void DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyBool("attachmentFeedbackLoopDynamicState", static_cast<bool>(obj.attachmentFeedbackLoopDynamicState)); } -void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &obj) { +void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyBool("attachmentFeedbackLoopLayout", static_cast<bool>(obj.attachmentFeedbackLoopLayout)); } -void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &obj) { +void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(31); p.PrintKeyBool("advancedBlendCoherentOperations", static_cast<bool>(obj.advancedBlendCoherentOperations)); } -void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &obj) { +void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(37); p.PrintKeyValue("advancedBlendMaxColorAttachments", obj.advancedBlendMaxColorAttachments); @@ -1562,49 +5204,57 @@ p.PrintKeyBool("advancedBlendCorrelatedOverlap", static_cast<bool>(obj.advancedBlendCorrelatedOverlap)); p.PrintKeyBool("advancedBlendAllOperations", static_cast<bool>(obj.advancedBlendAllOperations)); } -void DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &obj) { +void DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyBool("borderColorSwizzle", static_cast<bool>(obj.borderColorSwizzle)); p.PrintKeyBool("borderColorSwizzleFromImage", static_cast<bool>(obj.borderColorSwizzleFromImage)); } -void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer &p, std::string name, const VkPhysicalDeviceBufferDeviceAddressFeatures &obj) { +void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer& p, std::string name, + const VkPhysicalDeviceBufferDeviceAddressFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(32); p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress)); p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay)); p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice)); } -void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &obj) { +void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(32); p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress)); p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay)); p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice)); } -void DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceColorWriteEnableFeaturesEXT &obj) { +void DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceColorWriteEnableFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(16); p.PrintKeyBool("colorWriteEnable", static_cast<bool>(obj.colorWriteEnable)); } -void DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR &obj) { +void DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyBool("computeDerivativeGroupQuads", static_cast<bool>(obj.computeDerivativeGroupQuads)); p.PrintKeyBool("computeDerivativeGroupLinear", static_cast<bool>(obj.computeDerivativeGroupLinear)); } -void DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR &obj) { +void DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyBool("meshAndTaskShaderDerivatives", static_cast<bool>(obj.meshAndTaskShaderDerivatives)); } -void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceConditionalRenderingFeaturesEXT &obj) { +void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceConditionalRenderingFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(29); p.PrintKeyBool("conditionalRendering", static_cast<bool>(obj.conditionalRendering)); p.PrintKeyBool("inheritedConditionalRendering", static_cast<bool>(obj.inheritedConditionalRendering)); } -void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj) { +void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(43); p.PrintKeyValue("primitiveOverestimationSize", obj.primitiveOverestimationSize); @@ -1617,56 +5267,85 @@ p.PrintKeyBool("fullyCoveredFragmentShaderInputVariable", static_cast<bool>(obj.fullyCoveredFragmentShaderInputVariable)); p.PrintKeyBool("conservativeRasterizationPostDepthCoverage", static_cast<bool>(obj.conservativeRasterizationPostDepthCoverage)); } -void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceCooperativeMatrixFeaturesKHR &obj) { +void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(35); p.PrintKeyBool("cooperativeMatrix", static_cast<bool>(obj.cooperativeMatrix)); p.PrintKeyBool("cooperativeMatrixRobustBufferAccess", static_cast<bool>(obj.cooperativeMatrixRobustBufferAccess)); } -void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR &obj) { +void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& obj) { ObjectWrapper object{p, name}; DumpVkShaderStageFlags(p, "cooperativeMatrixSupportedStages", obj.cooperativeMatrixSupportedStages); } -void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceCustomBorderColorFeaturesEXT &obj) { +void DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(25); + p.PrintKeyBool("indirectMemoryCopy", static_cast<bool>(obj.indirectMemoryCopy)); + p.PrintKeyBool("indirectMemoryToImageCopy", static_cast<bool>(obj.indirectMemoryToImageCopy)); +} +void DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkQueueFlags(p, "supportedQueues", obj.supportedQueues); +} +void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceCustomBorderColorFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(30); p.PrintKeyBool("customBorderColors", static_cast<bool>(obj.customBorderColors)); p.PrintKeyBool("customBorderColorWithoutFormat", static_cast<bool>(obj.customBorderColorWithoutFormat)); } -void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceCustomBorderColorPropertiesEXT &obj) { +void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceCustomBorderColorPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyValue("maxCustomBorderColorSamplers", obj.maxCustomBorderColorSamplers); } -void DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDepthBiasControlFeaturesEXT &obj) { +void DumpVkPhysicalDeviceCustomResolveFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceCustomResolveFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(13); + p.PrintKeyBool("customResolve", static_cast<bool>(obj.customResolve)); +} +void DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthBiasControlFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(47); p.PrintKeyBool("depthBiasControl", static_cast<bool>(obj.depthBiasControl)); - p.PrintKeyBool("leastRepresentableValueForceUnormRepresentation", static_cast<bool>(obj.leastRepresentableValueForceUnormRepresentation)); + p.PrintKeyBool("leastRepresentableValueForceUnormRepresentation", + static_cast<bool>(obj.leastRepresentableValueForceUnormRepresentation)); p.PrintKeyBool("floatRepresentation", static_cast<bool>(obj.floatRepresentation)); p.PrintKeyBool("depthBiasExact", static_cast<bool>(obj.depthBiasExact)); } -void DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDepthClampControlFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthClampControlFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("depthClampControl", static_cast<bool>(obj.depthClampControl)); } -void DumpVkPhysicalDeviceDepthClampZeroOneFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("depthClampZeroOne", static_cast<bool>(obj.depthClampZeroOne)); } -void DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDepthClipControlFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthClipControlFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(16); p.PrintKeyBool("depthClipControl", static_cast<bool>(obj.depthClipControl)); } -void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDepthClipEnableFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDepthClipEnableFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(15); p.PrintKeyBool("depthClipEnable", static_cast<bool>(obj.depthClipEnable)); } -void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer &p, std::string name, const VkPhysicalDeviceDepthStencilResolveProperties &obj) { +void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer& p, std::string name, + const VkPhysicalDeviceDepthStencilResolveProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(22); DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes); @@ -1674,12 +5353,14 @@ p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone)); p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve)); } -void DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT &obj) { +void DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( + Printer& p, std::string name, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(44); p.PrintKeyValue("combinedImageSamplerDensityMapDescriptorSize", obj.combinedImageSamplerDensityMapDescriptorSize); } -void DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDescriptorBufferFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorBufferFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyBool("descriptorBuffer", static_cast<bool>(obj.descriptorBuffer)); @@ -1687,7 +5368,8 @@ p.PrintKeyBool("descriptorBufferImageLayoutIgnored", static_cast<bool>(obj.descriptorBufferImageLayoutIgnored)); p.PrintKeyBool("descriptorBufferPushDescriptors", static_cast<bool>(obj.descriptorBufferPushDescriptors)); } -void DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDescriptorBufferPropertiesEXT &obj) { +void DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorBufferPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(52); p.PrintKeyBool("combinedImageSamplerDescriptorSingleArray", static_cast<bool>(obj.combinedImageSamplerDescriptorSingleArray)); @@ -1703,7 +5385,8 @@ p.PrintKeyValue("imageCaptureReplayDescriptorDataSize", obj.imageCaptureReplayDescriptorDataSize); p.PrintKeyValue("imageViewCaptureReplayDescriptorDataSize", obj.imageViewCaptureReplayDescriptorDataSize); p.PrintKeyValue("samplerCaptureReplayDescriptorDataSize", obj.samplerCaptureReplayDescriptorDataSize); - p.PrintKeyValue("accelerationStructureCaptureReplayDescriptorDataSize", obj.accelerationStructureCaptureReplayDescriptorDataSize); + p.PrintKeyValue("accelerationStructureCaptureReplayDescriptorDataSize", + obj.accelerationStructureCaptureReplayDescriptorDataSize); p.PrintKeyValue("samplerDescriptorSize", obj.samplerDescriptorSize); p.PrintKeyValue("combinedImageSamplerDescriptorSize", obj.combinedImageSamplerDescriptorSize); p.PrintKeyValue("sampledImageDescriptorSize", obj.sampledImageDescriptorSize); @@ -1724,39 +5407,96 @@ p.PrintKeyValue("resourceDescriptorBufferAddressSpaceSize", to_hex_str(p, obj.resourceDescriptorBufferAddressSpaceSize)); p.PrintKeyValue("descriptorBufferAddressSpaceSize", to_hex_str(p, obj.descriptorBufferAddressSpaceSize)); } -void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer &p, std::string name, const VkPhysicalDeviceDescriptorIndexingFeatures &obj) { +void DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorHeapFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(27); + p.PrintKeyBool("descriptorHeap", static_cast<bool>(obj.descriptorHeap)); + p.PrintKeyBool("descriptorHeapCaptureReplay", static_cast<bool>(obj.descriptorHeapCaptureReplay)); +} +void DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorHeapPropertiesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(39); + p.PrintKeyValue("samplerHeapAlignment", to_hex_str(p, obj.samplerHeapAlignment)); + p.PrintKeyValue("resourceHeapAlignment", to_hex_str(p, obj.resourceHeapAlignment)); + p.PrintKeyValue("maxSamplerHeapSize", to_hex_str(p, obj.maxSamplerHeapSize)); + p.PrintKeyValue("maxResourceHeapSize", to_hex_str(p, obj.maxResourceHeapSize)); + p.PrintKeyValue("minSamplerHeapReservedRange", to_hex_str(p, obj.minSamplerHeapReservedRange)); + p.PrintKeyValue("minSamplerHeapReservedRangeWithEmbedded", to_hex_str(p, obj.minSamplerHeapReservedRangeWithEmbedded)); + p.PrintKeyValue("minResourceHeapReservedRange", to_hex_str(p, obj.minResourceHeapReservedRange)); + p.PrintKeyValue("samplerDescriptorSize", to_hex_str(p, obj.samplerDescriptorSize)); + p.PrintKeyValue("imageDescriptorSize", to_hex_str(p, obj.imageDescriptorSize)); + p.PrintKeyValue("bufferDescriptorSize", to_hex_str(p, obj.bufferDescriptorSize)); + p.PrintKeyValue("samplerDescriptorAlignment", to_hex_str(p, obj.samplerDescriptorAlignment)); + p.PrintKeyValue("imageDescriptorAlignment", to_hex_str(p, obj.imageDescriptorAlignment)); + p.PrintKeyValue("bufferDescriptorAlignment", to_hex_str(p, obj.bufferDescriptorAlignment)); + p.PrintKeyValue("maxPushDataSize", to_hex_str(p, obj.maxPushDataSize)); + p.PrintKeyValue("imageCaptureReplayOpaqueDataSize", obj.imageCaptureReplayOpaqueDataSize); + p.PrintKeyValue("maxDescriptorHeapEmbeddedSamplers", obj.maxDescriptorHeapEmbeddedSamplers); + p.PrintKeyValue("samplerYcbcrConversionCount", obj.samplerYcbcrConversionCount); + p.PrintKeyBool("sparseDescriptorHeaps", static_cast<bool>(obj.sparseDescriptorHeaps)); + p.PrintKeyBool("protectedDescriptorHeaps", static_cast<bool>(obj.protectedDescriptorHeaps)); +} +void DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(33); + p.PrintKeyValue("tensorDescriptorSize", to_hex_str(p, obj.tensorDescriptorSize)); + p.PrintKeyValue("tensorDescriptorAlignment", to_hex_str(p, obj.tensorDescriptorAlignment)); + p.PrintKeyValue("tensorCaptureReplayOpaqueDataSize", obj.tensorCaptureReplayOpaqueDataSize); +} +void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorIndexingFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(50); p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing)); - p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing)); - p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing)); + p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", + static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing)); + p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", + static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing)); p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing)); p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing)); p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing)); p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing)); - p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing)); - p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing)); - p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing)); - p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind)); + p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", + static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing)); + p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", + static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing)); + p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", + static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing)); + p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind)); p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending)); p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound)); p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount)); p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray)); } -void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer &p, std::string name, const VkPhysicalDeviceDescriptorIndexingProperties &obj) { +void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer& p, std::string name, + const VkPhysicalDeviceDescriptorIndexingProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(52); p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools); - p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative)); p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind)); p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod)); p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers); @@ -1764,24 +5504,35 @@ p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers); p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages); p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages); - p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments", obj.maxPerStageDescriptorUpdateAfterBindInputAttachments); + p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments", + obj.maxPerStageDescriptorUpdateAfterBindInputAttachments); p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers); - p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); + p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", + obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers); - p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); + p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", + obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments); } -void DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(21); + p.PrintKeyBool("deviceAddressCommands", static_cast<bool>(obj.deviceAddressCommands)); +} +void DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(30); p.PrintKeyBool("deviceGeneratedCommands", static_cast<bool>(obj.deviceGeneratedCommands)); p.PrintKeyBool("dynamicGeneratedPipelineLayout", static_cast<bool>(obj.dynamicGeneratedPipelineLayout)); } -void DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT &obj) { +void DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(45); p.PrintKeyValue("maxIndirectPipelineCount", obj.maxIndirectPipelineCount); @@ -1792,30 +5543,35 @@ p.PrintKeyValue("maxIndirectCommandsIndirectStride", obj.maxIndirectCommandsIndirectStride); DumpVkIndirectCommandsInputModeFlagsEXT(p, "supportedIndirectCommandsInputModes", obj.supportedIndirectCommandsInputModes); DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStages", obj.supportedIndirectCommandsShaderStages); - DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesPipelineBinding", obj.supportedIndirectCommandsShaderStagesPipelineBinding); - DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesShaderBinding", obj.supportedIndirectCommandsShaderStagesShaderBinding); + DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesPipelineBinding", + obj.supportedIndirectCommandsShaderStagesPipelineBinding); + DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesShaderBinding", + obj.supportedIndirectCommandsShaderStagesShaderBinding); p.PrintKeyBool("deviceGeneratedCommandsTransformFeedback", static_cast<bool>(obj.deviceGeneratedCommandsTransformFeedback)); - p.PrintKeyBool("deviceGeneratedCommandsMultiDrawIndirectCount", static_cast<bool>(obj.deviceGeneratedCommandsMultiDrawIndirectCount)); + p.PrintKeyBool("deviceGeneratedCommandsMultiDrawIndirectCount", + static_cast<bool>(obj.deviceGeneratedCommandsMultiDrawIndirectCount)); } -void DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(18); p.PrintKeyBool("deviceMemoryReport", static_cast<bool>(obj.deviceMemoryReport)); } -void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDiscardRectanglePropertiesEXT &obj) { +void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceDiscardRectanglePropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyValue("maxDiscardRectangles", obj.maxDiscardRectangles); } -void DumpVkPhysicalDeviceDriverProperties(Printer &p, std::string name, const VkPhysicalDeviceDriverProperties &obj) { +void DumpVkPhysicalDeviceDriverProperties(Printer& p, std::string name, const VkPhysicalDeviceDriverProperties& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(15); + p.SetMinKeyWidth(10); DumpVkDriverId(p, "driverID", obj.driverID); p.PrintKeyString("driverName", obj.driverName); p.PrintKeyString("driverInfo", obj.driverInfo); DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion); } -void DumpVkPhysicalDeviceDrmPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDrmPropertiesEXT &obj) { +void DumpVkPhysicalDeviceDrmPropertiesEXT(Printer& p, std::string name, const VkPhysicalDeviceDrmPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(12); p.PrintKeyBool("hasPrimary", static_cast<bool>(obj.hasPrimary)); @@ -1825,32 +5581,38 @@ p.PrintKeyValue("renderMajor", obj.renderMajor); p.PrintKeyValue("renderMinor", obj.renderMinor); } -void DumpVkPhysicalDeviceDynamicRenderingFeatures(Printer &p, std::string name, const VkPhysicalDeviceDynamicRenderingFeatures &obj) { +void DumpVkPhysicalDeviceDynamicRenderingFeatures(Printer& p, std::string name, + const VkPhysicalDeviceDynamicRenderingFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(16); p.PrintKeyBool("dynamicRendering", static_cast<bool>(obj.dynamicRendering)); } -void DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(Printer &p, std::string name, const VkPhysicalDeviceDynamicRenderingLocalReadFeatures &obj) { +void DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(Printer& p, std::string name, + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyBool("dynamicRenderingLocalRead", static_cast<bool>(obj.dynamicRenderingLocalRead)); } -void DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT &obj) { +void DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(33); p.PrintKeyBool("dynamicRenderingUnusedAttachments", static_cast<bool>(obj.dynamicRenderingUnusedAttachments)); } -void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &obj) { +void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(39); p.PrintKeyBool("extendedDynamicState2", static_cast<bool>(obj.extendedDynamicState2)); p.PrintKeyBool("extendedDynamicState2LogicOp", static_cast<bool>(obj.extendedDynamicState2LogicOp)); p.PrintKeyBool("extendedDynamicState2PatchControlPoints", static_cast<bool>(obj.extendedDynamicState2PatchControlPoints)); } -void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &obj) { +void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(53); - p.PrintKeyBool("extendedDynamicState3TessellationDomainOrigin", static_cast<bool>(obj.extendedDynamicState3TessellationDomainOrigin)); + p.PrintKeyBool("extendedDynamicState3TessellationDomainOrigin", + static_cast<bool>(obj.extendedDynamicState3TessellationDomainOrigin)); p.PrintKeyBool("extendedDynamicState3DepthClampEnable", static_cast<bool>(obj.extendedDynamicState3DepthClampEnable)); p.PrintKeyBool("extendedDynamicState3PolygonMode", static_cast<bool>(obj.extendedDynamicState3PolygonMode)); p.PrintKeyBool("extendedDynamicState3RasterizationSamples", static_cast<bool>(obj.extendedDynamicState3RasterizationSamples)); @@ -1862,48 +5624,74 @@ p.PrintKeyBool("extendedDynamicState3ColorBlendEquation", static_cast<bool>(obj.extendedDynamicState3ColorBlendEquation)); p.PrintKeyBool("extendedDynamicState3ColorWriteMask", static_cast<bool>(obj.extendedDynamicState3ColorWriteMask)); p.PrintKeyBool("extendedDynamicState3RasterizationStream", static_cast<bool>(obj.extendedDynamicState3RasterizationStream)); - p.PrintKeyBool("extendedDynamicState3ConservativeRasterizationMode", static_cast<bool>(obj.extendedDynamicState3ConservativeRasterizationMode)); - p.PrintKeyBool("extendedDynamicState3ExtraPrimitiveOverestimationSize", static_cast<bool>(obj.extendedDynamicState3ExtraPrimitiveOverestimationSize)); + p.PrintKeyBool("extendedDynamicState3ConservativeRasterizationMode", + static_cast<bool>(obj.extendedDynamicState3ConservativeRasterizationMode)); + p.PrintKeyBool("extendedDynamicState3ExtraPrimitiveOverestimationSize", + static_cast<bool>(obj.extendedDynamicState3ExtraPrimitiveOverestimationSize)); p.PrintKeyBool("extendedDynamicState3DepthClipEnable", static_cast<bool>(obj.extendedDynamicState3DepthClipEnable)); p.PrintKeyBool("extendedDynamicState3SampleLocationsEnable", static_cast<bool>(obj.extendedDynamicState3SampleLocationsEnable)); p.PrintKeyBool("extendedDynamicState3ColorBlendAdvanced", static_cast<bool>(obj.extendedDynamicState3ColorBlendAdvanced)); p.PrintKeyBool("extendedDynamicState3ProvokingVertexMode", static_cast<bool>(obj.extendedDynamicState3ProvokingVertexMode)); p.PrintKeyBool("extendedDynamicState3LineRasterizationMode", static_cast<bool>(obj.extendedDynamicState3LineRasterizationMode)); p.PrintKeyBool("extendedDynamicState3LineStippleEnable", static_cast<bool>(obj.extendedDynamicState3LineStippleEnable)); - p.PrintKeyBool("extendedDynamicState3DepthClipNegativeOneToOne", static_cast<bool>(obj.extendedDynamicState3DepthClipNegativeOneToOne)); - p.PrintKeyBool("extendedDynamicState3ViewportWScalingEnable", static_cast<bool>(obj.extendedDynamicState3ViewportWScalingEnable)); + p.PrintKeyBool("extendedDynamicState3DepthClipNegativeOneToOne", + static_cast<bool>(obj.extendedDynamicState3DepthClipNegativeOneToOne)); + p.PrintKeyBool("extendedDynamicState3ViewportWScalingEnable", + static_cast<bool>(obj.extendedDynamicState3ViewportWScalingEnable)); p.PrintKeyBool("extendedDynamicState3ViewportSwizzle", static_cast<bool>(obj.extendedDynamicState3ViewportSwizzle)); p.PrintKeyBool("extendedDynamicState3CoverageToColorEnable", static_cast<bool>(obj.extendedDynamicState3CoverageToColorEnable)); - p.PrintKeyBool("extendedDynamicState3CoverageToColorLocation", static_cast<bool>(obj.extendedDynamicState3CoverageToColorLocation)); - p.PrintKeyBool("extendedDynamicState3CoverageModulationMode", static_cast<bool>(obj.extendedDynamicState3CoverageModulationMode)); - p.PrintKeyBool("extendedDynamicState3CoverageModulationTableEnable", static_cast<bool>(obj.extendedDynamicState3CoverageModulationTableEnable)); - p.PrintKeyBool("extendedDynamicState3CoverageModulationTable", static_cast<bool>(obj.extendedDynamicState3CoverageModulationTable)); + p.PrintKeyBool("extendedDynamicState3CoverageToColorLocation", + static_cast<bool>(obj.extendedDynamicState3CoverageToColorLocation)); + p.PrintKeyBool("extendedDynamicState3CoverageModulationMode", + static_cast<bool>(obj.extendedDynamicState3CoverageModulationMode)); + p.PrintKeyBool("extendedDynamicState3CoverageModulationTableEnable", + static_cast<bool>(obj.extendedDynamicState3CoverageModulationTableEnable)); + p.PrintKeyBool("extendedDynamicState3CoverageModulationTable", + static_cast<bool>(obj.extendedDynamicState3CoverageModulationTable)); p.PrintKeyBool("extendedDynamicState3CoverageReductionMode", static_cast<bool>(obj.extendedDynamicState3CoverageReductionMode)); - p.PrintKeyBool("extendedDynamicState3RepresentativeFragmentTestEnable", static_cast<bool>(obj.extendedDynamicState3RepresentativeFragmentTestEnable)); - p.PrintKeyBool("extendedDynamicState3ShadingRateImageEnable", static_cast<bool>(obj.extendedDynamicState3ShadingRateImageEnable)); + p.PrintKeyBool("extendedDynamicState3RepresentativeFragmentTestEnable", + static_cast<bool>(obj.extendedDynamicState3RepresentativeFragmentTestEnable)); + p.PrintKeyBool("extendedDynamicState3ShadingRateImageEnable", + static_cast<bool>(obj.extendedDynamicState3ShadingRateImageEnable)); } -void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &obj) { +void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(36); p.PrintKeyBool("dynamicPrimitiveTopologyUnrestricted", static_cast<bool>(obj.dynamicPrimitiveTopologyUnrestricted)); } -void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &obj) { +void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("extendedDynamicState", static_cast<bool>(obj.extendedDynamicState)); } -void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceExternalMemoryHostPropertiesEXT &obj) { +void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(31); p.PrintKeyValue("minImportedHostPointerAlignment", to_hex_str(p, obj.minImportedHostPointerAlignment)); } -void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT &obj) { +void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("deviceFault", static_cast<bool>(obj.deviceFault)); p.PrintKeyBool("deviceFaultVendorBinary", static_cast<bool>(obj.deviceFaultVendorBinary)); } -void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, const VkPhysicalDeviceFeatures &obj) { +void DumpVkPhysicalDeviceFaultFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceFaultFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(29); + p.PrintKeyBool("deviceFault", static_cast<bool>(obj.deviceFault)); + p.PrintKeyBool("deviceFaultVendorBinary", static_cast<bool>(obj.deviceFaultVendorBinary)); + p.PrintKeyBool("deviceFaultReportMasked", static_cast<bool>(obj.deviceFaultReportMasked)); + p.PrintKeyBool("deviceFaultDeviceLostOnMasked", static_cast<bool>(obj.deviceFaultDeviceLostOnMasked)); +} +void DumpVkPhysicalDeviceFaultPropertiesKHR(Printer& p, std::string name, const VkPhysicalDeviceFaultPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(19); + p.PrintKeyValue("maxDeviceFaultCount", obj.maxDeviceFaultCount); +} +void DumpVkPhysicalDeviceFeatures(Printer& p, std::string name, const VkPhysicalDeviceFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(39); p.PrintKeyBool("robustBufferAccess", static_cast<bool>(obj.robustBufferAccess)); @@ -1962,7 +5750,7 @@ p.PrintKeyBool("variableMultisampleRate", static_cast<bool>(obj.variableMultisampleRate)); p.PrintKeyBool("inheritedQueries", static_cast<bool>(obj.inheritedQueries)); } -void DumpVkPhysicalDeviceFloatControlsProperties(Printer &p, std::string name, const VkPhysicalDeviceFloatControlsProperties &obj) { +void DumpVkPhysicalDeviceFloatControlsProperties(Printer& p, std::string name, const VkPhysicalDeviceFloatControlsProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(37); DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence); @@ -1983,12 +5771,14 @@ p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32)); p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64)); } -void DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &obj) { +void DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); p.PrintKeyBool("fragmentDensityMapDeferred", static_cast<bool>(obj.fragmentDensityMapDeferred)); } -void DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &obj) { +void DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(41); p.PrintKeyBool("subsampledLoads", static_cast<bool>(obj.subsampledLoads)); @@ -1996,99 +5786,134 @@ p.PrintKeyValue("maxSubsampledArrayLayers", obj.maxSubsampledArrayLayers); p.PrintKeyValue("maxDescriptorSetSubsampledSamplers", obj.maxDescriptorSetSubsampledSamplers); } -void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFragmentDensityMapFeaturesEXT &obj) { +void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(37); p.PrintKeyBool("fragmentDensityMap", static_cast<bool>(obj.fragmentDensityMap)); p.PrintKeyBool("fragmentDensityMapDynamic", static_cast<bool>(obj.fragmentDensityMapDynamic)); p.PrintKeyBool("fragmentDensityMapNonSubsampledImages", static_cast<bool>(obj.fragmentDensityMapNonSubsampledImages)); } -void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceFragmentDensityMapPropertiesEXT &obj) { +void DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(24); + p.PrintKeyBool("fragmentDensityMapOffset", static_cast<bool>(obj.fragmentDensityMapOffset)); +} +void DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& obj) { + ObjectWrapper object{p, name}; + DumpVkExtent2D(p, "fragmentDensityOffsetGranularity", obj.fragmentDensityOffsetGranularity); +} +void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); DumpVkExtent2D(p, "minFragmentDensityTexelSize", obj.minFragmentDensityTexelSize); DumpVkExtent2D(p, "maxFragmentDensityTexelSize", obj.maxFragmentDensityTexelSize); p.PrintKeyBool("fragmentDensityInvocations", static_cast<bool>(obj.fragmentDensityInvocations)); } -void DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR &obj) { +void DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyBool("fragmentShaderBarycentric", static_cast<bool>(obj.fragmentShaderBarycentric)); } -void DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR &obj) { +void DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(47); - p.PrintKeyBool("triStripVertexOrderIndependentOfProvokingVertex", static_cast<bool>(obj.triStripVertexOrderIndependentOfProvokingVertex)); + p.PrintKeyBool("triStripVertexOrderIndependentOfProvokingVertex", + static_cast<bool>(obj.triStripVertexOrderIndependentOfProvokingVertex)); } -void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &obj) { +void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyBool("fragmentShaderSampleInterlock", static_cast<bool>(obj.fragmentShaderSampleInterlock)); p.PrintKeyBool("fragmentShaderPixelInterlock", static_cast<bool>(obj.fragmentShaderPixelInterlock)); p.PrintKeyBool("fragmentShaderShadingRateInterlock", static_cast<bool>(obj.fragmentShaderShadingRateInterlock)); } -void DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR &obj) { +void DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(29); p.PrintKeyBool("pipelineFragmentShadingRate", static_cast<bool>(obj.pipelineFragmentShadingRate)); p.PrintKeyBool("primitiveFragmentShadingRate", static_cast<bool>(obj.primitiveFragmentShadingRate)); p.PrintKeyBool("attachmentFragmentShadingRate", static_cast<bool>(obj.attachmentFragmentShadingRate)); } -void DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR &obj) { +void DumpVkPhysicalDeviceFragmentShadingRateKHR(Printer& p, std::string name, const VkPhysicalDeviceFragmentShadingRateKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkSampleCountFlags(p, "sampleCounts", obj.sampleCounts); + DumpVkExtent2D(p, "fragmentSize", obj.fragmentSize); +} +void DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(52); DumpVkExtent2D(p, "minFragmentShadingRateAttachmentTexelSize", obj.minFragmentShadingRateAttachmentTexelSize); DumpVkExtent2D(p, "maxFragmentShadingRateAttachmentTexelSize", obj.maxFragmentShadingRateAttachmentTexelSize); - p.PrintKeyValue("maxFragmentShadingRateAttachmentTexelSizeAspectRatio", obj.maxFragmentShadingRateAttachmentTexelSizeAspectRatio); - p.PrintKeyBool("primitiveFragmentShadingRateWithMultipleViewports", static_cast<bool>(obj.primitiveFragmentShadingRateWithMultipleViewports)); + p.PrintKeyValue("maxFragmentShadingRateAttachmentTexelSizeAspectRatio", + obj.maxFragmentShadingRateAttachmentTexelSizeAspectRatio); + p.PrintKeyBool("primitiveFragmentShadingRateWithMultipleViewports", + static_cast<bool>(obj.primitiveFragmentShadingRateWithMultipleViewports)); p.PrintKeyBool("layeredShadingRateAttachments", static_cast<bool>(obj.layeredShadingRateAttachments)); p.PrintKeyBool("fragmentShadingRateNonTrivialCombinerOps", static_cast<bool>(obj.fragmentShadingRateNonTrivialCombinerOps)); DumpVkExtent2D(p, "maxFragmentSize", obj.maxFragmentSize); p.PrintKeyValue("maxFragmentSizeAspectRatio", obj.maxFragmentSizeAspectRatio); p.PrintKeyValue("maxFragmentShadingRateCoverageSamples", obj.maxFragmentShadingRateCoverageSamples); DumpVkSampleCountFlagBits(p, "maxFragmentShadingRateRasterizationSamples", obj.maxFragmentShadingRateRasterizationSamples); - p.PrintKeyBool("fragmentShadingRateWithShaderDepthStencilWrites", static_cast<bool>(obj.fragmentShadingRateWithShaderDepthStencilWrites)); + p.PrintKeyBool("fragmentShadingRateWithShaderDepthStencilWrites", + static_cast<bool>(obj.fragmentShadingRateWithShaderDepthStencilWrites)); p.PrintKeyBool("fragmentShadingRateWithSampleMask", static_cast<bool>(obj.fragmentShadingRateWithSampleMask)); p.PrintKeyBool("fragmentShadingRateWithShaderSampleMask", static_cast<bool>(obj.fragmentShadingRateWithShaderSampleMask)); - p.PrintKeyBool("fragmentShadingRateWithConservativeRasterization", static_cast<bool>(obj.fragmentShadingRateWithConservativeRasterization)); - p.PrintKeyBool("fragmentShadingRateWithFragmentShaderInterlock", static_cast<bool>(obj.fragmentShadingRateWithFragmentShaderInterlock)); - p.PrintKeyBool("fragmentShadingRateWithCustomSampleLocations", static_cast<bool>(obj.fragmentShadingRateWithCustomSampleLocations)); + p.PrintKeyBool("fragmentShadingRateWithConservativeRasterization", + static_cast<bool>(obj.fragmentShadingRateWithConservativeRasterization)); + p.PrintKeyBool("fragmentShadingRateWithFragmentShaderInterlock", + static_cast<bool>(obj.fragmentShadingRateWithFragmentShaderInterlock)); + p.PrintKeyBool("fragmentShadingRateWithCustomSampleLocations", + static_cast<bool>(obj.fragmentShadingRateWithCustomSampleLocations)); p.PrintKeyBool("fragmentShadingRateStrictMultiplyCombiner", static_cast<bool>(obj.fragmentShadingRateStrictMultiplyCombiner)); } -void DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFrameBoundaryFeaturesEXT &obj) { +void DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceFrameBoundaryFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(13); p.PrintKeyBool("frameBoundary", static_cast<bool>(obj.frameBoundary)); } -void DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(Printer &p, std::string name, const VkPhysicalDeviceGlobalPriorityQueryFeatures &obj) { +void DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(Printer& p, std::string name, + const VkPhysicalDeviceGlobalPriorityQueryFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(19); p.PrintKeyBool("globalPriorityQuery", static_cast<bool>(obj.globalPriorityQuery)); } -void DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT &obj) { +void DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("graphicsPipelineLibrary", static_cast<bool>(obj.graphicsPipelineLibrary)); } -void DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT &obj) { +void DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(57); p.PrintKeyBool("graphicsPipelineLibraryFastLinking", static_cast<bool>(obj.graphicsPipelineLibraryFastLinking)); - p.PrintKeyBool("graphicsPipelineLibraryIndependentInterpolationDecoration", static_cast<bool>(obj.graphicsPipelineLibraryIndependentInterpolationDecoration)); + p.PrintKeyBool("graphicsPipelineLibraryIndependentInterpolationDecoration", + static_cast<bool>(obj.graphicsPipelineLibraryIndependentInterpolationDecoration)); } -void DumpVkPhysicalDeviceHostImageCopyFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyFeatures &obj) { +void DumpVkPhysicalDeviceHostImageCopyFeatures(Printer& p, std::string name, const VkPhysicalDeviceHostImageCopyFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(13); p.PrintKeyBool("hostImageCopy", static_cast<bool>(obj.hostImageCopy)); } -void DumpVkPhysicalDeviceHostImageCopyProperties(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyProperties &obj) { +void DumpVkPhysicalDeviceHostImageCopyProperties(Printer& p, std::string name, const VkPhysicalDeviceHostImageCopyProperties& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(35); + p.SetMinKeyWidth(31); p.PrintKeyValue("copySrcLayoutCount", obj.copySrcLayoutCount); if (obj.copySrcLayoutCount == 0 || obj.pCopySrcLayouts == nullptr) { p.PrintKeyString("pCopySrcLayouts", "NULL"); } else { - ArrayWrapper arr(p,"pCopySrcLayouts", obj.copySrcLayoutCount); + ArrayWrapper arr(p, "pCopySrcLayouts", obj.copySrcLayoutCount); for (uint32_t i = 0; i < obj.copySrcLayoutCount; i++) { DumpVkImageLayout(p, std::to_string(i), obj.pCopySrcLayouts[i]); } @@ -2097,7 +5922,7 @@ if (obj.copyDstLayoutCount == 0 || obj.pCopyDstLayouts == nullptr) { p.PrintKeyString("pCopyDstLayouts", "NULL"); } else { - ArrayWrapper arr(p,"pCopyDstLayouts", obj.copyDstLayoutCount); + ArrayWrapper arr(p, "pCopyDstLayouts", obj.copyDstLayoutCount); for (uint32_t i = 0; i < obj.copyDstLayoutCount; i++) { DumpVkImageLayout(p, std::to_string(i), obj.pCopyDstLayouts[i]); } @@ -2105,115 +5930,135 @@ p.PrintKeyValue("optimalTilingLayoutUUID", obj.optimalTilingLayoutUUID); p.PrintKeyBool("identicalMemoryTypeRequirements", static_cast<bool>(obj.identicalMemoryTypeRequirements)); } -void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostQueryResetFeatures &obj) { +void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer& p, std::string name, const VkPhysicalDeviceHostQueryResetFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(14); p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset)); } -void DumpVkPhysicalDeviceIDProperties(Printer &p, std::string name, const VkPhysicalDeviceIDProperties &obj) { +void DumpVkPhysicalDeviceIDProperties(Printer& p, std::string name, const VkPhysicalDeviceIDProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(15); p.PrintKeyValue("deviceUUID", obj.deviceUUID); p.PrintKeyValue("driverUUID", obj.driverUUID); - if (obj.deviceLUIDValid) { // special case - p.PrintKeyValue("deviceLUID", obj.deviceLUID); + if (obj.deviceLUIDValid) { // special case + p.PrintKeyValue("deviceLUID", obj.deviceLUID); } p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask); p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid)); } -void DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &obj) { +void DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("image2DViewOf3D", static_cast<bool>(obj.image2DViewOf3D)); p.PrintKeyBool("sampler2DViewOf3D", static_cast<bool>(obj.sampler2DViewOf3D)); } -void DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImageCompressionControlFeaturesEXT &obj) { +void DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImageCompressionControlFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("imageCompressionControl", static_cast<bool>(obj.imageCompressionControl)); } -void DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT &obj) { +void DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(32); p.PrintKeyBool("imageCompressionControlSwapchain", static_cast<bool>(obj.imageCompressionControlSwapchain)); } -void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer &p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures &obj) { +void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer& p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("robustImageAccess", static_cast<bool>(obj.robustImageAccess)); } -void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &obj) { +void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(19); p.PrintKeyBool("imageSlicedViewOf3D", static_cast<bool>(obj.imageSlicedViewOf3D)); } -void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImageViewMinLodFeaturesEXT &obj) { +void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceImageViewMinLodFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(6); p.PrintKeyBool("minLod", static_cast<bool>(obj.minLod)); } -void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name, const VkPhysicalDeviceImagelessFramebufferFeatures &obj) { +void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer& p, std::string name, + const VkPhysicalDeviceImagelessFramebufferFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer)); } -void DumpVkPhysicalDeviceIndexTypeUint8Features(Printer &p, std::string name, const VkPhysicalDeviceIndexTypeUint8Features &obj) { +void DumpVkPhysicalDeviceIndexTypeUint8Features(Printer& p, std::string name, const VkPhysicalDeviceIndexTypeUint8Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(14); p.PrintKeyBool("indexTypeUint8", static_cast<bool>(obj.indexTypeUint8)); } -void DumpVkPhysicalDeviceInlineUniformBlockFeatures(Printer &p, std::string name, const VkPhysicalDeviceInlineUniformBlockFeatures &obj) { +void DumpVkPhysicalDeviceInlineUniformBlockFeatures(Printer& p, std::string name, + const VkPhysicalDeviceInlineUniformBlockFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(50); p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock)); - p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind", static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind)); } -void DumpVkPhysicalDeviceInlineUniformBlockProperties(Printer &p, std::string name, const VkPhysicalDeviceInlineUniformBlockProperties &obj) { +void DumpVkPhysicalDeviceInlineUniformBlockProperties(Printer& p, std::string name, + const VkPhysicalDeviceInlineUniformBlockProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(55); p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize); p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks); - p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); + p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", + obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks); } -void DumpVkPhysicalDeviceLayeredApiPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesKHR &obj) { +void DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(15); - p.PrintKeyValue("vendorID", obj.vendorID); - p.PrintKeyValue("deviceID", obj.deviceID); + p.SetMinKeyWidth(28); + p.PrintKeyBool("internallySynchronizedQueues", static_cast<bool>(obj.internallySynchronizedQueues)); +} +void DumpVkPhysicalDeviceLayeredApiPropertiesKHR(Printer& p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(10); + p.PrintKeyValue("vendorID", to_hex_str(p, obj.vendorID)); + p.PrintKeyValue("deviceID", to_hex_str(p, obj.deviceID)); DumpVkPhysicalDeviceLayeredApiKHR(p, "layeredAPI", obj.layeredAPI); p.PrintKeyString("deviceName", obj.deviceName); } -void DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(Printer &p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesListKHR &obj) { +void DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(Printer& p, std::string name, + const VkPhysicalDeviceLayeredApiPropertiesListKHR& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(29); + p.SetMinKeyWidth(15); p.PrintKeyValue("layeredApiCount", obj.layeredApiCount); if (obj.layeredApiCount == 0 || obj.pLayeredApis == nullptr) { p.PrintKeyString("pLayeredApis", "NULL"); } else { - ArrayWrapper arr(p,"pLayeredApis", obj.layeredApiCount); + ArrayWrapper arr(p, "pLayeredApis", obj.layeredApiCount); for (uint32_t i = 0; i < obj.layeredApiCount; i++) { DumpVkPhysicalDeviceLayeredApiPropertiesKHR(p, std::to_string(i), obj.pLayeredApis[i]); } } } -void DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceLegacyDitheringFeaturesEXT &obj) { +void DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceLegacyDitheringFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(15); p.PrintKeyBool("legacyDithering", static_cast<bool>(obj.legacyDithering)); } -void DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT &obj) { +void DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(22); p.PrintKeyBool("legacyVertexAttributes", static_cast<bool>(obj.legacyVertexAttributes)); } -void DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT &obj) { +void DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); p.PrintKeyBool("nativeUnalignedPerformance", static_cast<bool>(obj.nativeUnalignedPerformance)); } -void DumpVkPhysicalDeviceLimits(Printer &p, std::string name, const VkPhysicalDeviceLimits &obj) { +void DumpVkPhysicalDeviceLimits(Printer& p, std::string name, const VkPhysicalDeviceLimits& obj) { if (p.Type() == OutputType::json) p.ObjectStart("limits"); else @@ -2272,13 +6117,17 @@ p.PrintKeyValue("maxFragmentCombinedOutputResources", obj.maxFragmentCombinedOutputResources); p.PrintKeyValue("maxComputeSharedMemorySize", obj.maxComputeSharedMemorySize); { - ArrayWrapper arr(p,"maxComputeWorkGroupCount", 3); - for (uint32_t i = 0; i < 3; i++) { p.PrintElement(obj.maxComputeWorkGroupCount[i]); } + ArrayWrapper arr(p, "maxComputeWorkGroupCount", 3); + for (uint32_t i = 0; i < 3; i++) { + p.PrintElement(obj.maxComputeWorkGroupCount[i]); + } } p.PrintKeyValue("maxComputeWorkGroupInvocations", obj.maxComputeWorkGroupInvocations); { - ArrayWrapper arr(p,"maxComputeWorkGroupSize", 3); - for (uint32_t i = 0; i < 3; i++) { p.PrintElement(obj.maxComputeWorkGroupSize[i]); } + ArrayWrapper arr(p, "maxComputeWorkGroupSize", 3); + for (uint32_t i = 0; i < 3; i++) { + p.PrintElement(obj.maxComputeWorkGroupSize[i]); + } } p.PrintKeyValue("subPixelPrecisionBits", obj.subPixelPrecisionBits); p.PrintKeyValue("subTexelPrecisionBits", obj.subTexelPrecisionBits); @@ -2289,12 +6138,16 @@ p.PrintKeyValue("maxSamplerAnisotropy", obj.maxSamplerAnisotropy); p.PrintKeyValue("maxViewports", obj.maxViewports); { - ArrayWrapper arr(p,"maxViewportDimensions", 2); - for (uint32_t i = 0; i < 2; i++) { p.PrintElement(obj.maxViewportDimensions[i]); } + ArrayWrapper arr(p, "maxViewportDimensions", 2); + for (uint32_t i = 0; i < 2; i++) { + p.PrintElement(obj.maxViewportDimensions[i]); + } } { - ArrayWrapper arr(p,"viewportBoundsRange", 2); - for (uint32_t i = 0; i < 2; i++) { p.PrintElement(obj.viewportBoundsRange[i]); } + ArrayWrapper arr(p, "viewportBoundsRange", 2); + for (uint32_t i = 0; i < 2; i++) { + p.PrintElement(obj.viewportBoundsRange[i]); + } } p.PrintKeyValue("viewportSubPixelBits", obj.viewportSubPixelBits); p.PrintKeyValue("minMemoryMapAlignment", obj.minMemoryMapAlignment); @@ -2329,12 +6182,16 @@ p.PrintKeyValue("maxCombinedClipAndCullDistances", obj.maxCombinedClipAndCullDistances); p.PrintKeyValue("discreteQueuePriorities", obj.discreteQueuePriorities); { - ArrayWrapper arr(p,"pointSizeRange", 2); - for (uint32_t i = 0; i < 2; i++) { p.PrintElement(obj.pointSizeRange[i]); } + ArrayWrapper arr(p, "pointSizeRange", 2); + for (uint32_t i = 0; i < 2; i++) { + p.PrintElement(obj.pointSizeRange[i]); + } } { - ArrayWrapper arr(p,"lineWidthRange", 2); - for (uint32_t i = 0; i < 2; i++) { p.PrintElement(obj.lineWidthRange[i]); } + ArrayWrapper arr(p, "lineWidthRange", 2); + for (uint32_t i = 0; i < 2; i++) { + p.PrintElement(obj.lineWidthRange[i]); + } } p.PrintKeyValue("pointSizeGranularity", obj.pointSizeGranularity); p.PrintKeyValue("lineWidthGranularity", obj.lineWidthGranularity); @@ -2345,7 +6202,8 @@ p.PrintKeyValue("nonCoherentAtomSize", to_hex_str(p, obj.nonCoherentAtomSize)); p.ObjectEnd(); } -void DumpVkPhysicalDeviceLineRasterizationFeatures(Printer &p, std::string name, const VkPhysicalDeviceLineRasterizationFeatures &obj) { +void DumpVkPhysicalDeviceLineRasterizationFeatures(Printer& p, std::string name, + const VkPhysicalDeviceLineRasterizationFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(24); p.PrintKeyBool("rectangularLines", static_cast<bool>(obj.rectangularLines)); @@ -2355,60 +6213,86 @@ p.PrintKeyBool("stippledBresenhamLines", static_cast<bool>(obj.stippledBresenhamLines)); p.PrintKeyBool("stippledSmoothLines", static_cast<bool>(obj.stippledSmoothLines)); } -void DumpVkPhysicalDeviceLineRasterizationProperties(Printer &p, std::string name, const VkPhysicalDeviceLineRasterizationProperties &obj) { +void DumpVkPhysicalDeviceLineRasterizationProperties(Printer& p, std::string name, + const VkPhysicalDeviceLineRasterizationProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits); } -void DumpVkPhysicalDeviceMaintenance3Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance3Properties &obj) { +void DumpVkPhysicalDeviceMaintenance10FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance10FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(13); + p.PrintKeyBool("maintenance10", static_cast<bool>(obj.maintenance10)); +} +void DumpVkPhysicalDeviceMaintenance10PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance10PropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(48); + p.PrintKeyBool("rgba4OpaqueBlackSwizzled", static_cast<bool>(obj.rgba4OpaqueBlackSwizzled)); + p.PrintKeyBool("resolveSrgbFormatAppliesTransferFunction", static_cast<bool>(obj.resolveSrgbFormatAppliesTransferFunction)); + p.PrintKeyBool("resolveSrgbFormatSupportsTransferFunctionControl", + static_cast<bool>(obj.resolveSrgbFormatSupportsTransferFunctionControl)); +} +void DumpVkPhysicalDeviceMaintenance11FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance11FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(13); + p.PrintKeyBool("maintenance11", static_cast<bool>(obj.maintenance11)); +} +void DumpVkPhysicalDeviceMaintenance3Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance3Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors); p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize)); } -void DumpVkPhysicalDeviceMaintenance4Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Features &obj) { +void DumpVkPhysicalDeviceMaintenance4Features(Printer& p, std::string name, const VkPhysicalDeviceMaintenance4Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(12); p.PrintKeyBool("maintenance4", static_cast<bool>(obj.maintenance4)); } -void DumpVkPhysicalDeviceMaintenance4Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Properties &obj) { +void DumpVkPhysicalDeviceMaintenance4Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance4Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(13); p.PrintKeyValue("maxBufferSize", to_hex_str(p, obj.maxBufferSize)); } -void DumpVkPhysicalDeviceMaintenance5Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Features &obj) { +void DumpVkPhysicalDeviceMaintenance5Features(Printer& p, std::string name, const VkPhysicalDeviceMaintenance5Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(12); p.PrintKeyBool("maintenance5", static_cast<bool>(obj.maintenance5)); } -void DumpVkPhysicalDeviceMaintenance5Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Properties &obj) { +void DumpVkPhysicalDeviceMaintenance5Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance5Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(51); - p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting", static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting)); - p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting", static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting)); + p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting", + static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting)); + p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting", + static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting)); p.PrintKeyBool("depthStencilSwizzleOneSupport", static_cast<bool>(obj.depthStencilSwizzleOneSupport)); p.PrintKeyBool("polygonModePointSize", static_cast<bool>(obj.polygonModePointSize)); - p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram)); + p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram", + static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram)); p.PrintKeyBool("nonStrictWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictWideLinesUseParallelogram)); } -void DumpVkPhysicalDeviceMaintenance6Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Features &obj) { +void DumpVkPhysicalDeviceMaintenance6Features(Printer& p, std::string name, const VkPhysicalDeviceMaintenance6Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(12); p.PrintKeyBool("maintenance6", static_cast<bool>(obj.maintenance6)); } -void DumpVkPhysicalDeviceMaintenance6Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Properties &obj) { +void DumpVkPhysicalDeviceMaintenance6Properties(Printer& p, std::string name, const VkPhysicalDeviceMaintenance6Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(38); p.PrintKeyBool("blockTexelViewCompatibleMultipleLayers", static_cast<bool>(obj.blockTexelViewCompatibleMultipleLayers)); p.PrintKeyValue("maxCombinedImageSamplerDescriptorCount", obj.maxCombinedImageSamplerDescriptorCount); p.PrintKeyBool("fragmentShadingRateClampCombinerInputs", static_cast<bool>(obj.fragmentShadingRateClampCombinerInputs)); } -void DumpVkPhysicalDeviceMaintenance7FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance7FeaturesKHR &obj) { +void DumpVkPhysicalDeviceMaintenance7FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceMaintenance7FeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(12); p.PrintKeyBool("maintenance7", static_cast<bool>(obj.maintenance7)); } -void DumpVkPhysicalDeviceMaintenance7PropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance7PropertiesKHR &obj) { +void DumpVkPhysicalDeviceMaintenance7PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance7PropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(57); p.PrintKeyBool("robustFragmentShadingRateAttachmentAccess", static_cast<bool>(obj.robustFragmentShadingRateAttachmentAccess)); @@ -2416,40 +6300,79 @@ p.PrintKeyValue("maxDescriptorSetTotalUniformBuffersDynamic", obj.maxDescriptorSetTotalUniformBuffersDynamic); p.PrintKeyValue("maxDescriptorSetTotalStorageBuffersDynamic", obj.maxDescriptorSetTotalStorageBuffersDynamic); p.PrintKeyValue("maxDescriptorSetTotalBuffersDynamic", obj.maxDescriptorSetTotalBuffersDynamic); - p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic); - p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic); + p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic", + obj.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic); + p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic", + obj.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic); } -void DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &obj) { +void DumpVkPhysicalDeviceMaintenance8FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceMaintenance8FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(12); + p.PrintKeyBool("maintenance8", static_cast<bool>(obj.maintenance8)); +} +void DumpVkPhysicalDeviceMaintenance9FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceMaintenance9FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(12); + p.PrintKeyBool("maintenance9", static_cast<bool>(obj.maintenance9)); +} +void DumpVkPhysicalDeviceMaintenance9PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceMaintenance9PropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(21); + p.PrintKeyBool("image2DViewOf3DSparse", static_cast<bool>(obj.image2DViewOf3DSparse)); + DumpVkDefaultVertexAttributeValueKHR(p, "defaultVertexAttributeValue", obj.defaultVertexAttributeValue); +} +void DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("memoryMapPlaced", static_cast<bool>(obj.memoryMapPlaced)); p.PrintKeyBool("memoryMapRangePlaced", static_cast<bool>(obj.memoryMapRangePlaced)); p.PrintKeyBool("memoryUnmapReserve", static_cast<bool>(obj.memoryUnmapReserve)); } -void DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &obj) { +void DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyValue("minPlacedMemoryMapAlignment", to_hex_str(p, obj.minPlacedMemoryMapAlignment)); } -void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMemoryBudgetPropertiesEXT &obj) { +void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryBudgetPropertiesEXT& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(14); { - ArrayWrapper arr(p,"heapBudget", 16); - for (uint32_t i = 0; i < 16; i++) { p.PrintElement(obj.heapBudget[i]); } + ArrayWrapper arr(p, "heapBudget", VK_MAX_MEMORY_HEAPS); + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + p.PrintElement(obj.heapBudget[i]); + } } { - ArrayWrapper arr(p,"heapUsage", 16); - for (uint32_t i = 0; i < 16; i++) { p.PrintElement(obj.heapUsage[i]); } + ArrayWrapper arr(p, "heapUsage", VK_MAX_MEMORY_HEAPS); + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + p.PrintElement(obj.heapUsage[i]); + } } } -void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMemoryPriorityFeaturesEXT &obj) { +void DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryDecompressionFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(19); + p.PrintKeyBool("memoryDecompression", static_cast<bool>(obj.memoryDecompression)); +} +void DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryDecompressionPropertiesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(29); + DumpVkMemoryDecompressionMethodFlagsEXT(p, "decompressionMethods", obj.decompressionMethods); + p.PrintKeyValue("maxDecompressionIndirectCount", obj.maxDecompressionIndirectCount); +} +void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMemoryPriorityFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(14); p.PrintKeyBool("memoryPriority", static_cast<bool>(obj.memoryPriority)); } -void DumpVkPhysicalDeviceMeshShaderFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderFeaturesEXT &obj) { +void DumpVkPhysicalDeviceMeshShaderFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceMeshShaderFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(38); p.PrintKeyBool("taskShader", static_cast<bool>(obj.taskShader)); @@ -2458,31 +6381,39 @@ p.PrintKeyBool("primitiveFragmentShadingRateMeshShader", static_cast<bool>(obj.primitiveFragmentShadingRateMeshShader)); p.PrintKeyBool("meshShaderQueries", static_cast<bool>(obj.meshShaderQueries)); } -void DumpVkPhysicalDeviceMeshShaderPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderPropertiesEXT &obj) { +void DumpVkPhysicalDeviceMeshShaderPropertiesEXT(Printer& p, std::string name, const VkPhysicalDeviceMeshShaderPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(37); p.PrintKeyValue("maxTaskWorkGroupTotalCount", obj.maxTaskWorkGroupTotalCount); { - ArrayWrapper arr(p,"maxTaskWorkGroupCount", 3); - for (uint32_t i = 0; i < 3; i++) { p.PrintElement(obj.maxTaskWorkGroupCount[i]); } + ArrayWrapper arr(p, "maxTaskWorkGroupCount", 3); + for (uint32_t i = 0; i < 3; i++) { + p.PrintElement(obj.maxTaskWorkGroupCount[i]); + } } p.PrintKeyValue("maxTaskWorkGroupInvocations", obj.maxTaskWorkGroupInvocations); { - ArrayWrapper arr(p,"maxTaskWorkGroupSize", 3); - for (uint32_t i = 0; i < 3; i++) { p.PrintElement(obj.maxTaskWorkGroupSize[i]); } + ArrayWrapper arr(p, "maxTaskWorkGroupSize", 3); + for (uint32_t i = 0; i < 3; i++) { + p.PrintElement(obj.maxTaskWorkGroupSize[i]); + } } p.PrintKeyValue("maxTaskPayloadSize", obj.maxTaskPayloadSize); p.PrintKeyValue("maxTaskSharedMemorySize", obj.maxTaskSharedMemorySize); p.PrintKeyValue("maxTaskPayloadAndSharedMemorySize", obj.maxTaskPayloadAndSharedMemorySize); p.PrintKeyValue("maxMeshWorkGroupTotalCount", obj.maxMeshWorkGroupTotalCount); { - ArrayWrapper arr(p,"maxMeshWorkGroupCount", 3); - for (uint32_t i = 0; i < 3; i++) { p.PrintElement(obj.maxMeshWorkGroupCount[i]); } + ArrayWrapper arr(p, "maxMeshWorkGroupCount", 3); + for (uint32_t i = 0; i < 3; i++) { + p.PrintElement(obj.maxMeshWorkGroupCount[i]); + } } p.PrintKeyValue("maxMeshWorkGroupInvocations", obj.maxMeshWorkGroupInvocations); { - ArrayWrapper arr(p,"maxMeshWorkGroupSize", 3); - for (uint32_t i = 0; i < 3; i++) { p.PrintElement(obj.maxMeshWorkGroupSize[i]); } + ArrayWrapper arr(p, "maxMeshWorkGroupSize", 3); + for (uint32_t i = 0; i < 3; i++) { + p.PrintElement(obj.maxMeshWorkGroupSize[i]); + } } p.PrintKeyValue("maxMeshSharedMemorySize", obj.maxMeshSharedMemorySize); p.PrintKeyValue("maxMeshPayloadAndSharedMemorySize", obj.maxMeshPayloadAndSharedMemorySize); @@ -2502,70 +6433,77 @@ p.PrintKeyBool("prefersCompactVertexOutput", static_cast<bool>(obj.prefersCompactVertexOutput)); p.PrintKeyBool("prefersCompactPrimitiveOutput", static_cast<bool>(obj.prefersCompactPrimitiveOutput)); } -void DumpVkPhysicalDeviceMultiDrawFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawFeaturesEXT &obj) { +void DumpVkPhysicalDeviceMultiDrawFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceMultiDrawFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(9); p.PrintKeyBool("multiDraw", static_cast<bool>(obj.multiDraw)); } -void DumpVkPhysicalDeviceMultiDrawPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawPropertiesEXT &obj) { +void DumpVkPhysicalDeviceMultiDrawPropertiesEXT(Printer& p, std::string name, const VkPhysicalDeviceMultiDrawPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyValue("maxMultiDrawCount", obj.maxMultiDrawCount); } -void DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT &obj) { +void DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(33); p.PrintKeyBool("multisampledRenderToSingleSampled", static_cast<bool>(obj.multisampledRenderToSingleSampled)); } -void DumpVkPhysicalDeviceMultiviewFeatures(Printer &p, std::string name, const VkPhysicalDeviceMultiviewFeatures &obj) { +void DumpVkPhysicalDeviceMultiviewFeatures(Printer& p, std::string name, const VkPhysicalDeviceMultiviewFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview)); p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader)); p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader)); } -void DumpVkPhysicalDeviceMultiviewProperties(Printer &p, std::string name, const VkPhysicalDeviceMultiviewProperties &obj) { +void DumpVkPhysicalDeviceMultiviewProperties(Printer& p, std::string name, const VkPhysicalDeviceMultiviewProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount); p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex); } -void DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT &obj) { +void DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(21); p.PrintKeyBool("mutableDescriptorType", static_cast<bool>(obj.mutableDescriptorType)); } -void DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceNestedCommandBufferFeaturesEXT &obj) { +void DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyBool("nestedCommandBuffer", static_cast<bool>(obj.nestedCommandBuffer)); p.PrintKeyBool("nestedCommandBufferRendering", static_cast<bool>(obj.nestedCommandBufferRendering)); p.PrintKeyBool("nestedCommandBufferSimultaneousUse", static_cast<bool>(obj.nestedCommandBufferSimultaneousUse)); } -void DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceNestedCommandBufferPropertiesEXT &obj) { +void DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceNestedCommandBufferPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyValue("maxCommandBufferNestingLevel", obj.maxCommandBufferNestingLevel); } -void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT &obj) { +void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(18); p.PrintKeyBool("nonSeamlessCubeMap", static_cast<bool>(obj.nonSeamlessCubeMap)); } -void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceOpacityMicromapFeaturesEXT &obj) { +void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceOpacityMicromapFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(21); p.PrintKeyBool("micromap", static_cast<bool>(obj.micromap)); p.PrintKeyBool("micromapCaptureReplay", static_cast<bool>(obj.micromapCaptureReplay)); p.PrintKeyBool("micromapHostCommands", static_cast<bool>(obj.micromapHostCommands)); } -void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceOpacityMicromapPropertiesEXT &obj) { +void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceOpacityMicromapPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(32); p.PrintKeyValue("maxOpacity2StateSubdivisionLevel", obj.maxOpacity2StateSubdivisionLevel); p.PrintKeyValue("maxOpacity4StateSubdivisionLevel", obj.maxOpacity4StateSubdivisionLevel); } -void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT &obj) { +void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer& p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(11); p.PrintKeyValue("pciDomain", obj.pciDomain); @@ -2573,28 +6511,33 @@ p.PrintKeyValue("pciDevice", obj.pciDevice); p.PrintKeyValue("pciFunction", obj.pciFunction); } -void DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &obj) { +void DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyBool("pageableDeviceLocalMemory", static_cast<bool>(obj.pageableDeviceLocalMemory)); } -void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePerformanceQueryFeaturesKHR &obj) { +void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePerformanceQueryFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(36); p.PrintKeyBool("performanceCounterQueryPools", static_cast<bool>(obj.performanceCounterQueryPools)); p.PrintKeyBool("performanceCounterMultipleQueryPools", static_cast<bool>(obj.performanceCounterMultipleQueryPools)); } -void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer &p, std::string name, const VkPhysicalDevicePerformanceQueryPropertiesKHR &obj) { +void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDevicePerformanceQueryPropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(29); p.PrintKeyBool("allowCommandBufferQueryCopies", static_cast<bool>(obj.allowCommandBufferQueryCopies)); } -void DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePipelineBinaryFeaturesKHR &obj) { +void DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePipelineBinaryFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(16); p.PrintKeyBool("pipelineBinaries", static_cast<bool>(obj.pipelineBinaries)); } -void DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(Printer &p, std::string name, const VkPhysicalDevicePipelineBinaryPropertiesKHR &obj) { +void DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDevicePipelineBinaryPropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(38); p.PrintKeyBool("pipelineBinaryInternalCache", static_cast<bool>(obj.pipelineBinaryInternalCache)); @@ -2603,49 +6546,57 @@ p.PrintKeyBool("pipelineBinaryPrecompiledInternalCache", static_cast<bool>(obj.pipelineBinaryPrecompiledInternalCache)); p.PrintKeyBool("pipelineBinaryCompressedData", static_cast<bool>(obj.pipelineBinaryCompressedData)); } -void DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(Printer &p, std::string name, const VkPhysicalDevicePipelineCreationCacheControlFeatures &obj) { +void DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(Printer& p, std::string name, + const VkPhysicalDevicePipelineCreationCacheControlFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyBool("pipelineCreationCacheControl", static_cast<bool>(obj.pipelineCreationCacheControl)); } -void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj) { +void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(22); p.PrintKeyBool("pipelineExecutableInfo", static_cast<bool>(obj.pipelineExecutableInfo)); } -void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &obj) { +void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyBool("pipelineLibraryGroupHandles", static_cast<bool>(obj.pipelineLibraryGroupHandles)); } -void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePipelinePropertiesFeaturesEXT &obj) { +void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePipelinePropertiesFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyBool("pipelinePropertiesIdentifier", static_cast<bool>(obj.pipelinePropertiesIdentifier)); } -void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer &p, std::string name, const VkPhysicalDevicePipelineProtectedAccessFeatures &obj) { +void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer& p, std::string name, + const VkPhysicalDevicePipelineProtectedAccessFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("pipelineProtectedAccess", static_cast<bool>(obj.pipelineProtectedAccess)); } -void DumpVkPhysicalDevicePipelineRobustnessFeatures(Printer &p, std::string name, const VkPhysicalDevicePipelineRobustnessFeatures &obj) { +void DumpVkPhysicalDevicePipelineRobustnessFeatures(Printer& p, std::string name, + const VkPhysicalDevicePipelineRobustnessFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(18); p.PrintKeyBool("pipelineRobustness", static_cast<bool>(obj.pipelineRobustness)); } -void DumpVkPhysicalDevicePipelineRobustnessProperties(Printer &p, std::string name, const VkPhysicalDevicePipelineRobustnessProperties &obj) { +void DumpVkPhysicalDevicePipelineRobustnessProperties(Printer& p, std::string name, + const VkPhysicalDevicePipelineRobustnessProperties& obj) { ObjectWrapper object{p, name}; DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessStorageBuffers", obj.defaultRobustnessStorageBuffers); DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessUniformBuffers", obj.defaultRobustnessUniformBuffers); DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessVertexInputs", obj.defaultRobustnessVertexInputs); DumpVkPipelineRobustnessImageBehavior(p, "defaultRobustnessImages", obj.defaultRobustnessImages); } -void DumpVkPhysicalDevicePointClippingProperties(Printer &p, std::string name, const VkPhysicalDevicePointClippingProperties &obj) { +void DumpVkPhysicalDevicePointClippingProperties(Printer& p, std::string name, const VkPhysicalDevicePointClippingProperties& obj) { ObjectWrapper object{p, name}; DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior); } #ifdef VK_ENABLE_BETA_EXTENSIONS -void DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePortabilitySubsetFeaturesKHR &obj) { +void DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePortabilitySubsetFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(38); p.PrintKeyBool("constantAlphaColorBlendFactors", static_cast<bool>(obj.constantAlphaColorBlendFactors)); @@ -2666,105 +6617,160 @@ } #endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS -void DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(Printer &p, std::string name, const VkPhysicalDevicePortabilitySubsetPropertiesKHR &obj) { +void DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDevicePortabilitySubsetPropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(36); p.PrintKeyValue("minVertexInputBindingStrideAlignment", obj.minVertexInputBindingStrideAlignment); } #endif // VK_ENABLE_BETA_EXTENSIONS -void DumpVkPhysicalDevicePresentIdFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentIdFeaturesKHR &obj) { +void DumpVkPhysicalDevicePresentId2FeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentId2FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(10); + p.PrintKeyBool("presentId2", static_cast<bool>(obj.presentId2)); +} +void DumpVkPhysicalDevicePresentIdFeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentIdFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(9); p.PrintKeyBool("presentId", static_cast<bool>(obj.presentId)); } -void DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT &obj) { +void DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); p.PrintKeyBool("presentModeFifoLatestReady", static_cast<bool>(obj.presentModeFifoLatestReady)); } -void DumpVkPhysicalDevicePresentWaitFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWaitFeaturesKHR &obj) { +void DumpVkPhysicalDevicePresentTimingFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePresentTimingFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(21); + p.PrintKeyBool("presentTiming", static_cast<bool>(obj.presentTiming)); + p.PrintKeyBool("presentAtAbsoluteTime", static_cast<bool>(obj.presentAtAbsoluteTime)); + p.PrintKeyBool("presentAtRelativeTime", static_cast<bool>(obj.presentAtRelativeTime)); +} +void DumpVkPhysicalDevicePresentWait2FeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentWait2FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(12); + p.PrintKeyBool("presentWait2", static_cast<bool>(obj.presentWait2)); +} +void DumpVkPhysicalDevicePresentWaitFeaturesKHR(Printer& p, std::string name, const VkPhysicalDevicePresentWaitFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(11); p.PrintKeyBool("presentWait", static_cast<bool>(obj.presentWait)); } -void DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &obj) { +void DumpVkPhysicalDevicePrimitiveRestartIndexFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(21); + p.PrintKeyBool("primitiveRestartIndex", static_cast<bool>(obj.primitiveRestartIndex)); +} +void DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(33); p.PrintKeyBool("primitiveTopologyListRestart", static_cast<bool>(obj.primitiveTopologyListRestart)); p.PrintKeyBool("primitiveTopologyPatchListRestart", static_cast<bool>(obj.primitiveTopologyPatchListRestart)); } -void DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT &obj) { +void DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(45); p.PrintKeyBool("primitivesGeneratedQuery", static_cast<bool>(obj.primitivesGeneratedQuery)); - p.PrintKeyBool("primitivesGeneratedQueryWithRasterizerDiscard", static_cast<bool>(obj.primitivesGeneratedQueryWithRasterizerDiscard)); + p.PrintKeyBool("primitivesGeneratedQueryWithRasterizerDiscard", + static_cast<bool>(obj.primitivesGeneratedQueryWithRasterizerDiscard)); p.PrintKeyBool("primitivesGeneratedQueryWithNonZeroStreams", static_cast<bool>(obj.primitivesGeneratedQueryWithNonZeroStreams)); } -void DumpVkPhysicalDevicePrivateDataFeatures(Printer &p, std::string name, const VkPhysicalDevicePrivateDataFeatures &obj) { +void DumpVkPhysicalDevicePrivateDataFeatures(Printer& p, std::string name, const VkPhysicalDevicePrivateDataFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(11); p.PrintKeyBool("privateData", static_cast<bool>(obj.privateData)); } -void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer &p, std::string name, const VkPhysicalDeviceProtectedMemoryFeatures &obj) { +void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer& p, std::string name, const VkPhysicalDeviceProtectedMemoryFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(15); p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory)); } -void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer &p, std::string name, const VkPhysicalDeviceProtectedMemoryProperties &obj) { +void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer& p, std::string name, + const VkPhysicalDeviceProtectedMemoryProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(16); p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault)); } -void DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceProvokingVertexFeaturesEXT &obj) { +void DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceProvokingVertexFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(41); p.PrintKeyBool("provokingVertexLast", static_cast<bool>(obj.provokingVertexLast)); p.PrintKeyBool("transformFeedbackPreservesProvokingVertex", static_cast<bool>(obj.transformFeedbackPreservesProvokingVertex)); } -void DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceProvokingVertexPropertiesEXT &obj) { +void DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceProvokingVertexPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(52); p.PrintKeyBool("provokingVertexModePerPipeline", static_cast<bool>(obj.provokingVertexModePerPipeline)); - p.PrintKeyBool("transformFeedbackPreservesTriangleFanProvokingVertex", static_cast<bool>(obj.transformFeedbackPreservesTriangleFanProvokingVertex)); + p.PrintKeyBool("transformFeedbackPreservesTriangleFanProvokingVertex", + static_cast<bool>(obj.transformFeedbackPreservesTriangleFanProvokingVertex)); } -void DumpVkPhysicalDevicePushDescriptorProperties(Printer &p, std::string name, const VkPhysicalDevicePushDescriptorProperties &obj) { +void DumpVkPhysicalDevicePushDescriptorProperties(Printer& p, std::string name, + const VkPhysicalDevicePushDescriptorProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(18); p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors); } -void DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &obj) { +void DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(33); p.PrintKeyBool("formatRgba10x6WithoutYCbCrSampler", static_cast<bool>(obj.formatRgba10x6WithoutYCbCrSampler)); } -void DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT &obj) { +void DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(41); p.PrintKeyBool("rasterizationOrderColorAttachmentAccess", static_cast<bool>(obj.rasterizationOrderColorAttachmentAccess)); p.PrintKeyBool("rasterizationOrderDepthAttachmentAccess", static_cast<bool>(obj.rasterizationOrderDepthAttachmentAccess)); p.PrintKeyBool("rasterizationOrderStencilAttachmentAccess", static_cast<bool>(obj.rasterizationOrderStencilAttachmentAccess)); } -void DumpVkPhysicalDeviceRayQueryFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayQueryFeaturesKHR &obj) { +void DumpVkPhysicalDeviceRayQueryFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceRayQueryFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(8); p.PrintKeyBool("rayQuery", static_cast<bool>(obj.rayQuery)); } -void DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR &obj) { +void DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(27); + p.PrintKeyBool("rayTracingInvocationReorder", static_cast<bool>(obj.rayTracingInvocationReorder)); +} +void DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT( + Printer& p, std::string name, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(32); + DumpVkRayTracingInvocationReorderModeEXT(p, "rayTracingInvocationReorderReorderingHint", + obj.rayTracingInvocationReorderReorderingHint); + p.PrintKeyValue("maxShaderBindingTableRecordIndex", obj.maxShaderBindingTableRecordIndex); +} +void DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(36); p.PrintKeyBool("rayTracingMaintenance1", static_cast<bool>(obj.rayTracingMaintenance1)); p.PrintKeyBool("rayTracingPipelineTraceRaysIndirect2", static_cast<bool>(obj.rayTracingPipelineTraceRaysIndirect2)); } -void DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayTracingPipelineFeaturesKHR &obj) { +void DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(53); p.PrintKeyBool("rayTracingPipeline", static_cast<bool>(obj.rayTracingPipeline)); - p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplay", static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplay)); - p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplayMixed", static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplayMixed)); + p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplay", + static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplay)); + p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplayMixed", + static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplayMixed)); p.PrintKeyBool("rayTracingPipelineTraceRaysIndirect", static_cast<bool>(obj.rayTracingPipelineTraceRaysIndirect)); p.PrintKeyBool("rayTraversalPrimitiveCulling", static_cast<bool>(obj.rayTraversalPrimitiveCulling)); } -void DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayTracingPipelinePropertiesKHR &obj) { +void DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyValue("shaderGroupHandleSize", obj.shaderGroupHandleSize); @@ -2776,58 +6782,85 @@ p.PrintKeyValue("shaderGroupHandleAlignment", obj.shaderGroupHandleAlignment); p.PrintKeyValue("maxRayHitAttributeSize", obj.maxRayHitAttributeSize); } -void DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR &obj) { +void DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("rayTracingPositionFetch", static_cast<bool>(obj.rayTracingPositionFetch)); } -void DumpVkPhysicalDeviceRobustness2FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceRobustness2FeaturesEXT &obj) { +void DumpVkPhysicalDeviceRobustness2FeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceRobustness2FeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(19); p.PrintKeyBool("robustBufferAccess2", static_cast<bool>(obj.robustBufferAccess2)); p.PrintKeyBool("robustImageAccess2", static_cast<bool>(obj.robustImageAccess2)); p.PrintKeyBool("nullDescriptor", static_cast<bool>(obj.nullDescriptor)); } -void DumpVkPhysicalDeviceRobustness2PropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceRobustness2PropertiesEXT &obj) { +void DumpVkPhysicalDeviceRobustness2PropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceRobustness2PropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(38); p.PrintKeyValue("robustStorageBufferAccessSizeAlignment", to_hex_str(p, obj.robustStorageBufferAccessSizeAlignment)); p.PrintKeyValue("robustUniformBufferAccessSizeAlignment", to_hex_str(p, obj.robustUniformBufferAccessSizeAlignment)); } -void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceSampleLocationsPropertiesEXT &obj) { +void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceSampleLocationsPropertiesEXT& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(32); + p.SetMinKeyWidth(26); DumpVkSampleCountFlags(p, "sampleLocationSampleCounts", obj.sampleLocationSampleCounts); DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize); { - ArrayWrapper arr(p,"sampleLocationCoordinateRange", 2); - for (uint32_t i = 0; i < 2; i++) { p.PrintElement(obj.sampleLocationCoordinateRange[i]); } + ArrayWrapper arr(p, "sampleLocationCoordinateRange", 2); + for (uint32_t i = 0; i < 2; i++) { + p.PrintElement(obj.sampleLocationCoordinateRange[i]); + } } p.PrintKeyValue("sampleLocationSubPixelBits", obj.sampleLocationSubPixelBits); p.PrintKeyBool("variableSampleLocations", static_cast<bool>(obj.variableSampleLocations)); } -void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer &p, std::string name, const VkPhysicalDeviceSamplerFilterMinmaxProperties &obj) { +void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer& p, std::string name, + const VkPhysicalDeviceSamplerFilterMinmaxProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats)); p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping)); } -void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer &p, std::string name, const VkPhysicalDeviceSamplerYcbcrConversionFeatures &obj) { +void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer& p, std::string name, + const VkPhysicalDeviceSamplerYcbcrConversionFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(22); p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion)); } -void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer &p, std::string name, const VkPhysicalDeviceScalarBlockLayoutFeatures &obj) { +void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer& p, std::string name, + const VkPhysicalDeviceScalarBlockLayoutFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout)); } -void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer &p, std::string name, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &obj) { +void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer& p, std::string name, + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts)); } -void DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &obj) { +void DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShader64BitIndexingFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(19); + p.PrintKeyBool("shader64BitIndexing", static_cast<bool>(obj.shader64BitIndexing)); +} +void DumpVkPhysicalDeviceShaderAbortFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceShaderAbortFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(11); + p.PrintKeyBool("shaderAbort", static_cast<bool>(obj.shaderAbort)); +} +void DumpVkPhysicalDeviceShaderAbortPropertiesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderAbortPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(25); + p.PrintKeyValue("maxShaderAbortMessageSize", obj.maxShaderAbortMessageSize); +} +void DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(31); p.PrintKeyBool("shaderBufferFloat16Atomics", static_cast<bool>(obj.shaderBufferFloat16Atomics)); @@ -2843,7 +6876,8 @@ p.PrintKeyBool("shaderImageFloat32AtomicMinMax", static_cast<bool>(obj.shaderImageFloat32AtomicMinMax)); p.PrintKeyBool("sparseImageFloat32AtomicMinMax", static_cast<bool>(obj.sparseImageFloat32AtomicMinMax)); } -void DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &obj) { +void DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyBool("shaderBufferFloat32Atomics", static_cast<bool>(obj.shaderBufferFloat32Atomics)); @@ -2859,166 +6893,268 @@ p.PrintKeyBool("sparseImageFloat32Atomics", static_cast<bool>(obj.sparseImageFloat32Atomics)); p.PrintKeyBool("sparseImageFloat32AtomicAdd", static_cast<bool>(obj.sparseImageFloat32AtomicAdd)); } -void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer &p, std::string name, const VkPhysicalDeviceShaderAtomicInt64Features &obj) { +void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer& p, std::string name, + const VkPhysicalDeviceShaderAtomicInt64Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(24); p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics)); p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics)); } -void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderClockFeaturesKHR &obj) { +void DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderBfloat16FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(31); + p.PrintKeyBool("shaderBFloat16Type", static_cast<bool>(obj.shaderBFloat16Type)); + p.PrintKeyBool("shaderBFloat16DotProduct", static_cast<bool>(obj.shaderBFloat16DotProduct)); + p.PrintKeyBool("shaderBFloat16CooperativeMatrix", static_cast<bool>(obj.shaderBFloat16CooperativeMatrix)); +} +void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceShaderClockFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(19); p.PrintKeyBool("shaderSubgroupClock", static_cast<bool>(obj.shaderSubgroupClock)); p.PrintKeyBool("shaderDeviceClock", static_cast<bool>(obj.shaderDeviceClock)); } -void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(Printer &p, std::string name, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures &obj) { +void DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderConstantDataFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(18); + p.PrintKeyBool("shaderConstantData", static_cast<bool>(obj.shaderConstantData)); +} +void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(30); p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation)); } -void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer &p, std::string name, const VkPhysicalDeviceShaderDrawParametersFeatures &obj) { +void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderDrawParametersFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters)); } -void DumpVkPhysicalDeviceShaderExpectAssumeFeatures(Printer &p, std::string name, const VkPhysicalDeviceShaderExpectAssumeFeatures &obj) { +void DumpVkPhysicalDeviceShaderExpectAssumeFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderExpectAssumeFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(18); p.PrintKeyBool("shaderExpectAssume", static_cast<bool>(obj.shaderExpectAssume)); } -void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer &p, std::string name, const VkPhysicalDeviceShaderFloat16Int8Features &obj) { +void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer& p, std::string name, + const VkPhysicalDeviceShaderFloat16Int8Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(13); p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16)); p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8)); } -void DumpVkPhysicalDeviceShaderFloatControls2Features(Printer &p, std::string name, const VkPhysicalDeviceShaderFloatControls2Features &obj) { +void DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceShaderFloat8FeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(29); + p.PrintKeyBool("shaderFloat8", static_cast<bool>(obj.shaderFloat8)); + p.PrintKeyBool("shaderFloat8CooperativeMatrix", static_cast<bool>(obj.shaderFloat8CooperativeMatrix)); +} +void DumpVkPhysicalDeviceShaderFloatControls2Features(Printer& p, std::string name, + const VkPhysicalDeviceShaderFloatControls2Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("shaderFloatControls2", static_cast<bool>(obj.shaderFloatControls2)); } -void DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &obj) { +void DumpVkPhysicalDeviceShaderFmaFeaturesKHR(Printer& p, std::string name, const VkPhysicalDeviceShaderFmaFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(16); + p.PrintKeyBool("shaderFmaFloat16", static_cast<bool>(obj.shaderFmaFloat16)); + p.PrintKeyBool("shaderFmaFloat32", static_cast<bool>(obj.shaderFmaFloat32)); + p.PrintKeyBool("shaderFmaFloat64", static_cast<bool>(obj.shaderFmaFloat64)); +} +void DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("shaderImageInt64Atomics", static_cast<bool>(obj.shaderImageInt64Atomics)); p.PrintKeyBool("sparseImageInt64Atomics", static_cast<bool>(obj.sparseImageInt64Atomics)); } -void DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(Printer &p, std::string name, const VkPhysicalDeviceShaderIntegerDotProductFeatures &obj) { +void DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderIntegerDotProductFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("shaderIntegerDotProduct", static_cast<bool>(obj.shaderIntegerDotProduct)); } -void DumpVkPhysicalDeviceShaderIntegerDotProductProperties(Printer &p, std::string name, const VkPhysicalDeviceShaderIntegerDotProductProperties &obj) { +void DumpVkPhysicalDeviceShaderIntegerDotProductProperties(Printer& p, std::string name, + const VkPhysicalDeviceShaderIntegerDotProductProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(77); p.PrintKeyBool("integerDotProduct8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct8BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated)); - p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated", static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated)); - p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated", + static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated)); + p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated", + static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated)); + p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated)); p.PrintKeyBool("integerDotProduct16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct16BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated)); p.PrintKeyBool("integerDotProduct32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct32BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated)); p.PrintKeyBool("integerDotProduct64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct64BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); } -void DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &obj) { +void DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderLongVectorFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(10); + p.PrintKeyBool("longVector", static_cast<bool>(obj.longVector)); +} +void DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderLongVectorPropertiesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(19); + p.PrintKeyValue("maxVectorComponents", obj.maxVectorComponents); +} +void DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); p.PrintKeyBool("shaderMaximalReconvergence", static_cast<bool>(obj.shaderMaximalReconvergence)); } -void DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT &obj) { +void DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(22); p.PrintKeyBool("shaderModuleIdentifier", static_cast<bool>(obj.shaderModuleIdentifier)); } -void DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT &obj) { +void DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(39); + p.SetMinKeyWidth(35); p.PrintKeyValue("shaderModuleIdentifierAlgorithmUUID", obj.shaderModuleIdentifierAlgorithmUUID); } -void DumpVkPhysicalDeviceShaderObjectFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderObjectFeaturesEXT &obj) { +void DumpVkPhysicalDeviceShaderObjectFeaturesEXT(Printer& p, std::string name, const VkPhysicalDeviceShaderObjectFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(12); p.PrintKeyBool("shaderObject", static_cast<bool>(obj.shaderObject)); } -void DumpVkPhysicalDeviceShaderObjectPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderObjectPropertiesEXT &obj) { +void DumpVkPhysicalDeviceShaderObjectPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderObjectPropertiesEXT& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(20); + p.SetMinKeyWidth(19); p.PrintKeyValue("shaderBinaryUUID", obj.shaderBinaryUUID); p.PrintKeyValue("shaderBinaryVersion", obj.shaderBinaryVersion); } -void DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderQuadControlFeaturesKHR &obj) { +void DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderQuadControlFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("shaderQuadControl", static_cast<bool>(obj.shaderQuadControl)); } -void DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR &obj) { +void DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(32); p.PrintKeyBool("shaderRelaxedExtendedInstruction", static_cast<bool>(obj.shaderRelaxedExtendedInstruction)); } -void DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT &obj) { +void DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); p.PrintKeyBool("shaderReplicatedComposites", static_cast<bool>(obj.shaderReplicatedComposites)); } -void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer &p, std::string name, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &obj) { +void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes)); } -void DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(Printer &p, std::string name, const VkPhysicalDeviceShaderSubgroupRotateFeatures &obj) { +void DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(25); + p.PrintKeyBool("shaderSubgroupPartitioned", static_cast<bool>(obj.shaderSubgroupPartitioned)); +} +void DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderSubgroupRotateFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(29); p.PrintKeyBool("shaderSubgroupRotate", static_cast<bool>(obj.shaderSubgroupRotate)); p.PrintKeyBool("shaderSubgroupRotateClustered", static_cast<bool>(obj.shaderSubgroupRotateClustered)); } -void DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &obj) { +void DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(32); p.PrintKeyBool("shaderSubgroupUniformControlFlow", static_cast<bool>(obj.shaderSubgroupUniformControlFlow)); } -void DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(Printer &p, std::string name, const VkPhysicalDeviceShaderTerminateInvocationFeatures &obj) { +void DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(Printer& p, std::string name, + const VkPhysicalDeviceShaderTerminateInvocationFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyBool("shaderTerminateInvocation", static_cast<bool>(obj.shaderTerminateInvocation)); } -void DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderTileImageFeaturesEXT &obj) { +void DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderTileImageFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(32); p.PrintKeyBool("shaderTileImageColorReadAccess", static_cast<bool>(obj.shaderTileImageColorReadAccess)); p.PrintKeyBool("shaderTileImageDepthReadAccess", static_cast<bool>(obj.shaderTileImageDepthReadAccess)); p.PrintKeyBool("shaderTileImageStencilReadAccess", static_cast<bool>(obj.shaderTileImageStencilReadAccess)); } -void DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderTileImagePropertiesEXT &obj) { +void DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceShaderTileImagePropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(48); p.PrintKeyBool("shaderTileImageCoherentReadAccelerated", static_cast<bool>(obj.shaderTileImageCoherentReadAccelerated)); - p.PrintKeyBool("shaderTileImageReadSampleFromPixelRateInvocation", static_cast<bool>(obj.shaderTileImageReadSampleFromPixelRateInvocation)); + p.PrintKeyBool("shaderTileImageReadSampleFromPixelRateInvocation", + static_cast<bool>(obj.shaderTileImageReadSampleFromPixelRateInvocation)); p.PrintKeyBool("shaderTileImageReadFromHelperInvocation", static_cast<bool>(obj.shaderTileImageReadFromHelperInvocation)); } -void DumpVkPhysicalDeviceSparseProperties(Printer &p, std::string name, const VkPhysicalDeviceSparseProperties &obj) { +void DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( + Printer& p, std::string name, const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(31); + p.PrintKeyBool("shaderUniformBufferUnsizedArray", static_cast<bool>(obj.shaderUniformBufferUnsizedArray)); +} +void DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(21); + p.PrintKeyBool("shaderUntypedPointers", static_cast<bool>(obj.shaderUntypedPointers)); +} +void DumpVkPhysicalDeviceSparseProperties(Printer& p, std::string name, const VkPhysicalDeviceSparseProperties& obj) { if (p.Type() == OutputType::json) p.ObjectStart("sparseProperties"); else @@ -3031,7 +7167,7 @@ p.PrintKeyBool("residencyNonResidentStrict", static_cast<bool>(obj.residencyNonResidentStrict)); p.ObjectEnd(); } -void DumpVkPhysicalDeviceSubgroupProperties(Printer &p, std::string name, const VkPhysicalDeviceSubgroupProperties &obj) { +void DumpVkPhysicalDeviceSubgroupProperties(Printer& p, std::string name, const VkPhysicalDeviceSubgroupProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyValue("subgroupSize", obj.subgroupSize); @@ -3039,13 +7175,15 @@ DumpVkSubgroupFeatureFlags(p, "supportedOperations", obj.supportedOperations); p.PrintKeyBool("quadOperationsInAllStages", static_cast<bool>(obj.quadOperationsInAllStages)); } -void DumpVkPhysicalDeviceSubgroupSizeControlFeatures(Printer &p, std::string name, const VkPhysicalDeviceSubgroupSizeControlFeatures &obj) { +void DumpVkPhysicalDeviceSubgroupSizeControlFeatures(Printer& p, std::string name, + const VkPhysicalDeviceSubgroupSizeControlFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("subgroupSizeControl", static_cast<bool>(obj.subgroupSizeControl)); p.PrintKeyBool("computeFullSubgroups", static_cast<bool>(obj.computeFullSubgroups)); } -void DumpVkPhysicalDeviceSubgroupSizeControlProperties(Printer &p, std::string name, const VkPhysicalDeviceSubgroupSizeControlProperties &obj) { +void DumpVkPhysicalDeviceSubgroupSizeControlProperties(Printer& p, std::string name, + const VkPhysicalDeviceSubgroupSizeControlProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize); @@ -3053,65 +7191,83 @@ p.PrintKeyValue("maxComputeWorkgroupSubgroups", obj.maxComputeWorkgroupSubgroups); DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages); } -void DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT &obj) { +void DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("subpassMergeFeedback", static_cast<bool>(obj.subpassMergeFeedback)); } -void DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT &obj) { +void DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(21); p.PrintKeyBool("swapchainMaintenance1", static_cast<bool>(obj.swapchainMaintenance1)); } -void DumpVkPhysicalDeviceSynchronization2Features(Printer &p, std::string name, const VkPhysicalDeviceSynchronization2Features &obj) { +void DumpVkPhysicalDeviceSynchronization2Features(Printer& p, std::string name, + const VkPhysicalDeviceSynchronization2Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(16); p.PrintKeyBool("synchronization2", static_cast<bool>(obj.synchronization2)); } -void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &obj) { +void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); p.PrintKeyBool("texelBufferAlignment", static_cast<bool>(obj.texelBufferAlignment)); } -void DumpVkPhysicalDeviceTexelBufferAlignmentProperties(Printer &p, std::string name, const VkPhysicalDeviceTexelBufferAlignmentProperties &obj) { +void DumpVkPhysicalDeviceTexelBufferAlignmentProperties(Printer& p, std::string name, + const VkPhysicalDeviceTexelBufferAlignmentProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(44); p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes)); - p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment)); + p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment", + static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment)); p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes)); - p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment)); + p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment", + static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment)); } -void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(Printer &p, std::string name, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures &obj) { +void DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(25); + p.PrintKeyBool("textureCompressionASTC_3D", static_cast<bool>(obj.textureCompressionASTC_3D)); +} +void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(Printer& p, std::string name, + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); p.PrintKeyBool("textureCompressionASTC_HDR", static_cast<bool>(obj.textureCompressionASTC_HDR)); } -void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer &p, std::string name, const VkPhysicalDeviceTimelineSemaphoreFeatures &obj) { +void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer& p, std::string name, + const VkPhysicalDeviceTimelineSemaphoreFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore)); } -void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer &p, std::string name, const VkPhysicalDeviceTimelineSemaphoreProperties &obj) { +void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer& p, std::string name, + const VkPhysicalDeviceTimelineSemaphoreProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(35); p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference); } -void DumpVkPhysicalDeviceToolProperties(Printer &p, std::string name, const VkPhysicalDeviceToolProperties &obj) { +void DumpVkPhysicalDeviceToolProperties(Printer& p, std::string name, const VkPhysicalDeviceToolProperties& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(16); + p.SetMinKeyWidth(11); p.PrintKeyString("name", obj.name); p.PrintKeyString("version", obj.version); DumpVkToolPurposeFlags(p, "purposes", obj.purposes); p.PrintKeyString("description", obj.description); p.PrintKeyString("layer", obj.layer); } -void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceTransformFeedbackFeaturesEXT &obj) { +void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTransformFeedbackFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("transformFeedback", static_cast<bool>(obj.transformFeedback)); p.PrintKeyBool("geometryStreams", static_cast<bool>(obj.geometryStreams)); } -void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceTransformFeedbackPropertiesEXT &obj) { +void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceTransformFeedbackPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(42); p.PrintKeyValue("maxTransformFeedbackStreams", obj.maxTransformFeedbackStreams); @@ -3125,60 +7281,95 @@ p.PrintKeyBool("transformFeedbackRasterizationStreamSelect", static_cast<bool>(obj.transformFeedbackRasterizationStreamSelect)); p.PrintKeyBool("transformFeedbackDraw", static_cast<bool>(obj.transformFeedbackDraw)); } -void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer &p, std::string name, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures &obj) { +void DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(24); + p.PrintKeyBool("unifiedImageLayouts", static_cast<bool>(obj.unifiedImageLayouts)); + p.PrintKeyBool("unifiedImageLayoutsVideo", static_cast<bool>(obj.unifiedImageLayoutsVideo)); +} +void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer& p, std::string name, + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout)); } -void DumpVkPhysicalDeviceVariablePointersFeatures(Printer &p, std::string name, const VkPhysicalDeviceVariablePointersFeatures &obj) { +void DumpVkPhysicalDeviceVariablePointersFeatures(Printer& p, std::string name, + const VkPhysicalDeviceVariablePointersFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(29); p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer)); p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers)); } -void DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(Printer &p, std::string name, const VkPhysicalDeviceVertexAttributeDivisorFeatures &obj) { +void DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeDivisorFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(38); p.PrintKeyBool("vertexAttributeInstanceRateDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateDivisor)); p.PrintKeyBool("vertexAttributeInstanceRateZeroDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateZeroDivisor)); } -void DumpVkPhysicalDeviceVertexAttributeDivisorProperties(Printer &p, std::string name, const VkPhysicalDeviceVertexAttributeDivisorProperties &obj) { +void DumpVkPhysicalDeviceVertexAttributeDivisorProperties(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeDivisorProperties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor); p.PrintKeyBool("supportsNonZeroFirstInstance", static_cast<bool>(obj.supportsNonZeroFirstInstance)); } -void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &obj) { +void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(22); p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor); } -void DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT &obj) { +void DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(25); p.PrintKeyBool("vertexAttributeRobustness", static_cast<bool>(obj.vertexAttributeRobustness)); } -void DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &obj) { +void DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(23); p.PrintKeyBool("vertexInputDynamicState", static_cast<bool>(obj.vertexInputDynamicState)); } -void DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR &obj) { +void DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(14); + p.PrintKeyBool("videoDecodeVP9", static_cast<bool>(obj.videoDecodeVP9)); +} +void DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(14); p.PrintKeyBool("videoEncodeAV1", static_cast<bool>(obj.videoEncodeAV1)); } -void DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR &obj) { +void DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(23); + p.PrintKeyBool("videoEncodeIntraRefresh", static_cast<bool>(obj.videoEncodeIntraRefresh)); +} +void DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(26); p.PrintKeyBool("videoEncodeQuantizationMap", static_cast<bool>(obj.videoEncodeQuantizationMap)); } -void DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceVideoMaintenance1FeaturesKHR &obj) { +void DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("videoMaintenance1", static_cast<bool>(obj.videoMaintenance1)); } -void DumpVkPhysicalDeviceVulkan11Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Features &obj) { +void DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(Printer& p, std::string name, + const VkPhysicalDeviceVideoMaintenance2FeaturesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(17); + p.PrintKeyBool("videoMaintenance2", static_cast<bool>(obj.videoMaintenance2)); +} +void DumpVkPhysicalDeviceVulkan11Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan11Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(34); p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess)); @@ -3194,13 +7385,13 @@ p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion)); p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters)); } -void DumpVkPhysicalDeviceVulkan11Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Properties &obj) { +void DumpVkPhysicalDeviceVulkan11Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan11Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(33); p.PrintKeyValue("deviceUUID", obj.deviceUUID); p.PrintKeyValue("driverUUID", obj.driverUUID); - if (obj.deviceLUIDValid) { // special case - p.PrintKeyValue("deviceLUID", obj.deviceLUID); + if (obj.deviceLUIDValid) { // special case + p.PrintKeyValue("deviceLUID", obj.deviceLUID); } p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask); p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid)); @@ -3215,7 +7406,7 @@ p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors); p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize)); } -void DumpVkPhysicalDeviceVulkan12Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Features &obj) { +void DumpVkPhysicalDeviceVulkan12Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan12Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(50); p.PrintKeyBool("samplerMirrorClampToEdge", static_cast<bool>(obj.samplerMirrorClampToEdge)); @@ -3229,21 +7420,32 @@ p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8)); p.PrintKeyBool("descriptorIndexing", static_cast<bool>(obj.descriptorIndexing)); p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing)); - p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing)); - p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing)); + p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", + static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing)); + p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", + static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing)); p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing)); p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing)); p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing)); p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing)); - p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing)); - p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing)); - p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing)); - p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind)); - p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind)); + p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", + static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing)); + p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", + static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing)); + p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", + static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing)); + p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind)); p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending)); p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound)); p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount)); @@ -3261,12 +7463,13 @@ p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice)); p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel)); p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope)); - p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains", static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains)); + p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains", + static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains)); p.PrintKeyBool("shaderOutputViewportIndex", static_cast<bool>(obj.shaderOutputViewportIndex)); p.PrintKeyBool("shaderOutputLayer", static_cast<bool>(obj.shaderOutputLayer)); p.PrintKeyBool("subgroupBroadcastDynamicId", static_cast<bool>(obj.subgroupBroadcastDynamicId)); } -void DumpVkPhysicalDeviceVulkan12Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Properties &obj) { +void DumpVkPhysicalDeviceVulkan12Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan12Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(52); DumpVkDriverId(p, "driverID", obj.driverID); @@ -3291,11 +7494,16 @@ p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32)); p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64)); p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools); - p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative)); - p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative)); + p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative", + static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative)); p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind)); p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod)); p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers); @@ -3303,13 +7511,16 @@ p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers); p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages); p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages); - p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments", obj.maxPerStageDescriptorUpdateAfterBindInputAttachments); + p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments", + obj.maxPerStageDescriptorUpdateAfterBindInputAttachments); p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers); - p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); + p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", + obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers); - p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); + p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", + obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments); @@ -3322,12 +7533,13 @@ p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference); DumpVkSampleCountFlags(p, "framebufferIntegerColorSampleCounts", obj.framebufferIntegerColorSampleCounts); } -void DumpVkPhysicalDeviceVulkan13Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Features &obj) { +void DumpVkPhysicalDeviceVulkan13Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan13Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(50); p.PrintKeyBool("robustImageAccess", static_cast<bool>(obj.robustImageAccess)); p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock)); - p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind", static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind)); + p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind", + static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind)); p.PrintKeyBool("pipelineCreationCacheControl", static_cast<bool>(obj.pipelineCreationCacheControl)); p.PrintKeyBool("privateData", static_cast<bool>(obj.privateData)); p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation)); @@ -3341,7 +7553,7 @@ p.PrintKeyBool("shaderIntegerDotProduct", static_cast<bool>(obj.shaderIntegerDotProduct)); p.PrintKeyBool("maintenance4", static_cast<bool>(obj.maintenance4)); } -void DumpVkPhysicalDeviceVulkan13Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Properties &obj) { +void DumpVkPhysicalDeviceVulkan13Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan13Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(77); p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize); @@ -3350,47 +7562,72 @@ DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages); p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize); p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks); - p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); + p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", + obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks); p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks); p.PrintKeyValue("maxInlineUniformTotalSize", obj.maxInlineUniformTotalSize); p.PrintKeyBool("integerDotProduct8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct8BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated)); - p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated", static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated)); - p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated", + static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated)); + p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated", + static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated)); + p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated)); p.PrintKeyBool("integerDotProduct16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct16BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated)); p.PrintKeyBool("integerDotProduct32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct32BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated)); p.PrintKeyBool("integerDotProduct64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitUnsignedAccelerated)); p.PrintKeyBool("integerDotProduct64BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitSignedAccelerated)); - p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated)); - p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated)); + p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", + static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes)); - p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment)); + p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment", + static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment)); p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes)); - p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment)); + p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment", + static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment)); p.PrintKeyValue("maxBufferSize", to_hex_str(p, obj.maxBufferSize)); } -void DumpVkPhysicalDeviceVulkan14Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Features &obj) { +void DumpVkPhysicalDeviceVulkan14Features(Printer& p, std::string name, const VkPhysicalDeviceVulkan14Features& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(38); p.PrintKeyBool("globalPriorityQuery", static_cast<bool>(obj.globalPriorityQuery)); @@ -3415,20 +7652,25 @@ p.PrintKeyBool("hostImageCopy", static_cast<bool>(obj.hostImageCopy)); p.PrintKeyBool("pushDescriptor", static_cast<bool>(obj.pushDescriptor)); } -void DumpVkPhysicalDeviceVulkan14Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Properties &obj) { +void DumpVkPhysicalDeviceVulkan14Properties(Printer& p, std::string name, const VkPhysicalDeviceVulkan14Properties& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(51); p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits); p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor); p.PrintKeyBool("supportsNonZeroFirstInstance", static_cast<bool>(obj.supportsNonZeroFirstInstance)); p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors); - p.PrintKeyBool("dynamicRenderingLocalReadDepthStencilAttachments", static_cast<bool>(obj.dynamicRenderingLocalReadDepthStencilAttachments)); - p.PrintKeyBool("dynamicRenderingLocalReadMultisampledAttachments", static_cast<bool>(obj.dynamicRenderingLocalReadMultisampledAttachments)); - p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting", static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting)); - p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting", static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting)); + p.PrintKeyBool("dynamicRenderingLocalReadDepthStencilAttachments", + static_cast<bool>(obj.dynamicRenderingLocalReadDepthStencilAttachments)); + p.PrintKeyBool("dynamicRenderingLocalReadMultisampledAttachments", + static_cast<bool>(obj.dynamicRenderingLocalReadMultisampledAttachments)); + p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting", + static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting)); + p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting", + static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting)); p.PrintKeyBool("depthStencilSwizzleOneSupport", static_cast<bool>(obj.depthStencilSwizzleOneSupport)); p.PrintKeyBool("polygonModePointSize", static_cast<bool>(obj.polygonModePointSize)); - p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram)); + p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram", + static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram)); p.PrintKeyBool("nonStrictWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictWideLinesUseParallelogram)); p.PrintKeyBool("blockTexelViewCompatibleMultipleLayers", static_cast<bool>(obj.blockTexelViewCompatibleMultipleLayers)); p.PrintKeyValue("maxCombinedImageSamplerDescriptorCount", obj.maxCombinedImageSamplerDescriptorCount); @@ -3441,7 +7683,7 @@ if (obj.copySrcLayoutCount == 0 || obj.pCopySrcLayouts == nullptr) { p.PrintKeyString("pCopySrcLayouts", "NULL"); } else { - ArrayWrapper arr(p,"pCopySrcLayouts", obj.copySrcLayoutCount); + ArrayWrapper arr(p, "pCopySrcLayouts", obj.copySrcLayoutCount); for (uint32_t i = 0; i < obj.copySrcLayoutCount; i++) { DumpVkImageLayout(p, std::to_string(i), obj.pCopySrcLayouts[i]); } @@ -3450,7 +7692,7 @@ if (obj.copyDstLayoutCount == 0 || obj.pCopyDstLayouts == nullptr) { p.PrintKeyString("pCopyDstLayouts", "NULL"); } else { - ArrayWrapper arr(p,"pCopyDstLayouts", obj.copyDstLayoutCount); + ArrayWrapper arr(p, "pCopyDstLayouts", obj.copyDstLayoutCount); for (uint32_t i = 0; i < obj.copyDstLayoutCount; i++) { DumpVkImageLayout(p, std::to_string(i), obj.pCopyDstLayouts[i]); } @@ -3458,74 +7700,108 @@ p.PrintKeyValue("optimalTilingLayoutUUID", obj.optimalTilingLayoutUUID); p.PrintKeyBool("identicalMemoryTypeRequirements", static_cast<bool>(obj.identicalMemoryTypeRequirements)); } -void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer &p, std::string name, const VkPhysicalDeviceVulkanMemoryModelFeatures &obj) { +void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer& p, std::string name, + const VkPhysicalDeviceVulkanMemoryModelFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(45); p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel)); p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope)); - p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains", static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains)); + p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains", + static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains)); } -void DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &obj) { +void DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( + Printer& p, std::string name, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(46); p.PrintKeyBool("workgroupMemoryExplicitLayout", static_cast<bool>(obj.workgroupMemoryExplicitLayout)); - p.PrintKeyBool("workgroupMemoryExplicitLayoutScalarBlockLayout", static_cast<bool>(obj.workgroupMemoryExplicitLayoutScalarBlockLayout)); + p.PrintKeyBool("workgroupMemoryExplicitLayoutScalarBlockLayout", + static_cast<bool>(obj.workgroupMemoryExplicitLayoutScalarBlockLayout)); p.PrintKeyBool("workgroupMemoryExplicitLayout8BitAccess", static_cast<bool>(obj.workgroupMemoryExplicitLayout8BitAccess)); p.PrintKeyBool("workgroupMemoryExplicitLayout16BitAccess", static_cast<bool>(obj.workgroupMemoryExplicitLayout16BitAccess)); } -void DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &obj) { +void DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(21); p.PrintKeyBool("ycbcr2plane444Formats", static_cast<bool>(obj.ycbcr2plane444Formats)); } -void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &obj) { +void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(16); p.PrintKeyBool("ycbcrImageArrays", static_cast<bool>(obj.ycbcrImageArrays)); } -void DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(Printer &p, std::string name, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures &obj) { +void DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(Printer& p, std::string name, + const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(26); + p.PrintKeyBool("zeroInitializeDeviceMemory", static_cast<bool>(obj.zeroInitializeDeviceMemory)); +} +void DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(Printer& p, std::string name, + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(35); p.PrintKeyBool("shaderZeroInitializeWorkgroupMemory", static_cast<bool>(obj.shaderZeroInitializeWorkgroupMemory)); } -void DumpVkQueueFamilyGlobalPriorityProperties(Printer &p, std::string name, const VkQueueFamilyGlobalPriorityProperties &obj) { +void DumpVkPresentTimingSurfaceCapabilitiesEXT(Printer& p, std::string name, const VkPresentTimingSurfaceCapabilitiesEXT& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(14); + p.SetMinKeyWidth(30); + p.PrintKeyBool("presentTimingSupported", static_cast<bool>(obj.presentTimingSupported)); + p.PrintKeyBool("presentAtAbsoluteTimeSupported", static_cast<bool>(obj.presentAtAbsoluteTimeSupported)); + p.PrintKeyBool("presentAtRelativeTimeSupported", static_cast<bool>(obj.presentAtRelativeTimeSupported)); + DumpVkPresentStageFlagsEXT(p, "presentStageQueries", obj.presentStageQueries); +} +void DumpVkQueueFamilyGlobalPriorityProperties(Printer& p, std::string name, const VkQueueFamilyGlobalPriorityProperties& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(13); p.PrintKeyValue("priorityCount", obj.priorityCount); - ArrayWrapper arr(p,"priorities", obj.priorityCount); + ArrayWrapper arr(p, "priorities", obj.priorityCount); for (uint32_t i = 0; i < obj.priorityCount; i++) { - if (p.Type() == OutputType::json) - p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i])); - else - p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i])); + if (p.Type() == OutputType::json) + p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i])); + else + p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i])); } } -void DumpVkQueueFamilyQueryResultStatusPropertiesKHR(Printer &p, std::string name, const VkQueueFamilyQueryResultStatusPropertiesKHR &obj) { +void DumpVkQueueFamilyOptimalImageTransferGranularityPropertiesKHR( + Printer& p, std::string name, const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkExtent3D(p, "optimalImageTransferGranularity", obj.optimalImageTransferGranularity); +} +void DumpVkQueueFamilyOwnershipTransferPropertiesKHR(Printer& p, std::string name, + const VkQueueFamilyOwnershipTransferPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(35); + p.PrintKeyValue("optimalImageTransferToQueueFamilies", obj.optimalImageTransferToQueueFamilies); +} +void DumpVkQueueFamilyQueryResultStatusPropertiesKHR(Printer& p, std::string name, + const VkQueueFamilyQueryResultStatusPropertiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(24); p.PrintKeyBool("queryResultStatusSupport", static_cast<bool>(obj.queryResultStatusSupport)); } -void DumpVkQueueFamilyVideoPropertiesKHR(Printer &p, std::string name, const VkQueueFamilyVideoPropertiesKHR &obj) { +void DumpVkQueueFamilyVideoPropertiesKHR(Printer& p, std::string name, const VkQueueFamilyVideoPropertiesKHR& obj) { ObjectWrapper object{p, name}; DumpVkVideoCodecOperationFlagsKHR(p, "videoCodecOperations", obj.videoCodecOperations); } -void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSharedPresentSurfaceCapabilitiesKHR &obj) { +void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer& p, std::string name, const VkSharedPresentSurfaceCapabilitiesKHR& obj) { ObjectWrapper object{p, name}; DumpVkImageUsageFlags(p, "sharedPresentSupportedUsageFlags", obj.sharedPresentSupportedUsageFlags); } -void DumpVkSubpassResolvePerformanceQueryEXT(Printer &p, std::string name, const VkSubpassResolvePerformanceQueryEXT &obj) { +void DumpVkSubpassResolvePerformanceQueryEXT(Printer& p, std::string name, const VkSubpassResolvePerformanceQueryEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(7); p.PrintKeyBool("optimal", static_cast<bool>(obj.optimal)); } #ifdef VK_USE_PLATFORM_WIN32_KHR -void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer &p, std::string name, const VkSurfaceCapabilitiesFullScreenExclusiveEXT &obj) { +void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer& p, std::string name, + const VkSurfaceCapabilitiesFullScreenExclusiveEXT& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); p.PrintKeyBool("fullScreenExclusiveSupported", static_cast<bool>(obj.fullScreenExclusiveSupported)); } #endif // VK_USE_PLATFORM_WIN32_KHR -void DumpVkSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceCapabilitiesKHR &obj) { +void DumpVkSurfaceCapabilitiesKHR(Printer& p, std::string name, const VkSurfaceCapabilitiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(19); p.PrintKeyValue("minImageCount", obj.minImageCount); @@ -3539,53 +7815,298 @@ DumpVkCompositeAlphaFlagsKHR(p, "supportedCompositeAlpha", obj.supportedCompositeAlpha); DumpVkImageUsageFlags(p, "supportedUsageFlags", obj.supportedUsageFlags); } -void DumpVkSurfaceFormatKHR(Printer &p, std::string name, const VkSurfaceFormatKHR &obj) { +void DumpVkSurfaceCapabilitiesPresentId2KHR(Printer& p, std::string name, const VkSurfaceCapabilitiesPresentId2KHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(19); + p.PrintKeyBool("presentId2Supported", static_cast<bool>(obj.presentId2Supported)); +} +void DumpVkSurfaceCapabilitiesPresentWait2KHR(Printer& p, std::string name, const VkSurfaceCapabilitiesPresentWait2KHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(21); + p.PrintKeyBool("presentWait2Supported", static_cast<bool>(obj.presentWait2Supported)); +} +void DumpVkSurfaceFormatKHR(Printer& p, std::string name, const VkSurfaceFormatKHR& obj) { ObjectWrapper object{p, name}; DumpVkFormat(p, "format", obj.format); DumpVkColorSpaceKHR(p, "colorSpace", obj.colorSpace); } -void DumpVkSurfacePresentModeCompatibilityEXT(Printer &p, std::string name, const VkSurfacePresentModeCompatibilityEXT &obj) { +void DumpVkSurfacePresentModeCompatibilityKHR(Printer& p, std::string name, const VkSurfacePresentModeCompatibilityKHR& obj) { ObjectWrapper object{p, name}; - p.SetMinKeyWidth(31); + p.SetMinKeyWidth(16); p.PrintKeyValue("presentModeCount", obj.presentModeCount); if (obj.presentModeCount == 0 || obj.pPresentModes == nullptr) { p.PrintKeyString("pPresentModes", "NULL"); } else { - ArrayWrapper arr(p,"pPresentModes", obj.presentModeCount); + ArrayWrapper arr(p, "pPresentModes", obj.presentModeCount); for (uint32_t i = 0; i < obj.presentModeCount; i++) { DumpVkPresentModeKHR(p, std::to_string(i), obj.pPresentModes[i]); } } } -void DumpVkSurfacePresentScalingCapabilitiesEXT(Printer &p, std::string name, const VkSurfacePresentScalingCapabilitiesEXT &obj) { +void DumpVkSurfacePresentScalingCapabilitiesKHR(Printer& p, std::string name, const VkSurfacePresentScalingCapabilitiesKHR& obj) { ObjectWrapper object{p, name}; - DumpVkPresentScalingFlagsEXT(p, "supportedPresentScaling", obj.supportedPresentScaling); - DumpVkPresentGravityFlagsEXT(p, "supportedPresentGravityX", obj.supportedPresentGravityX); - DumpVkPresentGravityFlagsEXT(p, "supportedPresentGravityY", obj.supportedPresentGravityY); + DumpVkPresentScalingFlagsKHR(p, "supportedPresentScaling", obj.supportedPresentScaling); + DumpVkPresentGravityFlagsKHR(p, "supportedPresentGravityX", obj.supportedPresentGravityX); + DumpVkPresentGravityFlagsKHR(p, "supportedPresentGravityY", obj.supportedPresentGravityY); DumpVkExtent2D(p, "minScaledImageExtent", obj.minScaledImageExtent); DumpVkExtent2D(p, "maxScaledImageExtent", obj.maxScaledImageExtent); } -void DumpVkSurfaceProtectedCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceProtectedCapabilitiesKHR &obj) { +void DumpVkSurfaceProtectedCapabilitiesKHR(Printer& p, std::string name, const VkSurfaceProtectedCapabilitiesKHR& obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(17); p.PrintKeyBool("supportsProtected", static_cast<bool>(obj.supportsProtected)); } +void DumpVkVideoCapabilitiesKHR(Printer& p, std::string name, const VkVideoCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(33); + DumpVkVideoCapabilityFlagsKHR(p, "flags", obj.flags); + p.PrintKeyValue("minBitstreamBufferOffsetAlignment", to_hex_str(p, obj.minBitstreamBufferOffsetAlignment)); + p.PrintKeyValue("minBitstreamBufferSizeAlignment", to_hex_str(p, obj.minBitstreamBufferSizeAlignment)); + DumpVkExtent2D(p, "pictureAccessGranularity", obj.pictureAccessGranularity); + DumpVkExtent2D(p, "minCodedExtent", obj.minCodedExtent); + DumpVkExtent2D(p, "maxCodedExtent", obj.maxCodedExtent); + p.PrintKeyValue("maxDpbSlots", obj.maxDpbSlots); + p.PrintKeyValue("maxActiveReferencePictures", obj.maxActiveReferencePictures); + DumpVkExtensionProperties(p, "stdHeaderVersion", obj.stdHeaderVersion); +} +void DumpVkVideoDecodeAV1CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeAV1CapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoAV1Level(p, "maxLevel", obj.maxLevel); +} +void DumpVkVideoDecodeAV1ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeAV1ProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(16); + DumpStdVideoAV1Profile(p, "stdProfile", obj.stdProfile); + p.PrintKeyBool("filmGrainSupport", static_cast<bool>(obj.filmGrainSupport)); +} +void DumpVkVideoDecodeCapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkVideoDecodeCapabilityFlagsKHR(p, "flags", obj.flags); +} +void DumpVkVideoDecodeH264CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeH264CapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoH264LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc); + DumpVkOffset2D(p, "fieldOffsetGranularity", obj.fieldOffsetGranularity); +} +void DumpVkVideoDecodeH264ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeH264ProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoH264ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc); + DumpVkVideoDecodeH264PictureLayoutFlagBitsKHR(p, "pictureLayout", obj.pictureLayout); +} +void DumpVkVideoDecodeH265CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeH265CapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoH265LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc); +} +void DumpVkVideoDecodeH265ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeH265ProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoH265ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc); +} +void DumpVkVideoDecodeUsageInfoKHR(Printer& p, std::string name, const VkVideoDecodeUsageInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkVideoDecodeUsageFlagsKHR(p, "videoUsageHints", obj.videoUsageHints); +} +void DumpVkVideoDecodeVP9CapabilitiesKHR(Printer& p, std::string name, const VkVideoDecodeVP9CapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoVP9Level(p, "maxLevel", obj.maxLevel); +} +void DumpVkVideoDecodeVP9ProfileInfoKHR(Printer& p, std::string name, const VkVideoDecodeVP9ProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoVP9Profile(p, "stdProfile", obj.stdProfile); +} +void DumpVkVideoEncodeAV1CapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeAV1CapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(45); + DumpVkVideoEncodeAV1CapabilityFlagsKHR(p, "flags", obj.flags); + DumpStdVideoAV1Level(p, "maxLevel", obj.maxLevel); + DumpVkExtent2D(p, "codedPictureAlignment", obj.codedPictureAlignment); + DumpVkExtent2D(p, "maxTiles", obj.maxTiles); + DumpVkExtent2D(p, "minTileSize", obj.minTileSize); + DumpVkExtent2D(p, "maxTileSize", obj.maxTileSize); + DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(p, "superblockSizes", obj.superblockSizes); + p.PrintKeyValue("maxSingleReferenceCount", obj.maxSingleReferenceCount); + p.PrintKeyValue("singleReferenceNameMask", obj.singleReferenceNameMask); + p.PrintKeyValue("maxUnidirectionalCompoundReferenceCount", obj.maxUnidirectionalCompoundReferenceCount); + p.PrintKeyValue("maxUnidirectionalCompoundGroup1ReferenceCount", obj.maxUnidirectionalCompoundGroup1ReferenceCount); + p.PrintKeyValue("unidirectionalCompoundReferenceNameMask", obj.unidirectionalCompoundReferenceNameMask); + p.PrintKeyValue("maxBidirectionalCompoundReferenceCount", obj.maxBidirectionalCompoundReferenceCount); + p.PrintKeyValue("maxBidirectionalCompoundGroup1ReferenceCount", obj.maxBidirectionalCompoundGroup1ReferenceCount); + p.PrintKeyValue("maxBidirectionalCompoundGroup2ReferenceCount", obj.maxBidirectionalCompoundGroup2ReferenceCount); + p.PrintKeyValue("bidirectionalCompoundReferenceNameMask", obj.bidirectionalCompoundReferenceNameMask); + p.PrintKeyValue("maxTemporalLayerCount", obj.maxTemporalLayerCount); + p.PrintKeyValue("maxSpatialLayerCount", obj.maxSpatialLayerCount); + p.PrintKeyValue("maxOperatingPoints", obj.maxOperatingPoints); + p.PrintKeyValue("minQIndex", obj.minQIndex); + p.PrintKeyValue("maxQIndex", obj.maxQIndex); + p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames)); + p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames)); + DumpVkVideoEncodeAV1StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags); +} +void DumpVkVideoEncodeAV1ProfileInfoKHR(Printer& p, std::string name, const VkVideoEncodeAV1ProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoAV1Profile(p, "stdProfile", obj.stdProfile); +} +void DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(14); + p.PrintKeyValue("minQIndexDelta", obj.minQIndexDelta); + p.PrintKeyValue("maxQIndexDelta", obj.maxQIndexDelta); +} +void DumpVkVideoEncodeCapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(20); + DumpVkVideoEncodeCapabilityFlagsKHR(p, "flags", obj.flags); + DumpVkVideoEncodeRateControlModeFlagsKHR(p, "rateControlModes", obj.rateControlModes); + p.PrintKeyValue("maxRateControlLayers", obj.maxRateControlLayers); + p.PrintKeyValue("maxBitrate", obj.maxBitrate); + p.PrintKeyValue("maxQualityLevels", obj.maxQualityLevels); + DumpVkExtent2D(p, "encodeInputPictureGranularity", obj.encodeInputPictureGranularity); + DumpVkVideoEncodeFeedbackFlagsKHR(p, "supportedEncodeFeedbackFlags", obj.supportedEncodeFeedbackFlags); +} +void DumpVkVideoEncodeH264CapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeH264CapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(32); + DumpVkVideoEncodeH264CapabilityFlagsKHR(p, "flags", obj.flags); + DumpStdVideoH264LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc); + p.PrintKeyValue("maxSliceCount", obj.maxSliceCount); + p.PrintKeyValue("maxPPictureL0ReferenceCount", obj.maxPPictureL0ReferenceCount); + p.PrintKeyValue("maxBPictureL0ReferenceCount", obj.maxBPictureL0ReferenceCount); + p.PrintKeyValue("maxL1ReferenceCount", obj.maxL1ReferenceCount); + p.PrintKeyValue("maxTemporalLayerCount", obj.maxTemporalLayerCount); + p.PrintKeyBool("expectDyadicTemporalLayerPattern", static_cast<bool>(obj.expectDyadicTemporalLayerPattern)); + p.PrintKeyValue("minQp", obj.minQp); + p.PrintKeyValue("maxQp", obj.maxQp); + p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames)); + p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames)); + DumpVkVideoEncodeH264StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags); +} +void DumpVkVideoEncodeH264ProfileInfoKHR(Printer& p, std::string name, const VkVideoEncodeH264ProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoH264ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc); +} +void DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeH264QuantizationMapCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(10); + p.PrintKeyValue("minQpDelta", obj.minQpDelta); + p.PrintKeyValue("maxQpDelta", obj.maxQpDelta); +} +void DumpVkVideoEncodeH265CapabilitiesKHR(Printer& p, std::string name, const VkVideoEncodeH265CapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(35); + DumpVkVideoEncodeH265CapabilityFlagsKHR(p, "flags", obj.flags); + DumpStdVideoH265LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc); + p.PrintKeyValue("maxSliceSegmentCount", obj.maxSliceSegmentCount); + DumpVkExtent2D(p, "maxTiles", obj.maxTiles); + DumpVkVideoEncodeH265CtbSizeFlagsKHR(p, "ctbSizes", obj.ctbSizes); + DumpVkVideoEncodeH265TransformBlockSizeFlagsKHR(p, "transformBlockSizes", obj.transformBlockSizes); + p.PrintKeyValue("maxPPictureL0ReferenceCount", obj.maxPPictureL0ReferenceCount); + p.PrintKeyValue("maxBPictureL0ReferenceCount", obj.maxBPictureL0ReferenceCount); + p.PrintKeyValue("maxL1ReferenceCount", obj.maxL1ReferenceCount); + p.PrintKeyValue("maxSubLayerCount", obj.maxSubLayerCount); + p.PrintKeyBool("expectDyadicTemporalSubLayerPattern", static_cast<bool>(obj.expectDyadicTemporalSubLayerPattern)); + p.PrintKeyValue("minQp", obj.minQp); + p.PrintKeyValue("maxQp", obj.maxQp); + p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames)); + p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames)); + DumpVkVideoEncodeH265StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags); +} +void DumpVkVideoEncodeH265ProfileInfoKHR(Printer& p, std::string name, const VkVideoEncodeH265ProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpStdVideoH265ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc); +} +void DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeH265QuantizationMapCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(10); + p.PrintKeyValue("minQpDelta", obj.minQpDelta); + p.PrintKeyValue("maxQpDelta", obj.maxQpDelta); +} +void DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeIntraRefreshCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(39); + DumpVkVideoEncodeIntraRefreshModeFlagsKHR(p, "intraRefreshModes", obj.intraRefreshModes); + p.PrintKeyValue("maxIntraRefreshCycleDuration", obj.maxIntraRefreshCycleDuration); + p.PrintKeyValue("maxIntraRefreshActiveReferencePictures", obj.maxIntraRefreshActiveReferencePictures); + p.PrintKeyBool("partitionIndependentIntraRefreshRegions", static_cast<bool>(obj.partitionIndependentIntraRefreshRegions)); + p.PrintKeyBool("nonRectangularIntraRefreshRegions", static_cast<bool>(obj.nonRectangularIntraRefreshRegions)); +} +void DumpVkVideoEncodeProfileRgbConversionInfoVALVE(Printer& p, std::string name, + const VkVideoEncodeProfileRgbConversionInfoVALVE& obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(26); + p.PrintKeyBool("performEncodeRgbConversion", static_cast<bool>(obj.performEncodeRgbConversion)); +} +void DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(Printer& p, std::string name, + const VkVideoEncodeQuantizationMapCapabilitiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkExtent2D(p, "maxQuantizationMapExtent", obj.maxQuantizationMapExtent); +} +void DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(Printer& p, std::string name, + const VkVideoEncodeRgbConversionCapabilitiesVALVE& obj) { + ObjectWrapper object{p, name}; + DumpVkVideoEncodeRgbModelConversionFlagsVALVE(p, "rgbModels", obj.rgbModels); + DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(p, "rgbRanges", obj.rgbRanges); + DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "xChromaOffsets", obj.xChromaOffsets); + DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "yChromaOffsets", obj.yChromaOffsets); +} +void DumpVkVideoEncodeUsageInfoKHR(Printer& p, std::string name, const VkVideoEncodeUsageInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkVideoEncodeUsageFlagsKHR(p, "videoUsageHints", obj.videoUsageHints); + DumpVkVideoEncodeContentFlagsKHR(p, "videoContentHints", obj.videoContentHints); + DumpVkVideoEncodeTuningModeKHR(p, "tuningMode", obj.tuningMode); +} +void DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(Printer& p, std::string name, + const VkVideoFormatAV1QuantizationMapPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(p, "compatibleSuperblockSizes", obj.compatibleSuperblockSizes); +} +void DumpVkVideoFormatH265QuantizationMapPropertiesKHR(Printer& p, std::string name, + const VkVideoFormatH265QuantizationMapPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkVideoEncodeH265CtbSizeFlagsKHR(p, "compatibleCtbSizes", obj.compatibleCtbSizes); +} +void DumpVkVideoFormatPropertiesKHR(Printer& p, std::string name, const VkVideoFormatPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkFormat(p, "format", obj.format); + DumpVkComponentMapping(p, "componentMapping", obj.componentMapping); + DumpVkImageCreateFlags(p, "imageCreateFlags", obj.imageCreateFlags); + DumpVkImageType(p, "imageType", obj.imageType); + DumpVkImageTiling(p, "imageTiling", obj.imageTiling); + DumpVkImageUsageFlags(p, "imageUsageFlags", obj.imageUsageFlags); +} +void DumpVkVideoFormatQuantizationMapPropertiesKHR(Printer& p, std::string name, + const VkVideoFormatQuantizationMapPropertiesKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkExtent2D(p, "quantizationMapTexelSize", obj.quantizationMapTexelSize); +} +void DumpVkVideoProfileInfoKHR(Printer& p, std::string name, const VkVideoProfileInfoKHR& obj) { + ObjectWrapper object{p, name}; + DumpVkVideoCodecOperationFlagBitsKHR(p, "videoCodecOperation", obj.videoCodecOperation); + DumpVkVideoChromaSubsamplingFlagsKHR(p, "chromaSubsampling", obj.chromaSubsampling); + DumpVkVideoComponentBitDepthFlagsKHR(p, "lumaBitDepth", obj.lumaBitDepth); + DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", obj.chromaBitDepth); +} struct phys_device_props2_chain { phys_device_props2_chain() = default; - phys_device_props2_chain(const phys_device_props2_chain &) = delete; - phys_device_props2_chain& operator=(const phys_device_props2_chain &) = delete; - phys_device_props2_chain(phys_device_props2_chain &&) = delete; - phys_device_props2_chain& operator=(phys_device_props2_chain &&) = delete; + phys_device_props2_chain(const phys_device_props2_chain&) = delete; + phys_device_props2_chain& operator=(const phys_device_props2_chain&) = delete; + phys_device_props2_chain(phys_device_props2_chain&&) = delete; + phys_device_props2_chain& operator=(phys_device_props2_chain&&) = delete; void* start_of_chain = nullptr; VkPhysicalDeviceAccelerationStructurePropertiesKHR PhysicalDeviceAccelerationStructurePropertiesKHR{}; VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT PhysicalDeviceBlendOperationAdvancedPropertiesEXT{}; VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR PhysicalDeviceComputeShaderDerivativesPropertiesKHR{}; VkPhysicalDeviceConservativeRasterizationPropertiesEXT PhysicalDeviceConservativeRasterizationPropertiesEXT{}; VkPhysicalDeviceCooperativeMatrixPropertiesKHR PhysicalDeviceCooperativeMatrixPropertiesKHR{}; + VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR PhysicalDeviceCopyMemoryIndirectPropertiesKHR{}; VkPhysicalDeviceCustomBorderColorPropertiesEXT PhysicalDeviceCustomBorderColorPropertiesEXT{}; VkPhysicalDeviceDepthStencilResolveProperties PhysicalDeviceDepthStencilResolveProperties{}; VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT{}; VkPhysicalDeviceDescriptorBufferPropertiesEXT PhysicalDeviceDescriptorBufferPropertiesEXT{}; + VkPhysicalDeviceDescriptorHeapPropertiesEXT PhysicalDeviceDescriptorHeapPropertiesEXT{}; + VkPhysicalDeviceDescriptorHeapTensorPropertiesARM PhysicalDeviceDescriptorHeapTensorPropertiesARM{}; VkPhysicalDeviceDescriptorIndexingProperties PhysicalDeviceDescriptorIndexingProperties{}; VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT{}; VkPhysicalDeviceDiscardRectanglePropertiesEXT PhysicalDeviceDiscardRectanglePropertiesEXT{}; @@ -3593,8 +8114,10 @@ VkPhysicalDeviceDrmPropertiesEXT PhysicalDeviceDrmPropertiesEXT{}; VkPhysicalDeviceExtendedDynamicState3PropertiesEXT PhysicalDeviceExtendedDynamicState3PropertiesEXT{}; VkPhysicalDeviceExternalMemoryHostPropertiesEXT PhysicalDeviceExternalMemoryHostPropertiesEXT{}; + VkPhysicalDeviceFaultPropertiesKHR PhysicalDeviceFaultPropertiesKHR{}; VkPhysicalDeviceFloatControlsProperties PhysicalDeviceFloatControlsProperties{}; VkPhysicalDeviceFragmentDensityMap2PropertiesEXT PhysicalDeviceFragmentDensityMap2PropertiesEXT{}; + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT{}; VkPhysicalDeviceFragmentDensityMapPropertiesEXT PhysicalDeviceFragmentDensityMapPropertiesEXT{}; VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR PhysicalDeviceFragmentShaderBarycentricPropertiesKHR{}; VkPhysicalDeviceFragmentShadingRatePropertiesKHR PhysicalDeviceFragmentShadingRatePropertiesKHR{}; @@ -3608,12 +8131,15 @@ std::vector<VkPhysicalDeviceLayeredApiPropertiesKHR> VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis; VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT PhysicalDeviceLegacyVertexAttributesPropertiesEXT{}; VkPhysicalDeviceLineRasterizationProperties PhysicalDeviceLineRasterizationProperties{}; + VkPhysicalDeviceMaintenance10PropertiesKHR PhysicalDeviceMaintenance10PropertiesKHR{}; VkPhysicalDeviceMaintenance3Properties PhysicalDeviceMaintenance3Properties{}; VkPhysicalDeviceMaintenance4Properties PhysicalDeviceMaintenance4Properties{}; VkPhysicalDeviceMaintenance5Properties PhysicalDeviceMaintenance5Properties{}; VkPhysicalDeviceMaintenance6Properties PhysicalDeviceMaintenance6Properties{}; VkPhysicalDeviceMaintenance7PropertiesKHR PhysicalDeviceMaintenance7PropertiesKHR{}; + VkPhysicalDeviceMaintenance9PropertiesKHR PhysicalDeviceMaintenance9PropertiesKHR{}; VkPhysicalDeviceMapMemoryPlacedPropertiesEXT PhysicalDeviceMapMemoryPlacedPropertiesEXT{}; + VkPhysicalDeviceMemoryDecompressionPropertiesEXT PhysicalDeviceMemoryDecompressionPropertiesEXT{}; VkPhysicalDeviceMeshShaderPropertiesEXT PhysicalDeviceMeshShaderPropertiesEXT{}; VkPhysicalDeviceMultiDrawPropertiesEXT PhysicalDeviceMultiDrawPropertiesEXT{}; VkPhysicalDeviceMultiviewProperties PhysicalDeviceMultiviewProperties{}; @@ -3630,11 +8156,14 @@ VkPhysicalDeviceProtectedMemoryProperties PhysicalDeviceProtectedMemoryProperties{}; VkPhysicalDeviceProvokingVertexPropertiesEXT PhysicalDeviceProvokingVertexPropertiesEXT{}; VkPhysicalDevicePushDescriptorProperties PhysicalDevicePushDescriptorProperties{}; + VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT PhysicalDeviceRayTracingInvocationReorderPropertiesEXT{}; VkPhysicalDeviceRayTracingPipelinePropertiesKHR PhysicalDeviceRayTracingPipelinePropertiesKHR{}; - VkPhysicalDeviceRobustness2PropertiesEXT PhysicalDeviceRobustness2PropertiesEXT{}; + VkPhysicalDeviceRobustness2PropertiesKHR PhysicalDeviceRobustness2PropertiesKHR{}; VkPhysicalDeviceSampleLocationsPropertiesEXT PhysicalDeviceSampleLocationsPropertiesEXT{}; VkPhysicalDeviceSamplerFilterMinmaxProperties PhysicalDeviceSamplerFilterMinmaxProperties{}; + VkPhysicalDeviceShaderAbortPropertiesKHR PhysicalDeviceShaderAbortPropertiesKHR{}; VkPhysicalDeviceShaderIntegerDotProductProperties PhysicalDeviceShaderIntegerDotProductProperties{}; + VkPhysicalDeviceShaderLongVectorPropertiesEXT PhysicalDeviceShaderLongVectorPropertiesEXT{}; VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT PhysicalDeviceShaderModuleIdentifierPropertiesEXT{}; VkPhysicalDeviceShaderObjectPropertiesEXT PhysicalDeviceShaderObjectPropertiesEXT{}; VkPhysicalDeviceShaderTileImagePropertiesEXT PhysicalDeviceShaderTileImagePropertiesEXT{}; @@ -3651,45 +8180,69 @@ VkPhysicalDeviceVulkan14Properties PhysicalDeviceVulkan14Properties{}; std::vector<VkImageLayout> VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts; std::vector<VkImageLayout> VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts; - void initialize_chain(AppInstance &inst, AppGpu &gpu , bool show_promoted_structs) noexcept { - PhysicalDeviceAccelerationStructurePropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; - PhysicalDeviceBlendOperationAdvancedPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; - PhysicalDeviceComputeShaderDerivativesPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; - PhysicalDeviceConservativeRasterizationPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; + void initialize_chain(AppInstance& inst, AppGpu& gpu, bool show_promoted_structs) noexcept { + PhysicalDeviceAccelerationStructurePropertiesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; + PhysicalDeviceBlendOperationAdvancedPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; + PhysicalDeviceComputeShaderDerivativesPropertiesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; + PhysicalDeviceConservativeRasterizationPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; PhysicalDeviceCooperativeMatrixPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + PhysicalDeviceCopyMemoryIndirectPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR; PhysicalDeviceCustomBorderColorPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; PhysicalDeviceDepthStencilResolveProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; - PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; PhysicalDeviceDescriptorBufferPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + PhysicalDeviceDescriptorHeapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT; + PhysicalDeviceDescriptorHeapTensorPropertiesARM.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM; PhysicalDeviceDescriptorIndexingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; - PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; PhysicalDeviceDiscardRectanglePropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; PhysicalDeviceDriverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; PhysicalDeviceDrmPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; - PhysicalDeviceExtendedDynamicState3PropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; + PhysicalDeviceExtendedDynamicState3PropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; PhysicalDeviceExternalMemoryHostPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; + PhysicalDeviceFaultPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR; PhysicalDeviceFloatControlsProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; - PhysicalDeviceFragmentDensityMap2PropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; + PhysicalDeviceFragmentDensityMap2PropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; + PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; PhysicalDeviceFragmentDensityMapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; - PhysicalDeviceFragmentShaderBarycentricPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; - PhysicalDeviceFragmentShadingRatePropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; - PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; + PhysicalDeviceFragmentShaderBarycentricPropertiesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; + PhysicalDeviceFragmentShadingRatePropertiesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; PhysicalDeviceHostImageCopyProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; PhysicalDeviceIDProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; PhysicalDeviceInlineUniformBlockProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; PhysicalDeviceLayeredApiPropertiesListKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; - PhysicalDeviceLegacyVertexAttributesPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; + PhysicalDeviceLegacyVertexAttributesPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; PhysicalDeviceLineRasterizationProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; + PhysicalDeviceMaintenance10PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR; PhysicalDeviceMaintenance3Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; PhysicalDeviceMaintenance4Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; PhysicalDeviceMaintenance5Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; PhysicalDeviceMaintenance6Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; PhysicalDeviceMaintenance7PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; + PhysicalDeviceMaintenance9PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; PhysicalDeviceMapMemoryPlacedPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; + PhysicalDeviceMemoryDecompressionPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT; PhysicalDeviceMeshShaderPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; PhysicalDeviceMultiDrawPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; PhysicalDeviceMultiviewProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; - PhysicalDeviceNestedCommandBufferPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; + PhysicalDeviceNestedCommandBufferPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; PhysicalDeviceOpacityMicromapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; PhysicalDevicePCIBusInfoPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; PhysicalDevicePerformanceQueryPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; @@ -3702,12 +8255,18 @@ PhysicalDeviceProtectedMemoryProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; PhysicalDeviceProvokingVertexPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; PhysicalDevicePushDescriptorProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; + PhysicalDeviceRayTracingInvocationReorderPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT; PhysicalDeviceRayTracingPipelinePropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; - PhysicalDeviceRobustness2PropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT; + PhysicalDeviceRobustness2PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; PhysicalDeviceSampleLocationsPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; PhysicalDeviceSamplerFilterMinmaxProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; - PhysicalDeviceShaderIntegerDotProductProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; - PhysicalDeviceShaderModuleIdentifierPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; + PhysicalDeviceShaderAbortPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR; + PhysicalDeviceShaderIntegerDotProductProperties.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; + PhysicalDeviceShaderLongVectorPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT; + PhysicalDeviceShaderModuleIdentifierPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; PhysicalDeviceShaderObjectPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; PhysicalDeviceShaderTileImagePropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; PhysicalDeviceSubgroupProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; @@ -3715,8 +8274,10 @@ PhysicalDeviceTexelBufferAlignmentProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; PhysicalDeviceTimelineSemaphoreProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; PhysicalDeviceTransformFeedbackPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; - PhysicalDeviceVertexAttributeDivisorProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; - PhysicalDeviceVertexAttributeDivisorPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; + PhysicalDeviceVertexAttributeDivisorProperties.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; + PhysicalDeviceVertexAttributeDivisorPropertiesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; PhysicalDeviceVulkan11Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; PhysicalDeviceVulkan12Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; PhysicalDeviceVulkan13Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; @@ -3732,24 +8293,31 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceConservativeRasterizationPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceCooperativeMatrixPropertiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceCopyMemoryIndirectPropertiesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceCustomBorderColorPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDepthStencilResolveProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorBufferPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorHeapPropertiesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorHeapTensorPropertiesARM)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorIndexingProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDiscardRectanglePropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDriverProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDrmPropertiesEXT)); @@ -3757,11 +8325,16 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceExtendedDynamicState3PropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceExternalMemoryHostPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_FAULT_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFaultPropertiesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFloatControlsProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentDensityMap2PropertiesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentDensityMapPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)) @@ -3770,47 +8343,54 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentShadingRatePropertiesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceHostImageCopyProperties)); - if ((inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) - || inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME) - || inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + if ((inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) || + inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME) || + inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceIDProperties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceInlineUniformBlockProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceLayeredApiPropertiesListKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceLegacyVertexAttributesPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceLineRasterizationProperties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_3_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_10_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance10PropertiesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_3_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance3Properties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance4Properties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance5Properties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance6Properties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance7PropertiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance9PropertiesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMapMemoryPlacedPropertiesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMemoryDecompressionPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MESH_SHADER_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMeshShaderPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTI_DRAW_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMultiDrawPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMultiviewProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceNestedCommandBufferPropertiesEXT)); @@ -3822,11 +8402,11 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePerformanceQueryPropertiesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_BINARY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineBinaryPropertiesKHR)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineRobustnessProperties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_2_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_2_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePointClippingProperties)); #ifdef VK_ENABLE_BETA_EXTENSIONS if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)) @@ -3836,21 +8416,28 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceProtectedMemoryProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceProvokingVertexPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePushDescriptorProperties)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRayTracingInvocationReorderPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRayTracingPipelinePropertiesKHR)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRobustness2PropertiesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRobustness2PropertiesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSampleLocationsPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSamplerFilterMinmaxProperties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ABORT_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderAbortPropertiesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderIntegerDotProductProperties)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderLongVectorPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderModuleIdentifierPropertiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_OBJECT_EXTENSION_NAME)) @@ -3859,19 +8446,19 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderTileImagePropertiesEXT)); if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSubgroupProperties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSubgroupSizeControlProperties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTexelBufferAlignmentProperties)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTimelineSemaphoreProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTransformFeedbackPropertiesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVertexAttributeDivisorProperties)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVertexAttributeDivisorPropertiesEXT)); @@ -3885,358 +8472,741 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVulkan14Properties)); if (!chain_members.empty()) { - for(size_t i = 0; i < chain_members.size() - 1; i++){ + for (size_t i = 0; i < chain_members.size() - 1; i++) { chain_members[i]->pNext = chain_members[i + 1]; } start_of_chain = chain_members[0]; } } }; -void setup_phys_device_props2_chain(VkPhysicalDeviceProperties2& start, std::unique_ptr<phys_device_props2_chain>& chain, AppInstance &inst,AppGpu &gpu,bool show_promoted_structs){ +void setup_phys_device_props2_chain(VkPhysicalDeviceProperties2& start, std::unique_ptr<phys_device_props2_chain>& chain, + AppInstance& inst, AppGpu& gpu, bool show_promoted_structs) { chain = std::unique_ptr<phys_device_props2_chain>(new phys_device_props2_chain()); - chain->initialize_chain(inst,gpu,show_promoted_structs); + chain->initialize_chain(inst, gpu, show_promoted_structs); start.pNext = chain->start_of_chain; }; -void chain_iterator_phys_device_props2(Printer &p, AppInstance &inst, AppGpu &gpu, bool show_promoted_structs, void * place) { +void chain_iterator_phys_device_props2(Printer& p, AppInstance& inst, AppGpu& gpu, bool show_promoted_structs, const void* place) { while (place) { - struct VkBaseOutStructure *structure = (struct VkBaseOutStructure *)place; + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; p.SetSubHeader(); if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR) { - VkPhysicalDeviceAccelerationStructurePropertiesKHR* props = (VkPhysicalDeviceAccelerationStructurePropertiesKHR*)structure; - DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(p, "VkPhysicalDeviceAccelerationStructurePropertiesKHR", *props); + const VkPhysicalDeviceAccelerationStructurePropertiesKHR* props = + (const VkPhysicalDeviceAccelerationStructurePropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceAccelerationStructurePropertiesKHR"; + DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT) { - VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* props = (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*)structure; - DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(p, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT", *props); + const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* props = + (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT"; + DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR) { - VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* props = (VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*)structure; - DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(p, "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR", *props); + const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* props = + (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR"; + DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT) { - VkPhysicalDeviceConservativeRasterizationPropertiesEXT* props = (VkPhysicalDeviceConservativeRasterizationPropertiesEXT*)structure; - DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(p, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT", *props); + const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* props = + (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceConservativeRasterizationPropertiesEXT"; + DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR) { - VkPhysicalDeviceCooperativeMatrixPropertiesKHR* props = (VkPhysicalDeviceCooperativeMatrixPropertiesKHR*)structure; - DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(p, "VkPhysicalDeviceCooperativeMatrixPropertiesKHR", *props); + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* props = + (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceCooperativeMatrixPropertiesKHR"; + DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR) { + const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* props = + (const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME) + ? "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR" + : ("VkPhysicalDeviceCopyMemoryIndirectPropertiesNV"); + DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(p, "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT) { - VkPhysicalDeviceCustomBorderColorPropertiesEXT* props = (VkPhysicalDeviceCustomBorderColorPropertiesEXT*)structure; - DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(p, "VkPhysicalDeviceCustomBorderColorPropertiesEXT", *props); + const VkPhysicalDeviceCustomBorderColorPropertiesEXT* props = + (const VkPhysicalDeviceCustomBorderColorPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceCustomBorderColorPropertiesEXT"; + DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES) { - VkPhysicalDeviceDepthStencilResolveProperties* props = (VkPhysicalDeviceDepthStencilResolveProperties*)structure; - DumpVkPhysicalDeviceDepthStencilResolveProperties(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceDepthStencilResolveProperties":"VkPhysicalDeviceDepthStencilResolvePropertiesKHR", *props); + const VkPhysicalDeviceDepthStencilResolveProperties* props = + (const VkPhysicalDeviceDepthStencilResolveProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDepthStencilResolveProperties" + : ("VkPhysicalDeviceDepthStencilResolvePropertiesKHR"); + DumpVkPhysicalDeviceDepthStencilResolveProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDepthStencilResolvePropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceDepthStencilResolveProperties(p, "VkPhysicalDeviceDepthStencilResolvePropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT) { - VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* props = (VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*)structure; - DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(p, "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT", *props); + const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* props = + (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT"; + DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT) { - VkPhysicalDeviceDescriptorBufferPropertiesEXT* props = (VkPhysicalDeviceDescriptorBufferPropertiesEXT*)structure; - DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(p, "VkPhysicalDeviceDescriptorBufferPropertiesEXT", *props); + const VkPhysicalDeviceDescriptorBufferPropertiesEXT* props = + (const VkPhysicalDeviceDescriptorBufferPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceDescriptorBufferPropertiesEXT"; + DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT) { + const VkPhysicalDeviceDescriptorHeapPropertiesEXT* props = + (const VkPhysicalDeviceDescriptorHeapPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceDescriptorHeapPropertiesEXT"; + DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM) { + const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM* props = + (const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM*)structure; + const char* name = "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM"; + DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES) { - VkPhysicalDeviceDescriptorIndexingProperties* props = (VkPhysicalDeviceDescriptorIndexingProperties*)structure; - DumpVkPhysicalDeviceDescriptorIndexingProperties(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceDescriptorIndexingProperties":"VkPhysicalDeviceDescriptorIndexingPropertiesEXT", *props); + const VkPhysicalDeviceDescriptorIndexingProperties* props = + (const VkPhysicalDeviceDescriptorIndexingProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDescriptorIndexingProperties" + : ("VkPhysicalDeviceDescriptorIndexingPropertiesEXT"); + DumpVkPhysicalDeviceDescriptorIndexingProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDescriptorIndexingPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceDescriptorIndexingProperties(p, "VkPhysicalDeviceDescriptorIndexingPropertiesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT) { - VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* props = (VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*)structure; - DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(p, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT", *props); + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* props = + (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT"; + DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT) { - VkPhysicalDeviceDiscardRectanglePropertiesEXT* props = (VkPhysicalDeviceDiscardRectanglePropertiesEXT*)structure; - DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(p, "VkPhysicalDeviceDiscardRectanglePropertiesEXT", *props); + const VkPhysicalDeviceDiscardRectanglePropertiesEXT* props = + (const VkPhysicalDeviceDiscardRectanglePropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceDiscardRectanglePropertiesEXT"; + DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES) { - VkPhysicalDeviceDriverProperties* props = (VkPhysicalDeviceDriverProperties*)structure; - DumpVkPhysicalDeviceDriverProperties(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceDriverProperties":"VkPhysicalDeviceDriverPropertiesKHR", *props); + const VkPhysicalDeviceDriverProperties* props = (const VkPhysicalDeviceDriverProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDriverProperties" + : ("VkPhysicalDeviceDriverPropertiesKHR"); + DumpVkPhysicalDeviceDriverProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDriverPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceDriverProperties(p, "VkPhysicalDeviceDriverPropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT) { - VkPhysicalDeviceDrmPropertiesEXT* props = (VkPhysicalDeviceDrmPropertiesEXT*)structure; - DumpVkPhysicalDeviceDrmPropertiesEXT(p, "VkPhysicalDeviceDrmPropertiesEXT", *props); + const VkPhysicalDeviceDrmPropertiesEXT* props = (const VkPhysicalDeviceDrmPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceDrmPropertiesEXT"; + DumpVkPhysicalDeviceDrmPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT) { - VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* props = (VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*)structure; - DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(p, "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT", *props); + const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* props = + (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT"; + DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT) { - VkPhysicalDeviceExternalMemoryHostPropertiesEXT* props = (VkPhysicalDeviceExternalMemoryHostPropertiesEXT*)structure; - DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(p, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT", *props); + const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* props = + (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceExternalMemoryHostPropertiesEXT"; + DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR) { + const VkPhysicalDeviceFaultPropertiesKHR* props = (const VkPhysicalDeviceFaultPropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceFaultPropertiesKHR"; + DumpVkPhysicalDeviceFaultPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES) { - VkPhysicalDeviceFloatControlsProperties* props = (VkPhysicalDeviceFloatControlsProperties*)structure; - DumpVkPhysicalDeviceFloatControlsProperties(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceFloatControlsProperties":"VkPhysicalDeviceFloatControlsPropertiesKHR", *props); + const VkPhysicalDeviceFloatControlsProperties* props = (const VkPhysicalDeviceFloatControlsProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceFloatControlsProperties" + : ("VkPhysicalDeviceFloatControlsPropertiesKHR"); + DumpVkPhysicalDeviceFloatControlsProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFloatControlsPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceFloatControlsProperties(p, "VkPhysicalDeviceFloatControlsPropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT) { - VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* props = (VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*)structure; - DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(p, "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT", *props); + const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* props = + (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT"; + DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT) { + const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* props = + (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) + ? "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT" + : ("VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM"); + DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( + p, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT) { - VkPhysicalDeviceFragmentDensityMapPropertiesEXT* props = (VkPhysicalDeviceFragmentDensityMapPropertiesEXT*)structure; - DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(p, "VkPhysicalDeviceFragmentDensityMapPropertiesEXT", *props); + const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* props = + (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceFragmentDensityMapPropertiesEXT"; + DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR) { - VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* props = (VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*)structure; - DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(p, "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR", *props); + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* props = + (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR"; + DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR) { - VkPhysicalDeviceFragmentShadingRatePropertiesKHR* props = (VkPhysicalDeviceFragmentShadingRatePropertiesKHR*)structure; - DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(p, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR", *props); + const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* props = + (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceFragmentShadingRatePropertiesKHR"; + DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT) { - VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* props = (VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*)structure; - DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(p, "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT", *props); + const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* props = + (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT"; + DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES) { - VkPhysicalDeviceHostImageCopyProperties* props = (VkPhysicalDeviceHostImageCopyProperties*)structure; - DumpVkPhysicalDeviceHostImageCopyProperties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceHostImageCopyProperties":"VkPhysicalDeviceHostImageCopyPropertiesEXT", *props); + const VkPhysicalDeviceHostImageCopyProperties* props = (const VkPhysicalDeviceHostImageCopyProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceHostImageCopyProperties" + : ("VkPhysicalDeviceHostImageCopyPropertiesEXT"); + DumpVkPhysicalDeviceHostImageCopyProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostImageCopyPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceHostImageCopyProperties(p, "VkPhysicalDeviceHostImageCopyPropertiesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES) { - VkPhysicalDeviceIDProperties* props = (VkPhysicalDeviceIDProperties*)structure; - DumpVkPhysicalDeviceIDProperties(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDeviceIDProperties":"VkPhysicalDeviceIDPropertiesKHR", *props); + const VkPhysicalDeviceIDProperties* props = (const VkPhysicalDeviceIDProperties*)structure; + const char* name = + gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceIDProperties" : ("VkPhysicalDeviceIDPropertiesKHR"); + DumpVkPhysicalDeviceIDProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIDPropertiesKHR") != 0 && + inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceIDProperties(p, "VkPhysicalDeviceIDPropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES) { - VkPhysicalDeviceInlineUniformBlockProperties* props = (VkPhysicalDeviceInlineUniformBlockProperties*)structure; - DumpVkPhysicalDeviceInlineUniformBlockProperties(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceInlineUniformBlockProperties":"VkPhysicalDeviceInlineUniformBlockPropertiesEXT", *props); + const VkPhysicalDeviceInlineUniformBlockProperties* props = + (const VkPhysicalDeviceInlineUniformBlockProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceInlineUniformBlockProperties" + : ("VkPhysicalDeviceInlineUniformBlockPropertiesEXT"); + DumpVkPhysicalDeviceInlineUniformBlockProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceInlineUniformBlockPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceInlineUniformBlockProperties(p, "VkPhysicalDeviceInlineUniformBlockPropertiesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR) { - VkPhysicalDeviceLayeredApiPropertiesListKHR* props = (VkPhysicalDeviceLayeredApiPropertiesListKHR*)structure; - DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(p, "VkPhysicalDeviceLayeredApiPropertiesListKHR", *props); + const VkPhysicalDeviceLayeredApiPropertiesListKHR* props = + (const VkPhysicalDeviceLayeredApiPropertiesListKHR*)structure; + const char* name = "VkPhysicalDeviceLayeredApiPropertiesListKHR"; + DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT) { - VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* props = (VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*)structure; - DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(p, "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT", *props); + const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* props = + (const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT"; + DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES) { - VkPhysicalDeviceLineRasterizationProperties* props = (VkPhysicalDeviceLineRasterizationProperties*)structure; - DumpVkPhysicalDeviceLineRasterizationProperties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceLineRasterizationProperties":"VkPhysicalDeviceLineRasterizationPropertiesKHR", *props); + const VkPhysicalDeviceLineRasterizationProperties* props = + (const VkPhysicalDeviceLineRasterizationProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 + ? "VkPhysicalDeviceLineRasterizationProperties" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) + ? "VkPhysicalDeviceLineRasterizationPropertiesKHR" + : ("VkPhysicalDeviceLineRasterizationPropertiesEXT")); + DumpVkPhysicalDeviceLineRasterizationProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceLineRasterizationProperties(p, "VkPhysicalDeviceLineRasterizationPropertiesKHR", *props); + } + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceLineRasterizationProperties(p, "VkPhysicalDeviceLineRasterizationPropertiesEXT", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR) { + const VkPhysicalDeviceMaintenance10PropertiesKHR* props = (const VkPhysicalDeviceMaintenance10PropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance10PropertiesKHR"; + DumpVkPhysicalDeviceMaintenance10PropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES) { - VkPhysicalDeviceMaintenance3Properties* props = (VkPhysicalDeviceMaintenance3Properties*)structure; - DumpVkPhysicalDeviceMaintenance3Properties(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDeviceMaintenance3Properties":"VkPhysicalDeviceMaintenance3PropertiesKHR", *props); + const VkPhysicalDeviceMaintenance3Properties* props = (const VkPhysicalDeviceMaintenance3Properties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMaintenance3Properties" + : ("VkPhysicalDeviceMaintenance3PropertiesKHR"); + DumpVkPhysicalDeviceMaintenance3Properties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance3PropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_3_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMaintenance3Properties(p, "VkPhysicalDeviceMaintenance3PropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES) { - VkPhysicalDeviceMaintenance4Properties* props = (VkPhysicalDeviceMaintenance4Properties*)structure; - DumpVkPhysicalDeviceMaintenance4Properties(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceMaintenance4Properties":"VkPhysicalDeviceMaintenance4PropertiesKHR", *props); + const VkPhysicalDeviceMaintenance4Properties* props = (const VkPhysicalDeviceMaintenance4Properties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceMaintenance4Properties" + : ("VkPhysicalDeviceMaintenance4PropertiesKHR"); + DumpVkPhysicalDeviceMaintenance4Properties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance4PropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMaintenance4Properties(p, "VkPhysicalDeviceMaintenance4PropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES) { - VkPhysicalDeviceMaintenance5Properties* props = (VkPhysicalDeviceMaintenance5Properties*)structure; - DumpVkPhysicalDeviceMaintenance5Properties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceMaintenance5Properties":"VkPhysicalDeviceMaintenance5PropertiesKHR", *props); + const VkPhysicalDeviceMaintenance5Properties* props = (const VkPhysicalDeviceMaintenance5Properties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance5Properties" + : ("VkPhysicalDeviceMaintenance5PropertiesKHR"); + DumpVkPhysicalDeviceMaintenance5Properties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance5PropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMaintenance5Properties(p, "VkPhysicalDeviceMaintenance5PropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES) { - VkPhysicalDeviceMaintenance6Properties* props = (VkPhysicalDeviceMaintenance6Properties*)structure; - DumpVkPhysicalDeviceMaintenance6Properties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceMaintenance6Properties":"VkPhysicalDeviceMaintenance6PropertiesKHR", *props); + const VkPhysicalDeviceMaintenance6Properties* props = (const VkPhysicalDeviceMaintenance6Properties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance6Properties" + : ("VkPhysicalDeviceMaintenance6PropertiesKHR"); + DumpVkPhysicalDeviceMaintenance6Properties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance6PropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMaintenance6Properties(p, "VkPhysicalDeviceMaintenance6PropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR) { - VkPhysicalDeviceMaintenance7PropertiesKHR* props = (VkPhysicalDeviceMaintenance7PropertiesKHR*)structure; - DumpVkPhysicalDeviceMaintenance7PropertiesKHR(p, "VkPhysicalDeviceMaintenance7PropertiesKHR", *props); + const VkPhysicalDeviceMaintenance7PropertiesKHR* props = (const VkPhysicalDeviceMaintenance7PropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance7PropertiesKHR"; + DumpVkPhysicalDeviceMaintenance7PropertiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR) { + const VkPhysicalDeviceMaintenance9PropertiesKHR* props = (const VkPhysicalDeviceMaintenance9PropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance9PropertiesKHR"; + DumpVkPhysicalDeviceMaintenance9PropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT) { - VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* props = (VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*)structure; - DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(p, "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT", *props); + const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* props = + (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT"; + DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT) { + const VkPhysicalDeviceMemoryDecompressionPropertiesEXT* props = + (const VkPhysicalDeviceMemoryDecompressionPropertiesEXT*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME) + ? "VkPhysicalDeviceMemoryDecompressionPropertiesEXT" + : ("VkPhysicalDeviceMemoryDecompressionPropertiesNV"); + DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMemoryDecompressionPropertiesNV") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(p, "VkPhysicalDeviceMemoryDecompressionPropertiesNV", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT) { - VkPhysicalDeviceMeshShaderPropertiesEXT* props = (VkPhysicalDeviceMeshShaderPropertiesEXT*)structure; - DumpVkPhysicalDeviceMeshShaderPropertiesEXT(p, "VkPhysicalDeviceMeshShaderPropertiesEXT", *props); + const VkPhysicalDeviceMeshShaderPropertiesEXT* props = (const VkPhysicalDeviceMeshShaderPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceMeshShaderPropertiesEXT"; + DumpVkPhysicalDeviceMeshShaderPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT) { - VkPhysicalDeviceMultiDrawPropertiesEXT* props = (VkPhysicalDeviceMultiDrawPropertiesEXT*)structure; - DumpVkPhysicalDeviceMultiDrawPropertiesEXT(p, "VkPhysicalDeviceMultiDrawPropertiesEXT", *props); + const VkPhysicalDeviceMultiDrawPropertiesEXT* props = (const VkPhysicalDeviceMultiDrawPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceMultiDrawPropertiesEXT"; + DumpVkPhysicalDeviceMultiDrawPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES) { - VkPhysicalDeviceMultiviewProperties* props = (VkPhysicalDeviceMultiviewProperties*)structure; - DumpVkPhysicalDeviceMultiviewProperties(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDeviceMultiviewProperties":"VkPhysicalDeviceMultiviewPropertiesKHR", *props); + const VkPhysicalDeviceMultiviewProperties* props = (const VkPhysicalDeviceMultiviewProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMultiviewProperties" + : ("VkPhysicalDeviceMultiviewPropertiesKHR"); + DumpVkPhysicalDeviceMultiviewProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMultiviewPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMultiviewProperties(p, "VkPhysicalDeviceMultiviewPropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT) { - VkPhysicalDeviceNestedCommandBufferPropertiesEXT* props = (VkPhysicalDeviceNestedCommandBufferPropertiesEXT*)structure; - DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(p, "VkPhysicalDeviceNestedCommandBufferPropertiesEXT", *props); + const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* props = + (const VkPhysicalDeviceNestedCommandBufferPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceNestedCommandBufferPropertiesEXT"; + DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT) { - VkPhysicalDeviceOpacityMicromapPropertiesEXT* props = (VkPhysicalDeviceOpacityMicromapPropertiesEXT*)structure; - DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(p, "VkPhysicalDeviceOpacityMicromapPropertiesEXT", *props); + const VkPhysicalDeviceOpacityMicromapPropertiesEXT* props = + (const VkPhysicalDeviceOpacityMicromapPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceOpacityMicromapPropertiesEXT"; + DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT) { - VkPhysicalDevicePCIBusInfoPropertiesEXT* props = (VkPhysicalDevicePCIBusInfoPropertiesEXT*)structure; - DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(p, "VkPhysicalDevicePCIBusInfoPropertiesEXT", *props); + const VkPhysicalDevicePCIBusInfoPropertiesEXT* props = (const VkPhysicalDevicePCIBusInfoPropertiesEXT*)structure; + const char* name = "VkPhysicalDevicePCIBusInfoPropertiesEXT"; + DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR) { - VkPhysicalDevicePerformanceQueryPropertiesKHR* props = (VkPhysicalDevicePerformanceQueryPropertiesKHR*)structure; - DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(p, "VkPhysicalDevicePerformanceQueryPropertiesKHR", *props); + const VkPhysicalDevicePerformanceQueryPropertiesKHR* props = + (const VkPhysicalDevicePerformanceQueryPropertiesKHR*)structure; + const char* name = "VkPhysicalDevicePerformanceQueryPropertiesKHR"; + DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR) { - VkPhysicalDevicePipelineBinaryPropertiesKHR* props = (VkPhysicalDevicePipelineBinaryPropertiesKHR*)structure; - DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(p, "VkPhysicalDevicePipelineBinaryPropertiesKHR", *props); + const VkPhysicalDevicePipelineBinaryPropertiesKHR* props = + (const VkPhysicalDevicePipelineBinaryPropertiesKHR*)structure; + const char* name = "VkPhysicalDevicePipelineBinaryPropertiesKHR"; + DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES) { - VkPhysicalDevicePipelineRobustnessProperties* props = (VkPhysicalDevicePipelineRobustnessProperties*)structure; - DumpVkPhysicalDevicePipelineRobustnessProperties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDevicePipelineRobustnessProperties":"VkPhysicalDevicePipelineRobustnessPropertiesEXT", *props); + const VkPhysicalDevicePipelineRobustnessProperties* props = + (const VkPhysicalDevicePipelineRobustnessProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineRobustnessProperties" + : ("VkPhysicalDevicePipelineRobustnessPropertiesEXT"); + DumpVkPhysicalDevicePipelineRobustnessProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineRobustnessPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePipelineRobustnessProperties(p, "VkPhysicalDevicePipelineRobustnessPropertiesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES) { - VkPhysicalDevicePointClippingProperties* props = (VkPhysicalDevicePointClippingProperties*)structure; - DumpVkPhysicalDevicePointClippingProperties(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDevicePointClippingProperties":"VkPhysicalDevicePointClippingPropertiesKHR", *props); + const VkPhysicalDevicePointClippingProperties* props = (const VkPhysicalDevicePointClippingProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDevicePointClippingProperties" + : ("VkPhysicalDevicePointClippingPropertiesKHR"); + DumpVkPhysicalDevicePointClippingProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePointClippingPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_2_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePointClippingProperties(p, "VkPhysicalDevicePointClippingPropertiesKHR", *props); + } p.AddNewline(); } #ifdef VK_ENABLE_BETA_EXTENSIONS - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR && p.Type() != OutputType::json) { - VkPhysicalDevicePortabilitySubsetPropertiesKHR* props = (VkPhysicalDevicePortabilitySubsetPropertiesKHR*)structure; - DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(p, "VkPhysicalDevicePortabilitySubsetPropertiesKHR", *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR && + p.Type() != OutputType::json) { + const VkPhysicalDevicePortabilitySubsetPropertiesKHR* props = + (const VkPhysicalDevicePortabilitySubsetPropertiesKHR*)structure; + const char* name = "VkPhysicalDevicePortabilitySubsetPropertiesKHR"; + DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(p, name, *props); p.AddNewline(); } #endif // VK_ENABLE_BETA_EXTENSIONS if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES) { - VkPhysicalDeviceProtectedMemoryProperties* props = (VkPhysicalDeviceProtectedMemoryProperties*)structure; - DumpVkPhysicalDeviceProtectedMemoryProperties(p, "VkPhysicalDeviceProtectedMemoryProperties", *props); + const VkPhysicalDeviceProtectedMemoryProperties* props = (const VkPhysicalDeviceProtectedMemoryProperties*)structure; + const char* name = "VkPhysicalDeviceProtectedMemoryProperties"; + DumpVkPhysicalDeviceProtectedMemoryProperties(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT) { - VkPhysicalDeviceProvokingVertexPropertiesEXT* props = (VkPhysicalDeviceProvokingVertexPropertiesEXT*)structure; - DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(p, "VkPhysicalDeviceProvokingVertexPropertiesEXT", *props); + const VkPhysicalDeviceProvokingVertexPropertiesEXT* props = + (const VkPhysicalDeviceProvokingVertexPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceProvokingVertexPropertiesEXT"; + DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES) { - VkPhysicalDevicePushDescriptorProperties* props = (VkPhysicalDevicePushDescriptorProperties*)structure; - DumpVkPhysicalDevicePushDescriptorProperties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDevicePushDescriptorProperties":"VkPhysicalDevicePushDescriptorPropertiesKHR", *props); + const VkPhysicalDevicePushDescriptorProperties* props = (const VkPhysicalDevicePushDescriptorProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePushDescriptorProperties" + : ("VkPhysicalDevicePushDescriptorPropertiesKHR"); + DumpVkPhysicalDevicePushDescriptorProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePushDescriptorPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePushDescriptorProperties(p, "VkPhysicalDevicePushDescriptorPropertiesKHR", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT) { + const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT* props = + (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT"; + DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR) { - VkPhysicalDeviceRayTracingPipelinePropertiesKHR* props = (VkPhysicalDeviceRayTracingPipelinePropertiesKHR*)structure; - DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(p, "VkPhysicalDeviceRayTracingPipelinePropertiesKHR", *props); + const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* props = + (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceRayTracingPipelinePropertiesKHR"; + DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(p, name, *props); p.AddNewline(); } - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT) { - VkPhysicalDeviceRobustness2PropertiesEXT* props = (VkPhysicalDeviceRobustness2PropertiesEXT*)structure; - DumpVkPhysicalDeviceRobustness2PropertiesEXT(p, "VkPhysicalDeviceRobustness2PropertiesEXT", *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR) { + const VkPhysicalDeviceRobustness2PropertiesKHR* props = (const VkPhysicalDeviceRobustness2PropertiesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) + ? "VkPhysicalDeviceRobustness2PropertiesKHR" + : ("VkPhysicalDeviceRobustness2PropertiesEXT"); + DumpVkPhysicalDeviceRobustness2PropertiesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRobustness2PropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceRobustness2PropertiesKHR(p, "VkPhysicalDeviceRobustness2PropertiesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT) { - VkPhysicalDeviceSampleLocationsPropertiesEXT* props = (VkPhysicalDeviceSampleLocationsPropertiesEXT*)structure; - DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(p, "VkPhysicalDeviceSampleLocationsPropertiesEXT", *props); + const VkPhysicalDeviceSampleLocationsPropertiesEXT* props = + (const VkPhysicalDeviceSampleLocationsPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceSampleLocationsPropertiesEXT"; + DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES) { - VkPhysicalDeviceSamplerFilterMinmaxProperties* props = (VkPhysicalDeviceSamplerFilterMinmaxProperties*)structure; - DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceSamplerFilterMinmaxProperties":"VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT", *props); + const VkPhysicalDeviceSamplerFilterMinmaxProperties* props = + (const VkPhysicalDeviceSamplerFilterMinmaxProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceSamplerFilterMinmaxProperties" + : ("VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT"); + DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR) { + const VkPhysicalDeviceShaderAbortPropertiesKHR* props = (const VkPhysicalDeviceShaderAbortPropertiesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderAbortPropertiesKHR"; + DumpVkPhysicalDeviceShaderAbortPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES) { - VkPhysicalDeviceShaderIntegerDotProductProperties* props = (VkPhysicalDeviceShaderIntegerDotProductProperties*)structure; - DumpVkPhysicalDeviceShaderIntegerDotProductProperties(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceShaderIntegerDotProductProperties":"VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR", *props); + const VkPhysicalDeviceShaderIntegerDotProductProperties* props = + (const VkPhysicalDeviceShaderIntegerDotProductProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderIntegerDotProductProperties" + : ("VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR"); + DumpVkPhysicalDeviceShaderIntegerDotProductProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderIntegerDotProductProperties(p, "VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR", + *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT) { + const VkPhysicalDeviceShaderLongVectorPropertiesEXT* props = + (const VkPhysicalDeviceShaderLongVectorPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderLongVectorPropertiesEXT"; + DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT) { - VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* props = (VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*)structure; - DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(p, "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT", *props); + const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* props = + (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT"; + DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT) { - VkPhysicalDeviceShaderObjectPropertiesEXT* props = (VkPhysicalDeviceShaderObjectPropertiesEXT*)structure; - DumpVkPhysicalDeviceShaderObjectPropertiesEXT(p, "VkPhysicalDeviceShaderObjectPropertiesEXT", *props); + const VkPhysicalDeviceShaderObjectPropertiesEXT* props = (const VkPhysicalDeviceShaderObjectPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderObjectPropertiesEXT"; + DumpVkPhysicalDeviceShaderObjectPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT) { - VkPhysicalDeviceShaderTileImagePropertiesEXT* props = (VkPhysicalDeviceShaderTileImagePropertiesEXT*)structure; - DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(p, "VkPhysicalDeviceShaderTileImagePropertiesEXT", *props); + const VkPhysicalDeviceShaderTileImagePropertiesEXT* props = + (const VkPhysicalDeviceShaderTileImagePropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderTileImagePropertiesEXT"; + DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES) { - VkPhysicalDeviceSubgroupProperties* props = (VkPhysicalDeviceSubgroupProperties*)structure; - DumpVkPhysicalDeviceSubgroupProperties(p, "VkPhysicalDeviceSubgroupProperties", *props); + const VkPhysicalDeviceSubgroupProperties* props = (const VkPhysicalDeviceSubgroupProperties*)structure; + const char* name = "VkPhysicalDeviceSubgroupProperties"; + DumpVkPhysicalDeviceSubgroupProperties(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES) { - VkPhysicalDeviceSubgroupSizeControlProperties* props = (VkPhysicalDeviceSubgroupSizeControlProperties*)structure; - DumpVkPhysicalDeviceSubgroupSizeControlProperties(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceSubgroupSizeControlProperties":"VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", *props); + const VkPhysicalDeviceSubgroupSizeControlProperties* props = + (const VkPhysicalDeviceSubgroupSizeControlProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSubgroupSizeControlProperties" + : ("VkPhysicalDeviceSubgroupSizeControlPropertiesEXT"); + DumpVkPhysicalDeviceSubgroupSizeControlProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceSubgroupSizeControlProperties(p, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES) { - VkPhysicalDeviceTexelBufferAlignmentProperties* props = (VkPhysicalDeviceTexelBufferAlignmentProperties*)structure; - DumpVkPhysicalDeviceTexelBufferAlignmentProperties(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceTexelBufferAlignmentProperties":"VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", *props); + const VkPhysicalDeviceTexelBufferAlignmentProperties* props = + (const VkPhysicalDeviceTexelBufferAlignmentProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceTexelBufferAlignmentProperties" + : ("VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT"); + DumpVkPhysicalDeviceTexelBufferAlignmentProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceTexelBufferAlignmentProperties(p, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES) { - VkPhysicalDeviceTimelineSemaphoreProperties* props = (VkPhysicalDeviceTimelineSemaphoreProperties*)structure; - DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceTimelineSemaphoreProperties":"VkPhysicalDeviceTimelineSemaphorePropertiesKHR", *props); + const VkPhysicalDeviceTimelineSemaphoreProperties* props = + (const VkPhysicalDeviceTimelineSemaphoreProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceTimelineSemaphoreProperties" + : ("VkPhysicalDeviceTimelineSemaphorePropertiesKHR"); + DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTimelineSemaphorePropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, "VkPhysicalDeviceTimelineSemaphorePropertiesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT) { - VkPhysicalDeviceTransformFeedbackPropertiesEXT* props = (VkPhysicalDeviceTransformFeedbackPropertiesEXT*)structure; - DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(p, "VkPhysicalDeviceTransformFeedbackPropertiesEXT", *props); + const VkPhysicalDeviceTransformFeedbackPropertiesEXT* props = + (const VkPhysicalDeviceTransformFeedbackPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceTransformFeedbackPropertiesEXT"; + DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES) { - VkPhysicalDeviceVertexAttributeDivisorProperties* props = (VkPhysicalDeviceVertexAttributeDivisorProperties*)structure; - DumpVkPhysicalDeviceVertexAttributeDivisorProperties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceVertexAttributeDivisorProperties":"VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR", *props); + const VkPhysicalDeviceVertexAttributeDivisorProperties* props = + (const VkPhysicalDeviceVertexAttributeDivisorProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceVertexAttributeDivisorProperties" + : ("VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR"); + DumpVkPhysicalDeviceVertexAttributeDivisorProperties(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceVertexAttributeDivisorProperties(p, "VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT) { - VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* props = (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*)structure; - DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(p, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT", *props); + const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* props = + (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*)structure; + const char* name = "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT"; + DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES) { - VkPhysicalDeviceVulkan11Properties* props = (VkPhysicalDeviceVulkan11Properties*)structure; - DumpVkPhysicalDeviceVulkan11Properties(p, "VkPhysicalDeviceVulkan11Properties", *props); + const VkPhysicalDeviceVulkan11Properties* props = (const VkPhysicalDeviceVulkan11Properties*)structure; + const char* name = "VkPhysicalDeviceVulkan11Properties"; + DumpVkPhysicalDeviceVulkan11Properties(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) { - VkPhysicalDeviceVulkan12Properties* props = (VkPhysicalDeviceVulkan12Properties*)structure; - DumpVkPhysicalDeviceVulkan12Properties(p, "VkPhysicalDeviceVulkan12Properties", *props); + const VkPhysicalDeviceVulkan12Properties* props = (const VkPhysicalDeviceVulkan12Properties*)structure; + const char* name = "VkPhysicalDeviceVulkan12Properties"; + DumpVkPhysicalDeviceVulkan12Properties(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES) { - VkPhysicalDeviceVulkan13Properties* props = (VkPhysicalDeviceVulkan13Properties*)structure; - DumpVkPhysicalDeviceVulkan13Properties(p, "VkPhysicalDeviceVulkan13Properties", *props); + const VkPhysicalDeviceVulkan13Properties* props = (const VkPhysicalDeviceVulkan13Properties*)structure; + const char* name = "VkPhysicalDeviceVulkan13Properties"; + DumpVkPhysicalDeviceVulkan13Properties(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES) { - VkPhysicalDeviceVulkan14Properties* props = (VkPhysicalDeviceVulkan14Properties*)structure; - DumpVkPhysicalDeviceVulkan14Properties(p, "VkPhysicalDeviceVulkan14Properties", *props); + const VkPhysicalDeviceVulkan14Properties* props = (const VkPhysicalDeviceVulkan14Properties*)structure; + const char* name = "VkPhysicalDeviceVulkan14Properties"; + DumpVkPhysicalDeviceVulkan14Properties(p, name, *props); p.AddNewline(); } place = structure->pNext; @@ -4245,12 +9215,18 @@ bool prepare_phys_device_props2_twocall_chain_vectors(std::unique_ptr<phys_device_props2_chain>& chain) { (void)chain; - chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.resize(chain->PhysicalDeviceHostImageCopyProperties.copySrcLayoutCount); - chain->PhysicalDeviceHostImageCopyProperties.pCopySrcLayouts = chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.data(); - chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.resize(chain->PhysicalDeviceHostImageCopyProperties.copyDstLayoutCount); - chain->PhysicalDeviceHostImageCopyProperties.pCopyDstLayouts = chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.data(); - chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.resize(chain->PhysicalDeviceLayeredApiPropertiesListKHR.layeredApiCount); - chain->PhysicalDeviceLayeredApiPropertiesListKHR.pLayeredApis = chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.data(); + chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.resize( + chain->PhysicalDeviceHostImageCopyProperties.copySrcLayoutCount); + chain->PhysicalDeviceHostImageCopyProperties.pCopySrcLayouts = + chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.data(); + chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.resize( + chain->PhysicalDeviceHostImageCopyProperties.copyDstLayoutCount); + chain->PhysicalDeviceHostImageCopyProperties.pCopyDstLayouts = + chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.data(); + chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.resize( + chain->PhysicalDeviceLayeredApiPropertiesListKHR.layeredApiCount); + chain->PhysicalDeviceLayeredApiPropertiesListKHR.pLayeredApis = + chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.data(); chain->VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts.resize(chain->PhysicalDeviceVulkan14Properties.copySrcLayoutCount); chain->PhysicalDeviceVulkan14Properties.pCopySrcLayouts = chain->VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts.data(); chain->VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts.resize(chain->PhysicalDeviceVulkan14Properties.copyDstLayoutCount); @@ -4259,27 +9235,28 @@ } struct phys_device_mem_props2_chain { phys_device_mem_props2_chain() = default; - phys_device_mem_props2_chain(const phys_device_mem_props2_chain &) = delete; - phys_device_mem_props2_chain& operator=(const phys_device_mem_props2_chain &) = delete; - phys_device_mem_props2_chain(phys_device_mem_props2_chain &&) = delete; - phys_device_mem_props2_chain& operator=(phys_device_mem_props2_chain &&) = delete; + phys_device_mem_props2_chain(const phys_device_mem_props2_chain&) = delete; + phys_device_mem_props2_chain& operator=(const phys_device_mem_props2_chain&) = delete; + phys_device_mem_props2_chain(phys_device_mem_props2_chain&&) = delete; + phys_device_mem_props2_chain& operator=(phys_device_mem_props2_chain&&) = delete; void* start_of_chain = nullptr; VkPhysicalDeviceMemoryBudgetPropertiesEXT PhysicalDeviceMemoryBudgetPropertiesEXT{}; - void initialize_chain(AppGpu &gpu ) noexcept { + void initialize_chain(AppGpu& gpu) noexcept { PhysicalDeviceMemoryBudgetPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; std::vector<VkBaseOutStructure*> chain_members{}; if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMemoryBudgetPropertiesEXT)); if (!chain_members.empty()) { - for(size_t i = 0; i < chain_members.size() - 1; i++){ + for (size_t i = 0; i < chain_members.size() - 1; i++) { chain_members[i]->pNext = chain_members[i + 1]; } start_of_chain = chain_members[0]; } } }; -void setup_phys_device_mem_props2_chain(VkPhysicalDeviceMemoryProperties2& start, std::unique_ptr<phys_device_mem_props2_chain>& chain, AppGpu &gpu){ +void setup_phys_device_mem_props2_chain(VkPhysicalDeviceMemoryProperties2& start, + std::unique_ptr<phys_device_mem_props2_chain>& chain, AppGpu& gpu) { chain = std::unique_ptr<phys_device_mem_props2_chain>(new phys_device_mem_props2_chain()); chain->initialize_chain(gpu); start.pNext = chain->start_of_chain; @@ -4291,10 +9268,10 @@ } struct phys_device_features2_chain { phys_device_features2_chain() = default; - phys_device_features2_chain(const phys_device_features2_chain &) = delete; - phys_device_features2_chain& operator=(const phys_device_features2_chain &) = delete; - phys_device_features2_chain(phys_device_features2_chain &&) = delete; - phys_device_features2_chain& operator=(phys_device_features2_chain &&) = delete; + phys_device_features2_chain(const phys_device_features2_chain&) = delete; + phys_device_features2_chain& operator=(const phys_device_features2_chain&) = delete; + phys_device_features2_chain(phys_device_features2_chain&&) = delete; + phys_device_features2_chain& operator=(phys_device_features2_chain&&) = delete; void* start_of_chain = nullptr; VkPhysicalDevice16BitStorageFeatures PhysicalDevice16BitStorageFeatures{}; VkPhysicalDevice4444FormatsFeaturesEXT PhysicalDevice4444FormatsFeaturesEXT{}; @@ -4312,14 +9289,18 @@ VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR PhysicalDeviceComputeShaderDerivativesFeaturesKHR{}; VkPhysicalDeviceConditionalRenderingFeaturesEXT PhysicalDeviceConditionalRenderingFeaturesEXT{}; VkPhysicalDeviceCooperativeMatrixFeaturesKHR PhysicalDeviceCooperativeMatrixFeaturesKHR{}; + VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR PhysicalDeviceCopyMemoryIndirectFeaturesKHR{}; VkPhysicalDeviceCustomBorderColorFeaturesEXT PhysicalDeviceCustomBorderColorFeaturesEXT{}; + VkPhysicalDeviceCustomResolveFeaturesEXT PhysicalDeviceCustomResolveFeaturesEXT{}; VkPhysicalDeviceDepthBiasControlFeaturesEXT PhysicalDeviceDepthBiasControlFeaturesEXT{}; VkPhysicalDeviceDepthClampControlFeaturesEXT PhysicalDeviceDepthClampControlFeaturesEXT{}; - VkPhysicalDeviceDepthClampZeroOneFeaturesEXT PhysicalDeviceDepthClampZeroOneFeaturesEXT{}; + VkPhysicalDeviceDepthClampZeroOneFeaturesKHR PhysicalDeviceDepthClampZeroOneFeaturesKHR{}; VkPhysicalDeviceDepthClipControlFeaturesEXT PhysicalDeviceDepthClipControlFeaturesEXT{}; VkPhysicalDeviceDepthClipEnableFeaturesEXT PhysicalDeviceDepthClipEnableFeaturesEXT{}; VkPhysicalDeviceDescriptorBufferFeaturesEXT PhysicalDeviceDescriptorBufferFeaturesEXT{}; + VkPhysicalDeviceDescriptorHeapFeaturesEXT PhysicalDeviceDescriptorHeapFeaturesEXT{}; VkPhysicalDeviceDescriptorIndexingFeatures PhysicalDeviceDescriptorIndexingFeatures{}; + VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR PhysicalDeviceDeviceAddressCommandsFeaturesKHR{}; VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT{}; VkPhysicalDeviceDeviceMemoryReportFeaturesEXT PhysicalDeviceDeviceMemoryReportFeaturesEXT{}; VkPhysicalDeviceDynamicRenderingFeatures PhysicalDeviceDynamicRenderingFeatures{}; @@ -4329,8 +9310,10 @@ VkPhysicalDeviceExtendedDynamicState3FeaturesEXT PhysicalDeviceExtendedDynamicState3FeaturesEXT{}; VkPhysicalDeviceExtendedDynamicStateFeaturesEXT PhysicalDeviceExtendedDynamicStateFeaturesEXT{}; VkPhysicalDeviceFaultFeaturesEXT PhysicalDeviceFaultFeaturesEXT{}; + VkPhysicalDeviceFaultFeaturesKHR PhysicalDeviceFaultFeaturesKHR{}; VkPhysicalDeviceFragmentDensityMap2FeaturesEXT PhysicalDeviceFragmentDensityMap2FeaturesEXT{}; VkPhysicalDeviceFragmentDensityMapFeaturesEXT PhysicalDeviceFragmentDensityMapFeaturesEXT{}; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT{}; VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR PhysicalDeviceFragmentShaderBarycentricFeaturesKHR{}; VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT PhysicalDeviceFragmentShaderInterlockFeaturesEXT{}; VkPhysicalDeviceFragmentShadingRateFeaturesKHR PhysicalDeviceFragmentShadingRateFeaturesKHR{}; @@ -4348,14 +9331,20 @@ VkPhysicalDeviceImagelessFramebufferFeatures PhysicalDeviceImagelessFramebufferFeatures{}; VkPhysicalDeviceIndexTypeUint8Features PhysicalDeviceIndexTypeUint8Features{}; VkPhysicalDeviceInlineUniformBlockFeatures PhysicalDeviceInlineUniformBlockFeatures{}; + VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR{}; VkPhysicalDeviceLegacyDitheringFeaturesEXT PhysicalDeviceLegacyDitheringFeaturesEXT{}; VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT PhysicalDeviceLegacyVertexAttributesFeaturesEXT{}; VkPhysicalDeviceLineRasterizationFeatures PhysicalDeviceLineRasterizationFeatures{}; + VkPhysicalDeviceMaintenance10FeaturesKHR PhysicalDeviceMaintenance10FeaturesKHR{}; + VkPhysicalDeviceMaintenance11FeaturesKHR PhysicalDeviceMaintenance11FeaturesKHR{}; VkPhysicalDeviceMaintenance4Features PhysicalDeviceMaintenance4Features{}; VkPhysicalDeviceMaintenance5Features PhysicalDeviceMaintenance5Features{}; VkPhysicalDeviceMaintenance6Features PhysicalDeviceMaintenance6Features{}; VkPhysicalDeviceMaintenance7FeaturesKHR PhysicalDeviceMaintenance7FeaturesKHR{}; + VkPhysicalDeviceMaintenance8FeaturesKHR PhysicalDeviceMaintenance8FeaturesKHR{}; + VkPhysicalDeviceMaintenance9FeaturesKHR PhysicalDeviceMaintenance9FeaturesKHR{}; VkPhysicalDeviceMapMemoryPlacedFeaturesEXT PhysicalDeviceMapMemoryPlacedFeaturesEXT{}; + VkPhysicalDeviceMemoryDecompressionFeaturesEXT PhysicalDeviceMemoryDecompressionFeaturesEXT{}; VkPhysicalDeviceMemoryPriorityFeaturesEXT PhysicalDeviceMemoryPriorityFeaturesEXT{}; VkPhysicalDeviceMeshShaderFeaturesEXT PhysicalDeviceMeshShaderFeaturesEXT{}; VkPhysicalDeviceMultiDrawFeaturesEXT PhysicalDeviceMultiDrawFeaturesEXT{}; @@ -4377,9 +9366,13 @@ #ifdef VK_ENABLE_BETA_EXTENSIONS VkPhysicalDevicePortabilitySubsetFeaturesKHR PhysicalDevicePortabilitySubsetFeaturesKHR{}; #endif // VK_ENABLE_BETA_EXTENSIONS + VkPhysicalDevicePresentId2FeaturesKHR PhysicalDevicePresentId2FeaturesKHR{}; VkPhysicalDevicePresentIdFeaturesKHR PhysicalDevicePresentIdFeaturesKHR{}; - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT{}; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR{}; + VkPhysicalDevicePresentTimingFeaturesEXT PhysicalDevicePresentTimingFeaturesEXT{}; + VkPhysicalDevicePresentWait2FeaturesKHR PhysicalDevicePresentWait2FeaturesKHR{}; VkPhysicalDevicePresentWaitFeaturesKHR PhysicalDevicePresentWaitFeaturesKHR{}; + VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT PhysicalDevicePrimitiveRestartIndexFeaturesEXT{}; VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT{}; VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT{}; VkPhysicalDevicePrivateDataFeatures PhysicalDevicePrivateDataFeatures{}; @@ -4388,25 +9381,33 @@ VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT PhysicalDeviceRGBA10X6FormatsFeaturesEXT{}; VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT{}; VkPhysicalDeviceRayQueryFeaturesKHR PhysicalDeviceRayQueryFeaturesKHR{}; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT PhysicalDeviceRayTracingInvocationReorderFeaturesEXT{}; VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR PhysicalDeviceRayTracingMaintenance1FeaturesKHR{}; VkPhysicalDeviceRayTracingPipelineFeaturesKHR PhysicalDeviceRayTracingPipelineFeaturesKHR{}; VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR PhysicalDeviceRayTracingPositionFetchFeaturesKHR{}; - VkPhysicalDeviceRobustness2FeaturesEXT PhysicalDeviceRobustness2FeaturesEXT{}; + VkPhysicalDeviceRobustness2FeaturesKHR PhysicalDeviceRobustness2FeaturesKHR{}; VkPhysicalDeviceSamplerYcbcrConversionFeatures PhysicalDeviceSamplerYcbcrConversionFeatures{}; VkPhysicalDeviceScalarBlockLayoutFeatures PhysicalDeviceScalarBlockLayoutFeatures{}; VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures PhysicalDeviceSeparateDepthStencilLayoutsFeatures{}; + VkPhysicalDeviceShader64BitIndexingFeaturesEXT PhysicalDeviceShader64BitIndexingFeaturesEXT{}; + VkPhysicalDeviceShaderAbortFeaturesKHR PhysicalDeviceShaderAbortFeaturesKHR{}; VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT PhysicalDeviceShaderAtomicFloat2FeaturesEXT{}; VkPhysicalDeviceShaderAtomicFloatFeaturesEXT PhysicalDeviceShaderAtomicFloatFeaturesEXT{}; VkPhysicalDeviceShaderAtomicInt64Features PhysicalDeviceShaderAtomicInt64Features{}; + VkPhysicalDeviceShaderBfloat16FeaturesKHR PhysicalDeviceShaderBfloat16FeaturesKHR{}; VkPhysicalDeviceShaderClockFeaturesKHR PhysicalDeviceShaderClockFeaturesKHR{}; + VkPhysicalDeviceShaderConstantDataFeaturesKHR PhysicalDeviceShaderConstantDataFeaturesKHR{}; VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures PhysicalDeviceShaderDemoteToHelperInvocationFeatures{}; VkPhysicalDeviceShaderDrawParametersFeatures PhysicalDeviceShaderDrawParametersFeatures{}; VkPhysicalDeviceShaderExpectAssumeFeatures PhysicalDeviceShaderExpectAssumeFeatures{}; VkPhysicalDeviceShaderFloat16Int8Features PhysicalDeviceShaderFloat16Int8Features{}; + VkPhysicalDeviceShaderFloat8FeaturesEXT PhysicalDeviceShaderFloat8FeaturesEXT{}; VkPhysicalDeviceShaderFloatControls2Features PhysicalDeviceShaderFloatControls2Features{}; + VkPhysicalDeviceShaderFmaFeaturesKHR PhysicalDeviceShaderFmaFeaturesKHR{}; VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT PhysicalDeviceShaderImageAtomicInt64FeaturesEXT{}; VkPhysicalDeviceShaderIntegerDotProductFeatures PhysicalDeviceShaderIntegerDotProductFeatures{}; char VkPhysicalDeviceShaderIntegerDotProductFeatures_padding[64]; + VkPhysicalDeviceShaderLongVectorFeaturesEXT PhysicalDeviceShaderLongVectorFeaturesEXT{}; VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR{}; VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT PhysicalDeviceShaderModuleIdentifierFeaturesEXT{}; VkPhysicalDeviceShaderObjectFeaturesEXT PhysicalDeviceShaderObjectFeaturesEXT{}; @@ -4414,26 +9415,34 @@ VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR{}; VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT PhysicalDeviceShaderReplicatedCompositesFeaturesEXT{}; VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures PhysicalDeviceShaderSubgroupExtendedTypesFeatures{}; + VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT{}; VkPhysicalDeviceShaderSubgroupRotateFeatures PhysicalDeviceShaderSubgroupRotateFeatures{}; VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{}; VkPhysicalDeviceShaderTerminateInvocationFeatures PhysicalDeviceShaderTerminateInvocationFeatures{}; VkPhysicalDeviceShaderTileImageFeaturesEXT PhysicalDeviceShaderTileImageFeaturesEXT{}; + VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT{}; + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR PhysicalDeviceShaderUntypedPointersFeaturesKHR{}; VkPhysicalDeviceSubgroupSizeControlFeatures PhysicalDeviceSubgroupSizeControlFeatures{}; VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT PhysicalDeviceSubpassMergeFeedbackFeaturesEXT{}; - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT PhysicalDeviceSwapchainMaintenance1FeaturesEXT{}; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR PhysicalDeviceSwapchainMaintenance1FeaturesKHR{}; VkPhysicalDeviceSynchronization2Features PhysicalDeviceSynchronization2Features{}; VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT PhysicalDeviceTexelBufferAlignmentFeaturesEXT{}; + VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT PhysicalDeviceTextureCompressionASTC3DFeaturesEXT{}; VkPhysicalDeviceTextureCompressionASTCHDRFeatures PhysicalDeviceTextureCompressionASTCHDRFeatures{}; VkPhysicalDeviceTimelineSemaphoreFeatures PhysicalDeviceTimelineSemaphoreFeatures{}; VkPhysicalDeviceTransformFeedbackFeaturesEXT PhysicalDeviceTransformFeedbackFeaturesEXT{}; + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR PhysicalDeviceUnifiedImageLayoutsFeaturesKHR{}; VkPhysicalDeviceUniformBufferStandardLayoutFeatures PhysicalDeviceUniformBufferStandardLayoutFeatures{}; VkPhysicalDeviceVariablePointersFeatures PhysicalDeviceVariablePointersFeatures{}; VkPhysicalDeviceVertexAttributeDivisorFeatures PhysicalDeviceVertexAttributeDivisorFeatures{}; VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT PhysicalDeviceVertexAttributeRobustnessFeaturesEXT{}; VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT PhysicalDeviceVertexInputDynamicStateFeaturesEXT{}; + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR PhysicalDeviceVideoDecodeVP9FeaturesKHR{}; VkPhysicalDeviceVideoEncodeAV1FeaturesKHR PhysicalDeviceVideoEncodeAV1FeaturesKHR{}; + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR{}; VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR{}; VkPhysicalDeviceVideoMaintenance1FeaturesKHR PhysicalDeviceVideoMaintenance1FeaturesKHR{}; + VkPhysicalDeviceVideoMaintenance2FeaturesKHR PhysicalDeviceVideoMaintenance2FeaturesKHR{}; VkPhysicalDeviceVulkan11Features PhysicalDeviceVulkan11Features{}; VkPhysicalDeviceVulkan12Features PhysicalDeviceVulkan12Features{}; VkPhysicalDeviceVulkan13Features PhysicalDeviceVulkan13Features{}; @@ -4442,162 +9451,254 @@ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{}; VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT{}; VkPhysicalDeviceYcbcrImageArraysFeaturesEXT PhysicalDeviceYcbcrImageArraysFeaturesEXT{}; + VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT{}; VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures{}; - void initialize_chain(AppGpu &gpu , bool show_promoted_structs) noexcept { + void initialize_chain(AppGpu& gpu, bool show_promoted_structs) noexcept { PhysicalDevice16BitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; PhysicalDevice4444FormatsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; PhysicalDevice8BitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; PhysicalDeviceASTCDecodeFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; - PhysicalDeviceAccelerationStructureFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + PhysicalDeviceAccelerationStructureFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; PhysicalDeviceAddressBindingReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; - PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; - PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; - PhysicalDeviceBlendOperationAdvancedFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; + PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + PhysicalDeviceBlendOperationAdvancedFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; PhysicalDeviceBorderColorSwizzleFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; PhysicalDeviceBufferDeviceAddressFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; PhysicalDeviceBufferDeviceAddressFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; PhysicalDeviceColorWriteEnableFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; - PhysicalDeviceComputeShaderDerivativesFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; + PhysicalDeviceComputeShaderDerivativesFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; PhysicalDeviceConditionalRenderingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; PhysicalDeviceCooperativeMatrixFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + PhysicalDeviceCopyMemoryIndirectFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR; PhysicalDeviceCustomBorderColorFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; + PhysicalDeviceCustomResolveFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT; PhysicalDeviceDepthBiasControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; PhysicalDeviceDepthClampControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; - PhysicalDeviceDepthClampZeroOneFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; + PhysicalDeviceDepthClampZeroOneFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; PhysicalDeviceDepthClipControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; PhysicalDeviceDepthClipEnableFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; PhysicalDeviceDescriptorBufferFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + PhysicalDeviceDescriptorHeapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT; PhysicalDeviceDescriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; - PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + PhysicalDeviceDeviceAddressCommandsFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR; + PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; PhysicalDeviceDeviceMemoryReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; PhysicalDeviceDynamicRenderingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; - PhysicalDeviceDynamicRenderingLocalReadFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; - PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; - PhysicalDeviceExtendedDynamicState2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; - PhysicalDeviceExtendedDynamicState3FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + PhysicalDeviceDynamicRenderingLocalReadFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; + PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; + PhysicalDeviceExtendedDynamicState2FeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + PhysicalDeviceExtendedDynamicState3FeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; PhysicalDeviceExtendedDynamicStateFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; PhysicalDeviceFaultFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + PhysicalDeviceFaultFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR; PhysicalDeviceFragmentDensityMap2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; PhysicalDeviceFragmentDensityMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; - PhysicalDeviceFragmentShaderBarycentricFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; - PhysicalDeviceFragmentShaderInterlockFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; + PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; + PhysicalDeviceFragmentShaderInterlockFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; PhysicalDeviceFragmentShadingRateFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; PhysicalDeviceFrameBoundaryFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; PhysicalDeviceGlobalPriorityQueryFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; - PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; PhysicalDeviceHostImageCopyFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; PhysicalDeviceHostQueryResetFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; PhysicalDeviceImage2DViewOf3DFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; - PhysicalDeviceImageCompressionControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; - PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; + PhysicalDeviceImageCompressionControlFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; PhysicalDeviceImageRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; PhysicalDeviceImageSlicedViewOf3DFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; PhysicalDeviceImageViewMinLodFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; PhysicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; PhysicalDeviceIndexTypeUint8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; PhysicalDeviceInlineUniformBlockFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR; PhysicalDeviceLegacyDitheringFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; - PhysicalDeviceLegacyVertexAttributesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; + PhysicalDeviceLegacyVertexAttributesFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; PhysicalDeviceLineRasterizationFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; + PhysicalDeviceMaintenance10FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR; + PhysicalDeviceMaintenance11FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR; PhysicalDeviceMaintenance4Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; PhysicalDeviceMaintenance5Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; PhysicalDeviceMaintenance6Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; PhysicalDeviceMaintenance7FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; + PhysicalDeviceMaintenance8FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; + PhysicalDeviceMaintenance9FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; PhysicalDeviceMapMemoryPlacedFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; + PhysicalDeviceMemoryDecompressionFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT; PhysicalDeviceMemoryPriorityFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; PhysicalDeviceMeshShaderFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; PhysicalDeviceMultiDrawFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; - PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; PhysicalDeviceMultiviewFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; - PhysicalDeviceMutableDescriptorTypeFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + PhysicalDeviceMutableDescriptorTypeFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; PhysicalDeviceNestedCommandBufferFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; PhysicalDeviceNonSeamlessCubeMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; PhysicalDeviceOpacityMicromapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; - PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; PhysicalDevicePerformanceQueryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; PhysicalDevicePipelineBinaryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; - PhysicalDevicePipelineCreationCacheControlFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; - PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + PhysicalDevicePipelineCreationCacheControlFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; PhysicalDevicePipelinePropertiesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; PhysicalDevicePipelineProtectedAccessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; PhysicalDevicePipelineRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; #ifdef VK_ENABLE_BETA_EXTENSIONS PhysicalDevicePortabilitySubsetFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; #endif // VK_ENABLE_BETA_EXTENSIONS + PhysicalDevicePresentId2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; PhysicalDevicePresentIdFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; - PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; + PhysicalDevicePresentTimingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + PhysicalDevicePresentWait2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; PhysicalDevicePresentWaitFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; - PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; - PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; + PhysicalDevicePrimitiveRestartIndexFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT; + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; PhysicalDevicePrivateDataFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; PhysicalDeviceProtectedMemoryFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; PhysicalDeviceProvokingVertexFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; PhysicalDeviceRGBA10X6FormatsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; - PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; PhysicalDeviceRayQueryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; - PhysicalDeviceRayTracingMaintenance1FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + PhysicalDeviceRayTracingInvocationReorderFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT; + PhysicalDeviceRayTracingMaintenance1FeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; PhysicalDeviceRayTracingPipelineFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; - PhysicalDeviceRayTracingPositionFetchFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; - PhysicalDeviceRobustness2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT; + PhysicalDeviceRayTracingPositionFetchFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; + PhysicalDeviceRobustness2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; PhysicalDeviceSamplerYcbcrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; PhysicalDeviceScalarBlockLayoutFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; - PhysicalDeviceSeparateDepthStencilLayoutsFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + PhysicalDeviceSeparateDepthStencilLayoutsFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + PhysicalDeviceShader64BitIndexingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT; + PhysicalDeviceShaderAbortFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR; PhysicalDeviceShaderAtomicFloat2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; PhysicalDeviceShaderAtomicFloatFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; PhysicalDeviceShaderAtomicInt64Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + PhysicalDeviceShaderBfloat16FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; PhysicalDeviceShaderClockFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; - PhysicalDeviceShaderDemoteToHelperInvocationFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + PhysicalDeviceShaderConstantDataFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR; + PhysicalDeviceShaderDemoteToHelperInvocationFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; PhysicalDeviceShaderDrawParametersFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; PhysicalDeviceShaderExpectAssumeFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; PhysicalDeviceShaderFloat16Int8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + PhysicalDeviceShaderFloat8FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; PhysicalDeviceShaderFloatControls2Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; - PhysicalDeviceShaderImageAtomicInt64FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; + PhysicalDeviceShaderFmaFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR; + PhysicalDeviceShaderImageAtomicInt64FeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; PhysicalDeviceShaderIntegerDotProductFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; - PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; - PhysicalDeviceShaderModuleIdentifierFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + PhysicalDeviceShaderLongVectorFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT; + PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + PhysicalDeviceShaderModuleIdentifierFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; PhysicalDeviceShaderObjectFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; PhysicalDeviceShaderQuadControlFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; - PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; - PhysicalDeviceShaderReplicatedCompositesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; - PhysicalDeviceShaderSubgroupExtendedTypesFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + PhysicalDeviceShaderReplicatedCompositesFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + PhysicalDeviceShaderSubgroupExtendedTypesFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT; PhysicalDeviceShaderSubgroupRotateFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; - PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; - PhysicalDeviceShaderTerminateInvocationFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; + PhysicalDeviceShaderTerminateInvocationFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; PhysicalDeviceShaderTileImageFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; + PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT; + PhysicalDeviceShaderUntypedPointersFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; PhysicalDeviceSubgroupSizeControlFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; PhysicalDeviceSubpassMergeFeedbackFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; - PhysicalDeviceSwapchainMaintenance1FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; + PhysicalDeviceSwapchainMaintenance1FeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; PhysicalDeviceSynchronization2Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; PhysicalDeviceTexelBufferAlignmentFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; - PhysicalDeviceTextureCompressionASTCHDRFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + PhysicalDeviceTextureCompressionASTC3DFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT; + PhysicalDeviceTextureCompressionASTCHDRFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; PhysicalDeviceTimelineSemaphoreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; PhysicalDeviceTransformFeedbackFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; - PhysicalDeviceUniformBufferStandardLayoutFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + PhysicalDeviceUnifiedImageLayoutsFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + PhysicalDeviceUniformBufferStandardLayoutFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; PhysicalDeviceVariablePointersFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; PhysicalDeviceVertexAttributeDivisorFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; - PhysicalDeviceVertexAttributeRobustnessFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; - PhysicalDeviceVertexInputDynamicStateFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + PhysicalDeviceVertexAttributeRobustnessFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + PhysicalDeviceVertexInputDynamicStateFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + PhysicalDeviceVideoDecodeVP9FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; PhysicalDeviceVideoEncodeAV1FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; - PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; PhysicalDeviceVideoMaintenance1FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; + PhysicalDeviceVideoMaintenance2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; PhysicalDeviceVulkan11Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; PhysicalDeviceVulkan12Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; PhysicalDeviceVulkan13Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; PhysicalDeviceVulkan14Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; PhysicalDeviceVulkanMemoryModelFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; - PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; - PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; PhysicalDeviceYcbcrImageArraysFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; - PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; std::vector<VkBaseOutStructure*> chain_members{}; - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevice16BitStorageFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_4444_FORMATS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevice4444FormatsFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevice8BitStorageFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceASTCDecodeFeaturesEXT)); @@ -4606,56 +9707,67 @@ if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceAddressBindingReportFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT)); + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceBlendOperationAdvancedFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceBorderColorSwizzleFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceBufferDeviceAddressFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceBufferDeviceAddressFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceColorWriteEnableFeaturesEXT)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceComputeShaderDerivativesFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceConditionalRenderingFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceCooperativeMatrixFeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceCopyMemoryIndirectFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceCustomBorderColorFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceCustomResolveFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDepthBiasControlFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDepthClampControlFeaturesEXT)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDepthClampZeroOneFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDepthClampZeroOneFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDepthClipControlFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDepthClipEnableFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorBufferFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorHeapFeaturesEXT)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDescriptorIndexingFeatures)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_ADDRESS_COMMANDS_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDeviceAddressCommandsFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDeviceMemoryReportFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDynamicRenderingFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDynamicRenderingLocalReadFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT)); + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceExtendedDynamicState2FeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME)) @@ -4664,12 +9776,17 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceExtendedDynamicStateFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_FAULT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFaultFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_FAULT_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFaultFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentDensityMap2FeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentDensityMapFeaturesEXT)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentShaderBarycentricFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentShaderInterlockFeaturesEXT)); @@ -4677,62 +9794,76 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFragmentShadingRateFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceFrameBoundaryFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceGlobalPriorityQueryFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceHostImageCopyFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceHostQueryResetFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImage2DViewOf3DFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImageCompressionControlFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImageRobustnessFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImageSlicedViewOf3DFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImageViewMinLodFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceImagelessFramebufferFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceIndexTypeUint8Features)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceInlineUniformBlockFeatures)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_DITHERING_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceLegacyDitheringFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceLegacyVertexAttributesFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceLineRasterizationFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_10_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance10FeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_11_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance11FeaturesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance4Features)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance5Features)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance6Features)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance7FeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_8_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance8FeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMaintenance9FeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMapMemoryPlacedFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMemoryDecompressionFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMemoryPriorityFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MESH_SHADER_EXTENSION_NAME)) @@ -4740,12 +9871,13 @@ if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTI_DRAW_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMultiDrawFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMultiviewFeatures)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceMutableDescriptorTypeFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceNestedCommandBufferFeaturesEXT)); @@ -4759,8 +9891,8 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePerformanceQueryFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_BINARY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineBinaryFeaturesKHR)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineCreationCacheControlFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineExecutablePropertiesFeaturesKHR)); @@ -4768,28 +9900,37 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelinePropertiesFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineProtectedAccessFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePipelineRobustnessFeatures)); #ifdef VK_ENABLE_BETA_EXTENSIONS if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePortabilitySubsetFeaturesKHR)); #endif // VK_ENABLE_BETA_EXTENSIONS + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_2_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePresentId2FeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePresentIdFeaturesKHR)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_TIMING_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePresentTimingFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePresentWait2FeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePresentWaitFeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIMITIVE_RESTART_INDEX_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePrimitiveRestartIndexFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIVATE_DATA_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIVATE_DATA_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDevicePrivateDataFeatures)); if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceProtectedMemoryFeatures)); @@ -4797,56 +9938,74 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceProvokingVertexFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRGBA10X6FormatsFeaturesEXT)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME)) + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_QUERY_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRayQueryFeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRayTracingInvocationReorderFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRayTracingMaintenance1FeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRayTracingPipelineFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRayTracingPositionFetchFeaturesKHR)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRobustness2FeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceRobustness2FeaturesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSamplerYcbcrConversionFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceScalarBlockLayoutFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSeparateDepthStencilLayoutsFeatures)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShader64BitIndexingFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ABORT_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderAbortFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderAtomicFloat2FeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderAtomicFloatFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderAtomicInt64Features)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderBfloat16FeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_CLOCK_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderClockFeaturesKHR)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_CONSTANT_DATA_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderConstantDataFeaturesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderDemoteToHelperInvocationFeatures)); if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderDrawParametersFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderExpectAssumeFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderFloat16Int8Features)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_FLOAT8_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderFloat8FeaturesEXT)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderFloatControls2Features)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FMA_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderFmaFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderImageAtomicInt64FeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderIntegerDotProductFeatures)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderLongVectorFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME)) @@ -4856,62 +10015,82 @@ if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderQuadControlFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR)); + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderReplicatedCompositesFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderSubgroupExtendedTypesFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderSubgroupRotateFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderTerminateInvocationFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderTileImageFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME)) + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceShaderUntypedPointersFeaturesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSubgroupSizeControlFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSubpassMergeFeedbackFeaturesEXT)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSwapchainMaintenance1FeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSwapchainMaintenance1FeaturesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceSynchronization2Features)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTexelBufferAlignmentFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTextureCompressionASTC3DFeaturesEXT)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTextureCompressionASTCHDRFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTimelineSemaphoreFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceTransformFeedbackFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceUnifiedImageLayoutsFeaturesKHR)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceUniformBufferStandardLayoutFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVariablePointersFeatures)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVertexAttributeDivisorFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVertexAttributeRobustnessFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVertexInputDynamicStateFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVideoDecodeVP9FeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVideoEncodeAV1FeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVideoMaintenance1FeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVideoMaintenance2FeaturesKHR)); if ((gpu.api_version >= VK_API_VERSION_1_2)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVulkan11Features)); if ((gpu.api_version >= VK_API_VERSION_1_2)) @@ -4920,8 +10099,8 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVulkan13Features)); if ((gpu.api_version >= VK_API_VERSION_1_4)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVulkan14Features)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceVulkanMemoryModelFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR)); @@ -4929,748 +10108,1662 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceYcbcrImageArraysFeaturesEXT)); - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT)); + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures)); if (!chain_members.empty()) { - for(size_t i = 0; i < chain_members.size() - 1; i++){ + for (size_t i = 0; i < chain_members.size() - 1; i++) { chain_members[i]->pNext = chain_members[i + 1]; } start_of_chain = chain_members[0]; } } }; -void setup_phys_device_features2_chain(VkPhysicalDeviceFeatures2& start, std::unique_ptr<phys_device_features2_chain>& chain, AppGpu &gpu,bool show_promoted_structs){ +void setup_phys_device_features2_chain(VkPhysicalDeviceFeatures2& start, std::unique_ptr<phys_device_features2_chain>& chain, + AppGpu& gpu, bool show_promoted_structs) { chain = std::unique_ptr<phys_device_features2_chain>(new phys_device_features2_chain()); - chain->initialize_chain(gpu,show_promoted_structs); + chain->initialize_chain(gpu, show_promoted_structs); start.pNext = chain->start_of_chain; }; -void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, bool show_promoted_structs, void * place) { +void chain_iterator_phys_device_features2(Printer& p, AppGpu& gpu, bool show_promoted_structs, const void* place) { while (place) { - struct VkBaseOutStructure *structure = (struct VkBaseOutStructure *)place; + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; p.SetSubHeader(); if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES) { - VkPhysicalDevice16BitStorageFeatures* props = (VkPhysicalDevice16BitStorageFeatures*)structure; - DumpVkPhysicalDevice16BitStorageFeatures(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDevice16BitStorageFeatures":"VkPhysicalDevice16BitStorageFeaturesKHR", *props); + const VkPhysicalDevice16BitStorageFeatures* props = (const VkPhysicalDevice16BitStorageFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDevice16BitStorageFeatures" + : ("VkPhysicalDevice16BitStorageFeaturesKHR"); + DumpVkPhysicalDevice16BitStorageFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevice16BitStorageFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevice16BitStorageFeatures(p, "VkPhysicalDevice16BitStorageFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT) { - VkPhysicalDevice4444FormatsFeaturesEXT* props = (VkPhysicalDevice4444FormatsFeaturesEXT*)structure; - DumpVkPhysicalDevice4444FormatsFeaturesEXT(p, "VkPhysicalDevice4444FormatsFeaturesEXT", *props); + const VkPhysicalDevice4444FormatsFeaturesEXT* props = (const VkPhysicalDevice4444FormatsFeaturesEXT*)structure; + const char* name = "VkPhysicalDevice4444FormatsFeaturesEXT"; + DumpVkPhysicalDevice4444FormatsFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES) { - VkPhysicalDevice8BitStorageFeatures* props = (VkPhysicalDevice8BitStorageFeatures*)structure; - DumpVkPhysicalDevice8BitStorageFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDevice8BitStorageFeatures":"VkPhysicalDevice8BitStorageFeaturesKHR", *props); + const VkPhysicalDevice8BitStorageFeatures* props = (const VkPhysicalDevice8BitStorageFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDevice8BitStorageFeatures" + : ("VkPhysicalDevice8BitStorageFeaturesKHR"); + DumpVkPhysicalDevice8BitStorageFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevice8BitStorageFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevice8BitStorageFeatures(p, "VkPhysicalDevice8BitStorageFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT) { - VkPhysicalDeviceASTCDecodeFeaturesEXT* props = (VkPhysicalDeviceASTCDecodeFeaturesEXT*)structure; - DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(p, "VkPhysicalDeviceASTCDecodeFeaturesEXT", *props); + const VkPhysicalDeviceASTCDecodeFeaturesEXT* props = (const VkPhysicalDeviceASTCDecodeFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceASTCDecodeFeaturesEXT"; + DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR) { - VkPhysicalDeviceAccelerationStructureFeaturesKHR* props = (VkPhysicalDeviceAccelerationStructureFeaturesKHR*)structure; - DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(p, "VkPhysicalDeviceAccelerationStructureFeaturesKHR", *props); + const VkPhysicalDeviceAccelerationStructureFeaturesKHR* props = + (const VkPhysicalDeviceAccelerationStructureFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceAccelerationStructureFeaturesKHR"; + DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT) { - VkPhysicalDeviceAddressBindingReportFeaturesEXT* props = (VkPhysicalDeviceAddressBindingReportFeaturesEXT*)structure; - DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(p, "VkPhysicalDeviceAddressBindingReportFeaturesEXT", *props); + const VkPhysicalDeviceAddressBindingReportFeaturesEXT* props = + (const VkPhysicalDeviceAddressBindingReportFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceAddressBindingReportFeaturesEXT"; + DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT) { - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* props = (VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*)structure; - DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(p, "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT", *props); + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* props = + (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT"; + DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT) { - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* props = (VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*)structure; - DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(p, "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT", *props); + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* props = + (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT"; + DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT) { - VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* props = (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)structure; - DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(p, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", *props); + const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* props = + (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"; + DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT) { - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* props = (VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*)structure; - DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(p, "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT", *props); + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* props = + (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT"; + DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES) { - VkPhysicalDeviceBufferDeviceAddressFeatures* props = (VkPhysicalDeviceBufferDeviceAddressFeatures*)structure; - DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceBufferDeviceAddressFeatures":"VkPhysicalDeviceBufferDeviceAddressFeaturesKHR", *props); + const VkPhysicalDeviceBufferDeviceAddressFeatures* props = + (const VkPhysicalDeviceBufferDeviceAddressFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceBufferDeviceAddressFeatures" + : ("VkPhysicalDeviceBufferDeviceAddressFeaturesKHR"); + DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT) { - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* props = (VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*)structure; - DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT", *props); + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* props = + (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME) + ? "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT" + : ("VkPhysicalDeviceBufferAddressFeaturesEXT"); + DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceBufferAddressFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, "VkPhysicalDeviceBufferAddressFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT) { - VkPhysicalDeviceColorWriteEnableFeaturesEXT* props = (VkPhysicalDeviceColorWriteEnableFeaturesEXT*)structure; - DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(p, "VkPhysicalDeviceColorWriteEnableFeaturesEXT", *props); + const VkPhysicalDeviceColorWriteEnableFeaturesEXT* props = + (const VkPhysicalDeviceColorWriteEnableFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceColorWriteEnableFeaturesEXT"; + DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR) { - VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* props = (VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*)structure; - DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(p, "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR", *props); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* props = + (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME) + ? "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR" + : ("VkPhysicalDeviceComputeShaderDerivativesFeaturesNV"); + DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceComputeShaderDerivativesFeaturesNV") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(p, "VkPhysicalDeviceComputeShaderDerivativesFeaturesNV", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT) { - VkPhysicalDeviceConditionalRenderingFeaturesEXT* props = (VkPhysicalDeviceConditionalRenderingFeaturesEXT*)structure; - DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(p, "VkPhysicalDeviceConditionalRenderingFeaturesEXT", *props); + const VkPhysicalDeviceConditionalRenderingFeaturesEXT* props = + (const VkPhysicalDeviceConditionalRenderingFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceConditionalRenderingFeaturesEXT"; + DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR) { - VkPhysicalDeviceCooperativeMatrixFeaturesKHR* props = (VkPhysicalDeviceCooperativeMatrixFeaturesKHR*)structure; - DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(p, "VkPhysicalDeviceCooperativeMatrixFeaturesKHR", *props); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* props = + (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceCooperativeMatrixFeaturesKHR"; + DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR) { + const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* props = + (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR"; + DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT) { - VkPhysicalDeviceCustomBorderColorFeaturesEXT* props = (VkPhysicalDeviceCustomBorderColorFeaturesEXT*)structure; - DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(p, "VkPhysicalDeviceCustomBorderColorFeaturesEXT", *props); + const VkPhysicalDeviceCustomBorderColorFeaturesEXT* props = + (const VkPhysicalDeviceCustomBorderColorFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceCustomBorderColorFeaturesEXT"; + DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT) { + const VkPhysicalDeviceCustomResolveFeaturesEXT* props = (const VkPhysicalDeviceCustomResolveFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceCustomResolveFeaturesEXT"; + DumpVkPhysicalDeviceCustomResolveFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT) { - VkPhysicalDeviceDepthBiasControlFeaturesEXT* props = (VkPhysicalDeviceDepthBiasControlFeaturesEXT*)structure; - DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(p, "VkPhysicalDeviceDepthBiasControlFeaturesEXT", *props); + const VkPhysicalDeviceDepthBiasControlFeaturesEXT* props = + (const VkPhysicalDeviceDepthBiasControlFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDepthBiasControlFeaturesEXT"; + DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT) { - VkPhysicalDeviceDepthClampControlFeaturesEXT* props = (VkPhysicalDeviceDepthClampControlFeaturesEXT*)structure; - DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(p, "VkPhysicalDeviceDepthClampControlFeaturesEXT", *props); + const VkPhysicalDeviceDepthClampControlFeaturesEXT* props = + (const VkPhysicalDeviceDepthClampControlFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDepthClampControlFeaturesEXT"; + DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(p, name, *props); p.AddNewline(); } - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT) { - VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* props = (VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*)structure; - DumpVkPhysicalDeviceDepthClampZeroOneFeaturesEXT(p, "VkPhysicalDeviceDepthClampZeroOneFeaturesEXT", *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR) { + const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* props = + (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME) + ? "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR" + : ("VkPhysicalDeviceDepthClampZeroOneFeaturesEXT"); + DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDepthClampZeroOneFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(p, "VkPhysicalDeviceDepthClampZeroOneFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT) { - VkPhysicalDeviceDepthClipControlFeaturesEXT* props = (VkPhysicalDeviceDepthClipControlFeaturesEXT*)structure; - DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(p, "VkPhysicalDeviceDepthClipControlFeaturesEXT", *props); + const VkPhysicalDeviceDepthClipControlFeaturesEXT* props = + (const VkPhysicalDeviceDepthClipControlFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDepthClipControlFeaturesEXT"; + DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT) { - VkPhysicalDeviceDepthClipEnableFeaturesEXT* props = (VkPhysicalDeviceDepthClipEnableFeaturesEXT*)structure; - DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(p, "VkPhysicalDeviceDepthClipEnableFeaturesEXT", *props); + const VkPhysicalDeviceDepthClipEnableFeaturesEXT* props = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDepthClipEnableFeaturesEXT"; + DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT) { - VkPhysicalDeviceDescriptorBufferFeaturesEXT* props = (VkPhysicalDeviceDescriptorBufferFeaturesEXT*)structure; - DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(p, "VkPhysicalDeviceDescriptorBufferFeaturesEXT", *props); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT* props = + (const VkPhysicalDeviceDescriptorBufferFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDescriptorBufferFeaturesEXT"; + DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT) { + const VkPhysicalDeviceDescriptorHeapFeaturesEXT* props = (const VkPhysicalDeviceDescriptorHeapFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDescriptorHeapFeaturesEXT"; + DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES) { - VkPhysicalDeviceDescriptorIndexingFeatures* props = (VkPhysicalDeviceDescriptorIndexingFeatures*)structure; - DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceDescriptorIndexingFeatures":"VkPhysicalDeviceDescriptorIndexingFeaturesEXT", *props); + const VkPhysicalDeviceDescriptorIndexingFeatures* props = (const VkPhysicalDeviceDescriptorIndexingFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDescriptorIndexingFeatures" + : ("VkPhysicalDeviceDescriptorIndexingFeaturesEXT"); + DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDescriptorIndexingFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, "VkPhysicalDeviceDescriptorIndexingFeaturesEXT", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR) { + const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR* props = + (const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR"; + DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT) { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* props = (VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*)structure; - DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(p, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT", *props); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* props = + (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT"; + DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT) { - VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* props = (VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*)structure; - DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(p, "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT", *props); + const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* props = + (const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT"; + DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES) { - VkPhysicalDeviceDynamicRenderingFeatures* props = (VkPhysicalDeviceDynamicRenderingFeatures*)structure; - DumpVkPhysicalDeviceDynamicRenderingFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceDynamicRenderingFeatures":"VkPhysicalDeviceDynamicRenderingFeaturesKHR", *props); + const VkPhysicalDeviceDynamicRenderingFeatures* props = (const VkPhysicalDeviceDynamicRenderingFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceDynamicRenderingFeatures" + : ("VkPhysicalDeviceDynamicRenderingFeaturesKHR"); + DumpVkPhysicalDeviceDynamicRenderingFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDynamicRenderingFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceDynamicRenderingFeatures(p, "VkPhysicalDeviceDynamicRenderingFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES) { - VkPhysicalDeviceDynamicRenderingLocalReadFeatures* props = (VkPhysicalDeviceDynamicRenderingLocalReadFeatures*)structure; - DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceDynamicRenderingLocalReadFeatures":"VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR", *props); + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* props = + (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceDynamicRenderingLocalReadFeatures" + : ("VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR"); + DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(p, "VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT) { - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* props = (VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*)structure; - DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(p, "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT", *props); + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* props = + (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT"; + DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT) { - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* props = (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*)structure; - DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(p, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", *props); + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* props = + (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"; + DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT) { - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* props = (VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*)structure; - DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(p, "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT", *props); + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* props = + (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT"; + DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT) { - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* props = (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*)structure; - DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(p, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", *props); + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* props = + (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT"; + DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT) { - VkPhysicalDeviceFaultFeaturesEXT* props = (VkPhysicalDeviceFaultFeaturesEXT*)structure; - DumpVkPhysicalDeviceFaultFeaturesEXT(p, "VkPhysicalDeviceFaultFeaturesEXT", *props); + const VkPhysicalDeviceFaultFeaturesEXT* props = (const VkPhysicalDeviceFaultFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceFaultFeaturesEXT"; + DumpVkPhysicalDeviceFaultFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR) { + const VkPhysicalDeviceFaultFeaturesKHR* props = (const VkPhysicalDeviceFaultFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceFaultFeaturesKHR"; + DumpVkPhysicalDeviceFaultFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT) { - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* props = (VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*)structure; - DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(p, "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT", *props); + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* props = + (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT"; + DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT) { - VkPhysicalDeviceFragmentDensityMapFeaturesEXT* props = (VkPhysicalDeviceFragmentDensityMapFeaturesEXT*)structure; - DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(p, "VkPhysicalDeviceFragmentDensityMapFeaturesEXT", *props); + const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* props = + (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceFragmentDensityMapFeaturesEXT"; + DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT) { + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* props = + (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) + ? "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT" + : ("VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM"); + DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(p, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR) { - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* props = (VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*)structure; - DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(p, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR", *props); + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* props = + (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME) + ? "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR" + : ("VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV"); + DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(p, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT) { - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* props = (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*)structure; - DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(p, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", *props); + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* props = + (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"; + DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR) { - VkPhysicalDeviceFragmentShadingRateFeaturesKHR* props = (VkPhysicalDeviceFragmentShadingRateFeaturesKHR*)structure; - DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(p, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR", *props); + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* props = + (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceFragmentShadingRateFeaturesKHR"; + DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT) { - VkPhysicalDeviceFrameBoundaryFeaturesEXT* props = (VkPhysicalDeviceFrameBoundaryFeaturesEXT*)structure; - DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(p, "VkPhysicalDeviceFrameBoundaryFeaturesEXT", *props); + const VkPhysicalDeviceFrameBoundaryFeaturesEXT* props = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceFrameBoundaryFeaturesEXT"; + DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES) { - VkPhysicalDeviceGlobalPriorityQueryFeatures* props = (VkPhysicalDeviceGlobalPriorityQueryFeatures*)structure; - DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceGlobalPriorityQueryFeatures":"VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT", *props); + const VkPhysicalDeviceGlobalPriorityQueryFeatures* props = + (const VkPhysicalDeviceGlobalPriorityQueryFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 + ? "VkPhysicalDeviceGlobalPriorityQueryFeatures" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) + ? "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR" + : ("VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT")); + DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR", *props); + } + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, "VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT) { - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* props = (VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*)structure; - DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(p, "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT", *props); + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* props = + (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT"; + DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES) { - VkPhysicalDeviceHostImageCopyFeatures* props = (VkPhysicalDeviceHostImageCopyFeatures*)structure; - DumpVkPhysicalDeviceHostImageCopyFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceHostImageCopyFeatures":"VkPhysicalDeviceHostImageCopyFeaturesEXT", *props); + const VkPhysicalDeviceHostImageCopyFeatures* props = (const VkPhysicalDeviceHostImageCopyFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceHostImageCopyFeatures" + : ("VkPhysicalDeviceHostImageCopyFeaturesEXT"); + DumpVkPhysicalDeviceHostImageCopyFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostImageCopyFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceHostImageCopyFeatures(p, "VkPhysicalDeviceHostImageCopyFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES) { - VkPhysicalDeviceHostQueryResetFeatures* props = (VkPhysicalDeviceHostQueryResetFeatures*)structure; - DumpVkPhysicalDeviceHostQueryResetFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceHostQueryResetFeatures":"VkPhysicalDeviceHostQueryResetFeaturesEXT", *props); + const VkPhysicalDeviceHostQueryResetFeatures* props = (const VkPhysicalDeviceHostQueryResetFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceHostQueryResetFeatures" + : ("VkPhysicalDeviceHostQueryResetFeaturesEXT"); + DumpVkPhysicalDeviceHostQueryResetFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostQueryResetFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceHostQueryResetFeatures(p, "VkPhysicalDeviceHostQueryResetFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT) { - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* props = (VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*)structure; - DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(p, "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT", *props); + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* props = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT"; + DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT) { - VkPhysicalDeviceImageCompressionControlFeaturesEXT* props = (VkPhysicalDeviceImageCompressionControlFeaturesEXT*)structure; - DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(p, "VkPhysicalDeviceImageCompressionControlFeaturesEXT", *props); + const VkPhysicalDeviceImageCompressionControlFeaturesEXT* props = + (const VkPhysicalDeviceImageCompressionControlFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceImageCompressionControlFeaturesEXT"; + DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT) { - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* props = (VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*)structure; - DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(p, "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT", *props); + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* props = + (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT"; + DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES) { - VkPhysicalDeviceImageRobustnessFeatures* props = (VkPhysicalDeviceImageRobustnessFeatures*)structure; - DumpVkPhysicalDeviceImageRobustnessFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceImageRobustnessFeatures":"VkPhysicalDeviceImageRobustnessFeaturesEXT", *props); + const VkPhysicalDeviceImageRobustnessFeatures* props = (const VkPhysicalDeviceImageRobustnessFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceImageRobustnessFeatures" + : ("VkPhysicalDeviceImageRobustnessFeaturesEXT"); + DumpVkPhysicalDeviceImageRobustnessFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceImageRobustnessFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceImageRobustnessFeatures(p, "VkPhysicalDeviceImageRobustnessFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT) { - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* props = (VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*)structure; - DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(p, "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT", *props); + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* props = + (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT"; + DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT) { - VkPhysicalDeviceImageViewMinLodFeaturesEXT* props = (VkPhysicalDeviceImageViewMinLodFeaturesEXT*)structure; - DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(p, "VkPhysicalDeviceImageViewMinLodFeaturesEXT", *props); + const VkPhysicalDeviceImageViewMinLodFeaturesEXT* props = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceImageViewMinLodFeaturesEXT"; + DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES) { - VkPhysicalDeviceImagelessFramebufferFeatures* props = (VkPhysicalDeviceImagelessFramebufferFeatures*)structure; - DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceImagelessFramebufferFeatures":"VkPhysicalDeviceImagelessFramebufferFeaturesKHR", *props); + const VkPhysicalDeviceImagelessFramebufferFeatures* props = + (const VkPhysicalDeviceImagelessFramebufferFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceImagelessFramebufferFeatures" + : ("VkPhysicalDeviceImagelessFramebufferFeaturesKHR"); + DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceImagelessFramebufferFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, "VkPhysicalDeviceImagelessFramebufferFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES) { - VkPhysicalDeviceIndexTypeUint8Features* props = (VkPhysicalDeviceIndexTypeUint8Features*)structure; - DumpVkPhysicalDeviceIndexTypeUint8Features(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceIndexTypeUint8Features":"VkPhysicalDeviceIndexTypeUint8FeaturesKHR", *props); + const VkPhysicalDeviceIndexTypeUint8Features* props = (const VkPhysicalDeviceIndexTypeUint8Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 + ? "VkPhysicalDeviceIndexTypeUint8Features" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME) + ? "VkPhysicalDeviceIndexTypeUint8FeaturesKHR" + : ("VkPhysicalDeviceIndexTypeUint8FeaturesEXT")); + DumpVkPhysicalDeviceIndexTypeUint8Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIndexTypeUint8FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceIndexTypeUint8Features(p, "VkPhysicalDeviceIndexTypeUint8FeaturesKHR", *props); + } + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceIndexTypeUint8Features(p, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES) { - VkPhysicalDeviceInlineUniformBlockFeatures* props = (VkPhysicalDeviceInlineUniformBlockFeatures*)structure; - DumpVkPhysicalDeviceInlineUniformBlockFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceInlineUniformBlockFeatures":"VkPhysicalDeviceInlineUniformBlockFeaturesEXT", *props); + const VkPhysicalDeviceInlineUniformBlockFeatures* props = (const VkPhysicalDeviceInlineUniformBlockFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceInlineUniformBlockFeatures" + : ("VkPhysicalDeviceInlineUniformBlockFeaturesEXT"); + DumpVkPhysicalDeviceInlineUniformBlockFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceInlineUniformBlockFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceInlineUniformBlockFeatures(p, "VkPhysicalDeviceInlineUniformBlockFeaturesEXT", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR) { + const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR* props = + (const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR"; + DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT) { - VkPhysicalDeviceLegacyDitheringFeaturesEXT* props = (VkPhysicalDeviceLegacyDitheringFeaturesEXT*)structure; - DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(p, "VkPhysicalDeviceLegacyDitheringFeaturesEXT", *props); + const VkPhysicalDeviceLegacyDitheringFeaturesEXT* props = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceLegacyDitheringFeaturesEXT"; + DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT) { - VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* props = (VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*)structure; - DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(p, "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT", *props); + const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* props = + (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT"; + DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES) { - VkPhysicalDeviceLineRasterizationFeatures* props = (VkPhysicalDeviceLineRasterizationFeatures*)structure; - DumpVkPhysicalDeviceLineRasterizationFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceLineRasterizationFeatures":"VkPhysicalDeviceLineRasterizationFeaturesKHR", *props); + const VkPhysicalDeviceLineRasterizationFeatures* props = (const VkPhysicalDeviceLineRasterizationFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 + ? "VkPhysicalDeviceLineRasterizationFeatures" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) + ? "VkPhysicalDeviceLineRasterizationFeaturesKHR" + : ("VkPhysicalDeviceLineRasterizationFeaturesEXT")); + DumpVkPhysicalDeviceLineRasterizationFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceLineRasterizationFeatures(p, "VkPhysicalDeviceLineRasterizationFeaturesKHR", *props); + } + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceLineRasterizationFeatures(p, "VkPhysicalDeviceLineRasterizationFeaturesEXT", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR) { + const VkPhysicalDeviceMaintenance10FeaturesKHR* props = (const VkPhysicalDeviceMaintenance10FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance10FeaturesKHR"; + DumpVkPhysicalDeviceMaintenance10FeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR) { + const VkPhysicalDeviceMaintenance11FeaturesKHR* props = (const VkPhysicalDeviceMaintenance11FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance11FeaturesKHR"; + DumpVkPhysicalDeviceMaintenance11FeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES) { - VkPhysicalDeviceMaintenance4Features* props = (VkPhysicalDeviceMaintenance4Features*)structure; - DumpVkPhysicalDeviceMaintenance4Features(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceMaintenance4Features":"VkPhysicalDeviceMaintenance4FeaturesKHR", *props); + const VkPhysicalDeviceMaintenance4Features* props = (const VkPhysicalDeviceMaintenance4Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceMaintenance4Features" + : ("VkPhysicalDeviceMaintenance4FeaturesKHR"); + DumpVkPhysicalDeviceMaintenance4Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance4FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMaintenance4Features(p, "VkPhysicalDeviceMaintenance4FeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES) { - VkPhysicalDeviceMaintenance5Features* props = (VkPhysicalDeviceMaintenance5Features*)structure; - DumpVkPhysicalDeviceMaintenance5Features(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceMaintenance5Features":"VkPhysicalDeviceMaintenance5FeaturesKHR", *props); + const VkPhysicalDeviceMaintenance5Features* props = (const VkPhysicalDeviceMaintenance5Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance5Features" + : ("VkPhysicalDeviceMaintenance5FeaturesKHR"); + DumpVkPhysicalDeviceMaintenance5Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance5FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMaintenance5Features(p, "VkPhysicalDeviceMaintenance5FeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES) { - VkPhysicalDeviceMaintenance6Features* props = (VkPhysicalDeviceMaintenance6Features*)structure; - DumpVkPhysicalDeviceMaintenance6Features(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceMaintenance6Features":"VkPhysicalDeviceMaintenance6FeaturesKHR", *props); + const VkPhysicalDeviceMaintenance6Features* props = (const VkPhysicalDeviceMaintenance6Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance6Features" + : ("VkPhysicalDeviceMaintenance6FeaturesKHR"); + DumpVkPhysicalDeviceMaintenance6Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance6FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMaintenance6Features(p, "VkPhysicalDeviceMaintenance6FeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR) { - VkPhysicalDeviceMaintenance7FeaturesKHR* props = (VkPhysicalDeviceMaintenance7FeaturesKHR*)structure; - DumpVkPhysicalDeviceMaintenance7FeaturesKHR(p, "VkPhysicalDeviceMaintenance7FeaturesKHR", *props); + const VkPhysicalDeviceMaintenance7FeaturesKHR* props = (const VkPhysicalDeviceMaintenance7FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance7FeaturesKHR"; + DumpVkPhysicalDeviceMaintenance7FeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR) { + const VkPhysicalDeviceMaintenance8FeaturesKHR* props = (const VkPhysicalDeviceMaintenance8FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance8FeaturesKHR"; + DumpVkPhysicalDeviceMaintenance8FeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR) { + const VkPhysicalDeviceMaintenance9FeaturesKHR* props = (const VkPhysicalDeviceMaintenance9FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceMaintenance9FeaturesKHR"; + DumpVkPhysicalDeviceMaintenance9FeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT) { - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* props = (VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*)structure; - DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(p, "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT", *props); + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* props = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT"; + DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT) { + const VkPhysicalDeviceMemoryDecompressionFeaturesEXT* props = + (const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME) + ? "VkPhysicalDeviceMemoryDecompressionFeaturesEXT" + : ("VkPhysicalDeviceMemoryDecompressionFeaturesNV"); + DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMemoryDecompressionFeaturesNV") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(p, "VkPhysicalDeviceMemoryDecompressionFeaturesNV", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT) { - VkPhysicalDeviceMemoryPriorityFeaturesEXT* props = (VkPhysicalDeviceMemoryPriorityFeaturesEXT*)structure; - DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(p, "VkPhysicalDeviceMemoryPriorityFeaturesEXT", *props); + const VkPhysicalDeviceMemoryPriorityFeaturesEXT* props = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceMemoryPriorityFeaturesEXT"; + DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT) { - VkPhysicalDeviceMeshShaderFeaturesEXT* props = (VkPhysicalDeviceMeshShaderFeaturesEXT*)structure; - DumpVkPhysicalDeviceMeshShaderFeaturesEXT(p, "VkPhysicalDeviceMeshShaderFeaturesEXT", *props); + const VkPhysicalDeviceMeshShaderFeaturesEXT* props = (const VkPhysicalDeviceMeshShaderFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceMeshShaderFeaturesEXT"; + DumpVkPhysicalDeviceMeshShaderFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT) { - VkPhysicalDeviceMultiDrawFeaturesEXT* props = (VkPhysicalDeviceMultiDrawFeaturesEXT*)structure; - DumpVkPhysicalDeviceMultiDrawFeaturesEXT(p, "VkPhysicalDeviceMultiDrawFeaturesEXT", *props); + const VkPhysicalDeviceMultiDrawFeaturesEXT* props = (const VkPhysicalDeviceMultiDrawFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceMultiDrawFeaturesEXT"; + DumpVkPhysicalDeviceMultiDrawFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT) { - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* props = (VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*)structure; - DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(p, "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT", *props); + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* props = + (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT"; + DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES) { - VkPhysicalDeviceMultiviewFeatures* props = (VkPhysicalDeviceMultiviewFeatures*)structure; - DumpVkPhysicalDeviceMultiviewFeatures(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDeviceMultiviewFeatures":"VkPhysicalDeviceMultiviewFeaturesKHR", *props); + const VkPhysicalDeviceMultiviewFeatures* props = (const VkPhysicalDeviceMultiviewFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMultiviewFeatures" + : ("VkPhysicalDeviceMultiviewFeaturesKHR"); + DumpVkPhysicalDeviceMultiviewFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMultiviewFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMultiviewFeatures(p, "VkPhysicalDeviceMultiviewFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT) { - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* props = (VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*)structure; - DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(p, "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT", *props); + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* props = + (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME) + ? "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT" + : ("VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE"); + DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(p, "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT) { - VkPhysicalDeviceNestedCommandBufferFeaturesEXT* props = (VkPhysicalDeviceNestedCommandBufferFeaturesEXT*)structure; - DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(p, "VkPhysicalDeviceNestedCommandBufferFeaturesEXT", *props); + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* props = + (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceNestedCommandBufferFeaturesEXT"; + DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT) { - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* props = (VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*)structure; - DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(p, "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT", *props); + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* props = + (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT"; + DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT) { - VkPhysicalDeviceOpacityMicromapFeaturesEXT* props = (VkPhysicalDeviceOpacityMicromapFeaturesEXT*)structure; - DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(p, "VkPhysicalDeviceOpacityMicromapFeaturesEXT", *props); + const VkPhysicalDeviceOpacityMicromapFeaturesEXT* props = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceOpacityMicromapFeaturesEXT"; + DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT) { - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* props = (VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*)structure; - DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(p, "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT", *props); + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* props = + (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*)structure; + const char* name = "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT"; + DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR) { - VkPhysicalDevicePerformanceQueryFeaturesKHR* props = (VkPhysicalDevicePerformanceQueryFeaturesKHR*)structure; - DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(p, "VkPhysicalDevicePerformanceQueryFeaturesKHR", *props); + const VkPhysicalDevicePerformanceQueryFeaturesKHR* props = + (const VkPhysicalDevicePerformanceQueryFeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePerformanceQueryFeaturesKHR"; + DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR) { - VkPhysicalDevicePipelineBinaryFeaturesKHR* props = (VkPhysicalDevicePipelineBinaryFeaturesKHR*)structure; - DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(p, "VkPhysicalDevicePipelineBinaryFeaturesKHR", *props); + const VkPhysicalDevicePipelineBinaryFeaturesKHR* props = (const VkPhysicalDevicePipelineBinaryFeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePipelineBinaryFeaturesKHR"; + DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES) { - VkPhysicalDevicePipelineCreationCacheControlFeatures* props = (VkPhysicalDevicePipelineCreationCacheControlFeatures*)structure; - DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDevicePipelineCreationCacheControlFeatures":"VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT", *props); + const VkPhysicalDevicePipelineCreationCacheControlFeatures* props = + (const VkPhysicalDevicePipelineCreationCacheControlFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDevicePipelineCreationCacheControlFeatures" + : ("VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT"); + DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePipelineCreationCacheControlFeatures( + p, "VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR) { - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* props = (VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*)structure; - DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(p, "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR", *props); + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* props = + (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR"; + DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT) { - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* props = (VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*)structure; - DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(p, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT", *props); + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* props = + (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*)structure; + const char* name = "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"; + DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT) { - VkPhysicalDevicePipelinePropertiesFeaturesEXT* props = (VkPhysicalDevicePipelinePropertiesFeaturesEXT*)structure; - DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(p, "VkPhysicalDevicePipelinePropertiesFeaturesEXT", *props); + const VkPhysicalDevicePipelinePropertiesFeaturesEXT* props = + (const VkPhysicalDevicePipelinePropertiesFeaturesEXT*)structure; + const char* name = "VkPhysicalDevicePipelinePropertiesFeaturesEXT"; + DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES) { - VkPhysicalDevicePipelineProtectedAccessFeatures* props = (VkPhysicalDevicePipelineProtectedAccessFeatures*)structure; - DumpVkPhysicalDevicePipelineProtectedAccessFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDevicePipelineProtectedAccessFeatures":"VkPhysicalDevicePipelineProtectedAccessFeaturesEXT", *props); + const VkPhysicalDevicePipelineProtectedAccessFeatures* props = + (const VkPhysicalDevicePipelineProtectedAccessFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineProtectedAccessFeatures" + : ("VkPhysicalDevicePipelineProtectedAccessFeaturesEXT"); + DumpVkPhysicalDevicePipelineProtectedAccessFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineProtectedAccessFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePipelineProtectedAccessFeatures(p, "VkPhysicalDevicePipelineProtectedAccessFeaturesEXT", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES) { - VkPhysicalDevicePipelineRobustnessFeatures* props = (VkPhysicalDevicePipelineRobustnessFeatures*)structure; - DumpVkPhysicalDevicePipelineRobustnessFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDevicePipelineRobustnessFeatures":"VkPhysicalDevicePipelineRobustnessFeaturesEXT", *props); + const VkPhysicalDevicePipelineRobustnessFeatures* props = (const VkPhysicalDevicePipelineRobustnessFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineRobustnessFeatures" + : ("VkPhysicalDevicePipelineRobustnessFeaturesEXT"); + DumpVkPhysicalDevicePipelineRobustnessFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineRobustnessFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePipelineRobustnessFeatures(p, "VkPhysicalDevicePipelineRobustnessFeaturesEXT", *props); + } p.AddNewline(); } #ifdef VK_ENABLE_BETA_EXTENSIONS if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR && p.Type() != OutputType::json) { - VkPhysicalDevicePortabilitySubsetFeaturesKHR* props = (VkPhysicalDevicePortabilitySubsetFeaturesKHR*)structure; - DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(p, "VkPhysicalDevicePortabilitySubsetFeaturesKHR", *props); + const VkPhysicalDevicePortabilitySubsetFeaturesKHR* props = + (const VkPhysicalDevicePortabilitySubsetFeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePortabilitySubsetFeaturesKHR"; + DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(p, name, *props); p.AddNewline(); } #endif // VK_ENABLE_BETA_EXTENSIONS - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR) { - VkPhysicalDevicePresentIdFeaturesKHR* props = (VkPhysicalDevicePresentIdFeaturesKHR*)structure; - DumpVkPhysicalDevicePresentIdFeaturesKHR(p, "VkPhysicalDevicePresentIdFeaturesKHR", *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR) { + const VkPhysicalDevicePresentId2FeaturesKHR* props = (const VkPhysicalDevicePresentId2FeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePresentId2FeaturesKHR"; + DumpVkPhysicalDevicePresentId2FeaturesKHR(p, name, *props); p.AddNewline(); } - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT) { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* props = (VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT*)structure; - DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(p, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT", *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR) { + const VkPhysicalDevicePresentIdFeaturesKHR* props = (const VkPhysicalDevicePresentIdFeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePresentIdFeaturesKHR"; + DumpVkPhysicalDevicePresentIdFeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR) { + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* props = + (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME) + ? "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR" + : ("VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT"); + DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( + p, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT) { + const VkPhysicalDevicePresentTimingFeaturesEXT* props = (const VkPhysicalDevicePresentTimingFeaturesEXT*)structure; + const char* name = "VkPhysicalDevicePresentTimingFeaturesEXT"; + DumpVkPhysicalDevicePresentTimingFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR) { + const VkPhysicalDevicePresentWait2FeaturesKHR* props = (const VkPhysicalDevicePresentWait2FeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePresentWait2FeaturesKHR"; + DumpVkPhysicalDevicePresentWait2FeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR) { - VkPhysicalDevicePresentWaitFeaturesKHR* props = (VkPhysicalDevicePresentWaitFeaturesKHR*)structure; - DumpVkPhysicalDevicePresentWaitFeaturesKHR(p, "VkPhysicalDevicePresentWaitFeaturesKHR", *props); + const VkPhysicalDevicePresentWaitFeaturesKHR* props = (const VkPhysicalDevicePresentWaitFeaturesKHR*)structure; + const char* name = "VkPhysicalDevicePresentWaitFeaturesKHR"; + DumpVkPhysicalDevicePresentWaitFeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT) { + const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT* props = + (const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*)structure; + const char* name = "VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT"; + DumpVkPhysicalDevicePrimitiveRestartIndexFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT) { - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* props = (VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*)structure; - DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(p, "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT", *props); + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* props = + (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*)structure; + const char* name = "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"; + DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT) { - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* props = (VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*)structure; - DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(p, "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT", *props); + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* props = + (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*)structure; + const char* name = "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"; + DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES) { - VkPhysicalDevicePrivateDataFeatures* props = (VkPhysicalDevicePrivateDataFeatures*)structure; - DumpVkPhysicalDevicePrivateDataFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDevicePrivateDataFeatures":"VkPhysicalDevicePrivateDataFeaturesEXT", *props); + const VkPhysicalDevicePrivateDataFeatures* props = (const VkPhysicalDevicePrivateDataFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDevicePrivateDataFeatures" + : ("VkPhysicalDevicePrivateDataFeaturesEXT"); + DumpVkPhysicalDevicePrivateDataFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePrivateDataFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIVATE_DATA_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePrivateDataFeatures(p, "VkPhysicalDevicePrivateDataFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES) { - VkPhysicalDeviceProtectedMemoryFeatures* props = (VkPhysicalDeviceProtectedMemoryFeatures*)structure; - DumpVkPhysicalDeviceProtectedMemoryFeatures(p, "VkPhysicalDeviceProtectedMemoryFeatures", *props); + const VkPhysicalDeviceProtectedMemoryFeatures* props = (const VkPhysicalDeviceProtectedMemoryFeatures*)structure; + const char* name = "VkPhysicalDeviceProtectedMemoryFeatures"; + DumpVkPhysicalDeviceProtectedMemoryFeatures(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT) { - VkPhysicalDeviceProvokingVertexFeaturesEXT* props = (VkPhysicalDeviceProvokingVertexFeaturesEXT*)structure; - DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(p, "VkPhysicalDeviceProvokingVertexFeaturesEXT", *props); + const VkPhysicalDeviceProvokingVertexFeaturesEXT* props = (const VkPhysicalDeviceProvokingVertexFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceProvokingVertexFeaturesEXT"; + DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT) { - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* props = (VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*)structure; - DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(p, "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT", *props); + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* props = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT"; + DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT) { - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* props = (VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*)structure; - DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(p, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT", *props); + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* props = + (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME) + ? "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT" + : ("VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM"); + DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + p, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR) { - VkPhysicalDeviceRayQueryFeaturesKHR* props = (VkPhysicalDeviceRayQueryFeaturesKHR*)structure; - DumpVkPhysicalDeviceRayQueryFeaturesKHR(p, "VkPhysicalDeviceRayQueryFeaturesKHR", *props); + const VkPhysicalDeviceRayQueryFeaturesKHR* props = (const VkPhysicalDeviceRayQueryFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceRayQueryFeaturesKHR"; + DumpVkPhysicalDeviceRayQueryFeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT) { + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT* props = + (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT"; + DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR) { - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* props = (VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*)structure; - DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(p, "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR", *props); + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* props = + (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR"; + DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR) { - VkPhysicalDeviceRayTracingPipelineFeaturesKHR* props = (VkPhysicalDeviceRayTracingPipelineFeaturesKHR*)structure; - DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(p, "VkPhysicalDeviceRayTracingPipelineFeaturesKHR", *props); + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* props = + (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceRayTracingPipelineFeaturesKHR"; + DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR) { - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* props = (VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*)structure; - DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(p, "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR", *props); + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* props = + (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR"; + DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(p, name, *props); p.AddNewline(); } - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT) { - VkPhysicalDeviceRobustness2FeaturesEXT* props = (VkPhysicalDeviceRobustness2FeaturesEXT*)structure; - DumpVkPhysicalDeviceRobustness2FeaturesEXT(p, "VkPhysicalDeviceRobustness2FeaturesEXT", *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR) { + const VkPhysicalDeviceRobustness2FeaturesKHR* props = (const VkPhysicalDeviceRobustness2FeaturesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) + ? "VkPhysicalDeviceRobustness2FeaturesKHR" + : ("VkPhysicalDeviceRobustness2FeaturesEXT"); + DumpVkPhysicalDeviceRobustness2FeaturesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRobustness2FeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceRobustness2FeaturesKHR(p, "VkPhysicalDeviceRobustness2FeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES) { - VkPhysicalDeviceSamplerYcbcrConversionFeatures* props = (VkPhysicalDeviceSamplerYcbcrConversionFeatures*)structure; - DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDeviceSamplerYcbcrConversionFeatures":"VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR", *props); + const VkPhysicalDeviceSamplerYcbcrConversionFeatures* props = + (const VkPhysicalDeviceSamplerYcbcrConversionFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceSamplerYcbcrConversionFeatures" + : ("VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR"); + DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES) { - VkPhysicalDeviceScalarBlockLayoutFeatures* props = (VkPhysicalDeviceScalarBlockLayoutFeatures*)structure; - DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceScalarBlockLayoutFeatures":"VkPhysicalDeviceScalarBlockLayoutFeaturesEXT", *props); + const VkPhysicalDeviceScalarBlockLayoutFeatures* props = (const VkPhysicalDeviceScalarBlockLayoutFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceScalarBlockLayoutFeatures" + : ("VkPhysicalDeviceScalarBlockLayoutFeaturesEXT"); + DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceScalarBlockLayoutFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, "VkPhysicalDeviceScalarBlockLayoutFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES) { - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* props = (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*)structure; - DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures":"VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR", *props); + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* props = + (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures" + : ("VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR"); + DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR", + *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT) { + const VkPhysicalDeviceShader64BitIndexingFeaturesEXT* props = + (const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShader64BitIndexingFeaturesEXT"; + DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR) { + const VkPhysicalDeviceShaderAbortFeaturesKHR* props = (const VkPhysicalDeviceShaderAbortFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderAbortFeaturesKHR"; + DumpVkPhysicalDeviceShaderAbortFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT) { - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* props = (VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*)structure; - DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(p, "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT", *props); + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* props = + (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"; + DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT) { - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* props = (VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*)structure; - DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(p, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT", *props); + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* props = + (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"; + DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES) { - VkPhysicalDeviceShaderAtomicInt64Features* props = (VkPhysicalDeviceShaderAtomicInt64Features*)structure; - DumpVkPhysicalDeviceShaderAtomicInt64Features(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceShaderAtomicInt64Features":"VkPhysicalDeviceShaderAtomicInt64FeaturesKHR", *props); + const VkPhysicalDeviceShaderAtomicInt64Features* props = (const VkPhysicalDeviceShaderAtomicInt64Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceShaderAtomicInt64Features" + : ("VkPhysicalDeviceShaderAtomicInt64FeaturesKHR"); + DumpVkPhysicalDeviceShaderAtomicInt64Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderAtomicInt64FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderAtomicInt64Features(p, "VkPhysicalDeviceShaderAtomicInt64FeaturesKHR", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR) { + const VkPhysicalDeviceShaderBfloat16FeaturesKHR* props = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderBfloat16FeaturesKHR"; + DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR) { - VkPhysicalDeviceShaderClockFeaturesKHR* props = (VkPhysicalDeviceShaderClockFeaturesKHR*)structure; - DumpVkPhysicalDeviceShaderClockFeaturesKHR(p, "VkPhysicalDeviceShaderClockFeaturesKHR", *props); + const VkPhysicalDeviceShaderClockFeaturesKHR* props = (const VkPhysicalDeviceShaderClockFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderClockFeaturesKHR"; + DumpVkPhysicalDeviceShaderClockFeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR) { + const VkPhysicalDeviceShaderConstantDataFeaturesKHR* props = + (const VkPhysicalDeviceShaderConstantDataFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderConstantDataFeaturesKHR"; + DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES) { - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* props = (VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*)structure; - DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures":"VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", *props); + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* props = + (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 + ? "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures" + : ("VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT"); + DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures( + p, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES) { - VkPhysicalDeviceShaderDrawParametersFeatures* props = (VkPhysicalDeviceShaderDrawParametersFeatures*)structure; - DumpVkPhysicalDeviceShaderDrawParametersFeatures(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDeviceShaderDrawParametersFeatures":"VkPhysicalDeviceShaderDrawParameterFeatures", *props); + const VkPhysicalDeviceShaderDrawParametersFeatures* props = + (const VkPhysicalDeviceShaderDrawParametersFeatures*)structure; + const char* name = "VkPhysicalDeviceShaderDrawParametersFeatures"; + DumpVkPhysicalDeviceShaderDrawParametersFeatures(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES) { - VkPhysicalDeviceShaderExpectAssumeFeatures* props = (VkPhysicalDeviceShaderExpectAssumeFeatures*)structure; - DumpVkPhysicalDeviceShaderExpectAssumeFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceShaderExpectAssumeFeatures":"VkPhysicalDeviceShaderExpectAssumeFeaturesKHR", *props); + const VkPhysicalDeviceShaderExpectAssumeFeatures* props = (const VkPhysicalDeviceShaderExpectAssumeFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderExpectAssumeFeatures" + : ("VkPhysicalDeviceShaderExpectAssumeFeaturesKHR"); + DumpVkPhysicalDeviceShaderExpectAssumeFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderExpectAssumeFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderExpectAssumeFeatures(p, "VkPhysicalDeviceShaderExpectAssumeFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES) { - VkPhysicalDeviceShaderFloat16Int8Features* props = (VkPhysicalDeviceShaderFloat16Int8Features*)structure; - DumpVkPhysicalDeviceShaderFloat16Int8Features(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceShaderFloat16Int8Features":"VkPhysicalDeviceFloat16Int8FeaturesKHR", *props); + const VkPhysicalDeviceShaderFloat16Int8Features* props = (const VkPhysicalDeviceShaderFloat16Int8Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 + ? "VkPhysicalDeviceShaderFloat16Int8Features" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME) + ? "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR" + : ("VkPhysicalDeviceFloat16Int8FeaturesKHR")); + DumpVkPhysicalDeviceShaderFloat16Int8Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderFloat16Int8Features(p, "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR", *props); + } + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFloat16Int8FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderFloat16Int8Features(p, "VkPhysicalDeviceFloat16Int8FeaturesKHR", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT) { + const VkPhysicalDeviceShaderFloat8FeaturesEXT* props = (const VkPhysicalDeviceShaderFloat8FeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderFloat8FeaturesEXT"; + DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES) { - VkPhysicalDeviceShaderFloatControls2Features* props = (VkPhysicalDeviceShaderFloatControls2Features*)structure; - DumpVkPhysicalDeviceShaderFloatControls2Features(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceShaderFloatControls2Features":"VkPhysicalDeviceShaderFloatControls2FeaturesKHR", *props); + const VkPhysicalDeviceShaderFloatControls2Features* props = + (const VkPhysicalDeviceShaderFloatControls2Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderFloatControls2Features" + : ("VkPhysicalDeviceShaderFloatControls2FeaturesKHR"); + DumpVkPhysicalDeviceShaderFloatControls2Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderFloatControls2FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderFloatControls2Features(p, "VkPhysicalDeviceShaderFloatControls2FeaturesKHR", *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR) { + const VkPhysicalDeviceShaderFmaFeaturesKHR* props = (const VkPhysicalDeviceShaderFmaFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderFmaFeaturesKHR"; + DumpVkPhysicalDeviceShaderFmaFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT) { - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* props = (VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*)structure; - DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(p, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT", *props); + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* props = + (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"; + DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES) { - VkPhysicalDeviceShaderIntegerDotProductFeatures* props = (VkPhysicalDeviceShaderIntegerDotProductFeatures*)structure; - DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceShaderIntegerDotProductFeatures":"VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR", *props); + const VkPhysicalDeviceShaderIntegerDotProductFeatures* props = + (const VkPhysicalDeviceShaderIntegerDotProductFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderIntegerDotProductFeatures" + : ("VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR"); + DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(p, "VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR", + *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT) { + const VkPhysicalDeviceShaderLongVectorFeaturesEXT* props = + (const VkPhysicalDeviceShaderLongVectorFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderLongVectorFeaturesEXT"; + DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR) { - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* props = (VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*)structure; - DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(p, "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR", *props); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* props = + (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"; + DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT) { - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* props = (VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*)structure; - DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(p, "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT", *props); + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* props = + (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT"; + DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT) { - VkPhysicalDeviceShaderObjectFeaturesEXT* props = (VkPhysicalDeviceShaderObjectFeaturesEXT*)structure; - DumpVkPhysicalDeviceShaderObjectFeaturesEXT(p, "VkPhysicalDeviceShaderObjectFeaturesEXT", *props); + const VkPhysicalDeviceShaderObjectFeaturesEXT* props = (const VkPhysicalDeviceShaderObjectFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderObjectFeaturesEXT"; + DumpVkPhysicalDeviceShaderObjectFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR) { - VkPhysicalDeviceShaderQuadControlFeaturesKHR* props = (VkPhysicalDeviceShaderQuadControlFeaturesKHR*)structure; - DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(p, "VkPhysicalDeviceShaderQuadControlFeaturesKHR", *props); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR* props = + (const VkPhysicalDeviceShaderQuadControlFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderQuadControlFeaturesKHR"; + DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR) { - VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* props = (VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*)structure; - DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(p, "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR", *props); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* props = + (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"; + DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT) { - VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* props = (VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*)structure; - DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(p, "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT", *props); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* props = + (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT"; + DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES) { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* props = (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*)structure; - DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures":"VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR", *props); + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* props = + (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures" + : ("VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR"); + DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR", + *props); + } + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT) { + const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT* props = + (const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"; + DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES) { - VkPhysicalDeviceShaderSubgroupRotateFeatures* props = (VkPhysicalDeviceShaderSubgroupRotateFeatures*)structure; - DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceShaderSubgroupRotateFeatures":"VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR", *props); + const VkPhysicalDeviceShaderSubgroupRotateFeatures* props = + (const VkPhysicalDeviceShaderSubgroupRotateFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderSubgroupRotateFeatures" + : ("VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR"); + DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(p, "VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR) { - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* props = (VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*)structure; - DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(p, "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR", *props); + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* props = + (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR"; + DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES) { - VkPhysicalDeviceShaderTerminateInvocationFeatures* props = (VkPhysicalDeviceShaderTerminateInvocationFeatures*)structure; - DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceShaderTerminateInvocationFeatures":"VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR", *props); + const VkPhysicalDeviceShaderTerminateInvocationFeatures* props = + (const VkPhysicalDeviceShaderTerminateInvocationFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderTerminateInvocationFeatures" + : ("VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR"); + DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(p, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT) { - VkPhysicalDeviceShaderTileImageFeaturesEXT* props = (VkPhysicalDeviceShaderTileImageFeaturesEXT*)structure; - DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(p, "VkPhysicalDeviceShaderTileImageFeaturesEXT", *props); + const VkPhysicalDeviceShaderTileImageFeaturesEXT* props = (const VkPhysicalDeviceShaderTileImageFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderTileImageFeaturesEXT"; + DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT) { + const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT* props = + (const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT"; + DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR) { + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* props = + (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR"; + DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES) { - VkPhysicalDeviceSubgroupSizeControlFeatures* props = (VkPhysicalDeviceSubgroupSizeControlFeatures*)structure; - DumpVkPhysicalDeviceSubgroupSizeControlFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceSubgroupSizeControlFeatures":"VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", *props); + const VkPhysicalDeviceSubgroupSizeControlFeatures* props = + (const VkPhysicalDeviceSubgroupSizeControlFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSubgroupSizeControlFeatures" + : ("VkPhysicalDeviceSubgroupSizeControlFeaturesEXT"); + DumpVkPhysicalDeviceSubgroupSizeControlFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceSubgroupSizeControlFeatures(p, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT) { - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* props = (VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*)structure; - DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(p, "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT", *props); + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* props = + (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT"; + DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(p, name, *props); p.AddNewline(); } - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT) { - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* props = (VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*)structure; - DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(p, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT", *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR) { + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* props = + (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*)structure; + const char* name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME) + ? "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR" + : ("VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT"); + DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(p, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES) { - VkPhysicalDeviceSynchronization2Features* props = (VkPhysicalDeviceSynchronization2Features*)structure; - DumpVkPhysicalDeviceSynchronization2Features(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceSynchronization2Features":"VkPhysicalDeviceSynchronization2FeaturesKHR", *props); + const VkPhysicalDeviceSynchronization2Features* props = (const VkPhysicalDeviceSynchronization2Features*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSynchronization2Features" + : ("VkPhysicalDeviceSynchronization2FeaturesKHR"); + DumpVkPhysicalDeviceSynchronization2Features(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSynchronization2FeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceSynchronization2Features(p, "VkPhysicalDeviceSynchronization2FeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT) { - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* props = (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*)structure; - DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(p, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", *props); + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* props = + (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT"; + DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT) { + const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT* props = + (const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT"; + DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES) { - VkPhysicalDeviceTextureCompressionASTCHDRFeatures* props = (VkPhysicalDeviceTextureCompressionASTCHDRFeatures*)structure; - DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceTextureCompressionASTCHDRFeatures":"VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", *props); + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* props = + (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceTextureCompressionASTCHDRFeatures" + : ("VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT"); + DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(p, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES) { - VkPhysicalDeviceTimelineSemaphoreFeatures* props = (VkPhysicalDeviceTimelineSemaphoreFeatures*)structure; - DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceTimelineSemaphoreFeatures":"VkPhysicalDeviceTimelineSemaphoreFeaturesKHR", *props); + const VkPhysicalDeviceTimelineSemaphoreFeatures* props = (const VkPhysicalDeviceTimelineSemaphoreFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceTimelineSemaphoreFeatures" + : ("VkPhysicalDeviceTimelineSemaphoreFeaturesKHR"); + DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTimelineSemaphoreFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, "VkPhysicalDeviceTimelineSemaphoreFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT) { - VkPhysicalDeviceTransformFeedbackFeaturesEXT* props = (VkPhysicalDeviceTransformFeedbackFeaturesEXT*)structure; - DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(p, "VkPhysicalDeviceTransformFeedbackFeaturesEXT", *props); + const VkPhysicalDeviceTransformFeedbackFeaturesEXT* props = + (const VkPhysicalDeviceTransformFeedbackFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceTransformFeedbackFeaturesEXT"; + DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR) { + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* props = + (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR"; + DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES) { - VkPhysicalDeviceUniformBufferStandardLayoutFeatures* props = (VkPhysicalDeviceUniformBufferStandardLayoutFeatures*)structure; - DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceUniformBufferStandardLayoutFeatures":"VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR", *props); + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* props = + (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceUniformBufferStandardLayoutFeatures" + : ("VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR"); + DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, "VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR", + *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES) { - VkPhysicalDeviceVariablePointersFeatures* props = (VkPhysicalDeviceVariablePointersFeatures*)structure; - DumpVkPhysicalDeviceVariablePointersFeatures(p, gpu.api_version >= VK_API_VERSION_1_1 ?"VkPhysicalDeviceVariablePointersFeatures":"VkPhysicalDeviceVariablePointersFeaturesKHR", *props); + const VkPhysicalDeviceVariablePointersFeatures* props = (const VkPhysicalDeviceVariablePointersFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_1 + ? "VkPhysicalDeviceVariablePointersFeatures" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME) + ? "VkPhysicalDeviceVariablePointerFeaturesKHR" + : ("VkPhysicalDeviceVariablePointersFeaturesKHR")); + DumpVkPhysicalDeviceVariablePointersFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVariablePointerFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceVariablePointersFeatures(p, "VkPhysicalDeviceVariablePointerFeaturesKHR", *props); + } + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVariablePointersFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceVariablePointersFeatures(p, "VkPhysicalDeviceVariablePointersFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES) { - VkPhysicalDeviceVertexAttributeDivisorFeatures* props = (VkPhysicalDeviceVertexAttributeDivisorFeatures*)structure; - DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkPhysicalDeviceVertexAttributeDivisorFeatures":"VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR", *props); + const VkPhysicalDeviceVertexAttributeDivisorFeatures* props = + (const VkPhysicalDeviceVertexAttributeDivisorFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 + ? "VkPhysicalDeviceVertexAttributeDivisorFeatures" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) + ? "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR" + : ("VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT")); + DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR", *props); + } + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT) { - VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* props = (VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*)structure; - DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(p, "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT", *props); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* props = + (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"; + DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT) { - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* props = (VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*)structure; - DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(p, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", *props); + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* props = + (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"; + DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR) { + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* props = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR"; + DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR) { - VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* props = (VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*)structure; - DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(p, "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR", *props); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* props = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR"; + DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR) { + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* props = + (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR"; + DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR) { - VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* props = (VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*)structure; - DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(p, "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR", *props); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* props = + (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR"; + DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR) { - VkPhysicalDeviceVideoMaintenance1FeaturesKHR* props = (VkPhysicalDeviceVideoMaintenance1FeaturesKHR*)structure; - DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(p, "VkPhysicalDeviceVideoMaintenance1FeaturesKHR", *props); + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* props = + (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceVideoMaintenance1FeaturesKHR"; + DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR) { + const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* props = + (const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceVideoMaintenance2FeaturesKHR"; + DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES) { - VkPhysicalDeviceVulkan11Features* props = (VkPhysicalDeviceVulkan11Features*)structure; - DumpVkPhysicalDeviceVulkan11Features(p, "VkPhysicalDeviceVulkan11Features", *props); + const VkPhysicalDeviceVulkan11Features* props = (const VkPhysicalDeviceVulkan11Features*)structure; + const char* name = "VkPhysicalDeviceVulkan11Features"; + DumpVkPhysicalDeviceVulkan11Features(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES) { - VkPhysicalDeviceVulkan12Features* props = (VkPhysicalDeviceVulkan12Features*)structure; - DumpVkPhysicalDeviceVulkan12Features(p, "VkPhysicalDeviceVulkan12Features", *props); + const VkPhysicalDeviceVulkan12Features* props = (const VkPhysicalDeviceVulkan12Features*)structure; + const char* name = "VkPhysicalDeviceVulkan12Features"; + DumpVkPhysicalDeviceVulkan12Features(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES) { - VkPhysicalDeviceVulkan13Features* props = (VkPhysicalDeviceVulkan13Features*)structure; - DumpVkPhysicalDeviceVulkan13Features(p, "VkPhysicalDeviceVulkan13Features", *props); + const VkPhysicalDeviceVulkan13Features* props = (const VkPhysicalDeviceVulkan13Features*)structure; + const char* name = "VkPhysicalDeviceVulkan13Features"; + DumpVkPhysicalDeviceVulkan13Features(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES) { - VkPhysicalDeviceVulkan14Features* props = (VkPhysicalDeviceVulkan14Features*)structure; - DumpVkPhysicalDeviceVulkan14Features(p, "VkPhysicalDeviceVulkan14Features", *props); + const VkPhysicalDeviceVulkan14Features* props = (const VkPhysicalDeviceVulkan14Features*)structure; + const char* name = "VkPhysicalDeviceVulkan14Features"; + DumpVkPhysicalDeviceVulkan14Features(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES) { - VkPhysicalDeviceVulkanMemoryModelFeatures* props = (VkPhysicalDeviceVulkanMemoryModelFeatures*)structure; - DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, gpu.api_version >= VK_API_VERSION_1_2 ?"VkPhysicalDeviceVulkanMemoryModelFeatures":"VkPhysicalDeviceVulkanMemoryModelFeaturesKHR", *props); + const VkPhysicalDeviceVulkanMemoryModelFeatures* props = (const VkPhysicalDeviceVulkanMemoryModelFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceVulkanMemoryModelFeatures" + : ("VkPhysicalDeviceVulkanMemoryModelFeaturesKHR"); + DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVulkanMemoryModelFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, "VkPhysicalDeviceVulkanMemoryModelFeaturesKHR", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR) { - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* props = (VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*)structure; - DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(p, "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR", *props); + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* props = + (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*)structure; + const char* name = "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"; + DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT) { - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* props = (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*)structure; - DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(p, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", *props); + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* props = + (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"; + DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT) { - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* props = (VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*)structure; - DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(p, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", *props); + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* props = + (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT"; + DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT) { + const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* props = + (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*)structure; + const char* name = "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"; + DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES) { - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* props = (VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*)structure; - DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures":"VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR", *props); + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* props = + (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures" + : ("VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR"); + DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( + p, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR", *props); + } p.AddNewline(); } place = structure->pNext; @@ -5683,65 +11776,100 @@ } struct surface_capabilities2_chain { surface_capabilities2_chain() = default; - surface_capabilities2_chain(const surface_capabilities2_chain &) = delete; - surface_capabilities2_chain& operator=(const surface_capabilities2_chain &) = delete; - surface_capabilities2_chain(surface_capabilities2_chain &&) = delete; - surface_capabilities2_chain& operator=(surface_capabilities2_chain &&) = delete; + surface_capabilities2_chain(const surface_capabilities2_chain&) = delete; + surface_capabilities2_chain& operator=(const surface_capabilities2_chain&) = delete; + surface_capabilities2_chain(surface_capabilities2_chain&&) = delete; + surface_capabilities2_chain& operator=(surface_capabilities2_chain&&) = delete; void* start_of_chain = nullptr; + VkPresentTimingSurfaceCapabilitiesEXT PresentTimingSurfaceCapabilitiesEXT{}; VkSharedPresentSurfaceCapabilitiesKHR SharedPresentSurfaceCapabilitiesKHR{}; #ifdef VK_USE_PLATFORM_WIN32_KHR VkSurfaceCapabilitiesFullScreenExclusiveEXT SurfaceCapabilitiesFullScreenExclusiveEXT{}; #endif // VK_USE_PLATFORM_WIN32_KHR + VkSurfaceCapabilitiesPresentId2KHR SurfaceCapabilitiesPresentId2KHR{}; + VkSurfaceCapabilitiesPresentWait2KHR SurfaceCapabilitiesPresentWait2KHR{}; VkSurfaceProtectedCapabilitiesKHR SurfaceProtectedCapabilitiesKHR{}; - void initialize_chain(AppInstance &inst, AppGpu &gpu ) noexcept { + void initialize_chain(AppInstance& inst, AppGpu& gpu) noexcept { + PresentTimingSurfaceCapabilitiesEXT.sType = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; SharedPresentSurfaceCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; #ifdef VK_USE_PLATFORM_WIN32_KHR SurfaceCapabilitiesFullScreenExclusiveEXT.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; #endif // VK_USE_PLATFORM_WIN32_KHR + SurfaceCapabilitiesPresentId2KHR.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; + SurfaceCapabilitiesPresentWait2KHR.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; SurfaceProtectedCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; std::vector<VkBaseOutStructure*> chain_members{}; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_TIMING_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&PresentTimingSurfaceCapabilitiesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&SharedPresentSurfaceCapabilitiesKHR)); #ifdef VK_USE_PLATFORM_WIN32_KHR if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&SurfaceCapabilitiesFullScreenExclusiveEXT)); #endif // VK_USE_PLATFORM_WIN32_KHR + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_2_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&SurfaceCapabilitiesPresentId2KHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&SurfaceCapabilitiesPresentWait2KHR)); if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&SurfaceProtectedCapabilitiesKHR)); if (!chain_members.empty()) { - for(size_t i = 0; i < chain_members.size() - 1; i++){ + for (size_t i = 0; i < chain_members.size() - 1; i++) { chain_members[i]->pNext = chain_members[i + 1]; } start_of_chain = chain_members[0]; } } }; -void setup_surface_capabilities2_chain(VkSurfaceCapabilities2KHR& start, std::unique_ptr<surface_capabilities2_chain>& chain, AppInstance &inst,AppGpu &gpu){ +void setup_surface_capabilities2_chain(VkSurfaceCapabilities2KHR& start, std::unique_ptr<surface_capabilities2_chain>& chain, + AppInstance& inst, AppGpu& gpu) { chain = std::unique_ptr<surface_capabilities2_chain>(new surface_capabilities2_chain()); - chain->initialize_chain(inst,gpu); + chain->initialize_chain(inst, gpu); start.pNext = chain->start_of_chain; }; -void chain_iterator_surface_capabilities2(Printer &p, AppInstance &inst, AppGpu &gpu, void * place) { +void chain_iterator_surface_capabilities2(Printer& p, AppInstance& inst, AppGpu& gpu, const void* place) { while (place) { - struct VkBaseOutStructure *structure = (struct VkBaseOutStructure *)place; + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; p.SetSubHeader(); + if (structure->sType == VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT) { + const VkPresentTimingSurfaceCapabilitiesEXT* props = (const VkPresentTimingSurfaceCapabilitiesEXT*)structure; + const char* name = "VkPresentTimingSurfaceCapabilitiesEXT"; + DumpVkPresentTimingSurfaceCapabilitiesEXT(p, name, *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR) { - VkSharedPresentSurfaceCapabilitiesKHR* props = (VkSharedPresentSurfaceCapabilitiesKHR*)structure; - DumpVkSharedPresentSurfaceCapabilitiesKHR(p, "VkSharedPresentSurfaceCapabilitiesKHR", *props); + const VkSharedPresentSurfaceCapabilitiesKHR* props = (const VkSharedPresentSurfaceCapabilitiesKHR*)structure; + const char* name = "VkSharedPresentSurfaceCapabilitiesKHR"; + DumpVkSharedPresentSurfaceCapabilitiesKHR(p, name, *props); p.AddNewline(); } #ifdef VK_USE_PLATFORM_WIN32_KHR if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT) { - VkSurfaceCapabilitiesFullScreenExclusiveEXT* props = (VkSurfaceCapabilitiesFullScreenExclusiveEXT*)structure; - DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(p, "VkSurfaceCapabilitiesFullScreenExclusiveEXT", *props); + const VkSurfaceCapabilitiesFullScreenExclusiveEXT* props = + (const VkSurfaceCapabilitiesFullScreenExclusiveEXT*)structure; + const char* name = "VkSurfaceCapabilitiesFullScreenExclusiveEXT"; + DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(p, name, *props); p.AddNewline(); } #endif // VK_USE_PLATFORM_WIN32_KHR + if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR) { + const VkSurfaceCapabilitiesPresentId2KHR* props = (const VkSurfaceCapabilitiesPresentId2KHR*)structure; + const char* name = "VkSurfaceCapabilitiesPresentId2KHR"; + DumpVkSurfaceCapabilitiesPresentId2KHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR) { + const VkSurfaceCapabilitiesPresentWait2KHR* props = (const VkSurfaceCapabilitiesPresentWait2KHR*)structure; + const char* name = "VkSurfaceCapabilitiesPresentWait2KHR"; + DumpVkSurfaceCapabilitiesPresentWait2KHR(p, name, *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR) { - VkSurfaceProtectedCapabilitiesKHR* props = (VkSurfaceProtectedCapabilitiesKHR*)structure; - DumpVkSurfaceProtectedCapabilitiesKHR(p, "VkSurfaceProtectedCapabilitiesKHR", *props); + const VkSurfaceProtectedCapabilitiesKHR* props = (const VkSurfaceProtectedCapabilitiesKHR*)structure; + const char* name = "VkSurfaceProtectedCapabilitiesKHR"; + DumpVkSurfaceProtectedCapabilitiesKHR(p, name, *props); p.AddNewline(); } place = structure->pNext; @@ -5754,49 +11882,51 @@ } struct format_properties2_chain { format_properties2_chain() = default; - format_properties2_chain(const format_properties2_chain &) = delete; - format_properties2_chain& operator=(const format_properties2_chain &) = delete; - format_properties2_chain(format_properties2_chain &&) = delete; - format_properties2_chain& operator=(format_properties2_chain &&) = delete; + format_properties2_chain(const format_properties2_chain&) = delete; + format_properties2_chain& operator=(const format_properties2_chain&) = delete; + format_properties2_chain(format_properties2_chain&&) = delete; + format_properties2_chain& operator=(format_properties2_chain&&) = delete; void* start_of_chain = nullptr; VkFormatProperties3 FormatProperties3{}; VkSubpassResolvePerformanceQueryEXT SubpassResolvePerformanceQueryEXT{}; - void initialize_chain(AppGpu &gpu ) noexcept { + void initialize_chain(AppGpu& gpu) noexcept { FormatProperties3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; SubpassResolvePerformanceQueryEXT.sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; std::vector<VkBaseOutStructure*> chain_members{}; - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_3 )) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_3)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&FormatProperties3)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&SubpassResolvePerformanceQueryEXT)); if (!chain_members.empty()) { - for(size_t i = 0; i < chain_members.size() - 1; i++){ + for (size_t i = 0; i < chain_members.size() - 1; i++) { chain_members[i]->pNext = chain_members[i + 1]; } start_of_chain = chain_members[0]; } } }; -void setup_format_properties2_chain(VkFormatProperties2& start, std::unique_ptr<format_properties2_chain>& chain, AppGpu &gpu){ +void setup_format_properties2_chain(VkFormatProperties2& start, std::unique_ptr<format_properties2_chain>& chain, AppGpu& gpu) { chain = std::unique_ptr<format_properties2_chain>(new format_properties2_chain()); chain->initialize_chain(gpu); start.pNext = chain->start_of_chain; }; -void chain_iterator_format_properties2(Printer &p, AppGpu &gpu, void * place) { +void chain_iterator_format_properties2(Printer& p, AppGpu& gpu, const void* place) { while (place) { - struct VkBaseOutStructure *structure = (struct VkBaseOutStructure *)place; + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; p.SetSubHeader(); if (structure->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3) { - VkFormatProperties3* props = (VkFormatProperties3*)structure; - DumpVkFormatProperties3(p, gpu.api_version >= VK_API_VERSION_1_3 ?"VkFormatProperties3":"VkFormatProperties3KHR", *props); + const VkFormatProperties3* props = (const VkFormatProperties3*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkFormatProperties3" : ("VkFormatProperties3KHR"); + DumpVkFormatProperties3(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT) { - VkSubpassResolvePerformanceQueryEXT* props = (VkSubpassResolvePerformanceQueryEXT*)structure; - DumpVkSubpassResolvePerformanceQueryEXT(p, "VkSubpassResolvePerformanceQueryEXT", *props); + const VkSubpassResolvePerformanceQueryEXT* props = (const VkSubpassResolvePerformanceQueryEXT*)structure; + const char* name = "VkSubpassResolvePerformanceQueryEXT"; + DumpVkSubpassResolvePerformanceQueryEXT(p, name, *props); p.AddNewline(); } place = structure->pNext; @@ -5809,59 +11939,91 @@ } struct queue_properties2_chain { queue_properties2_chain() = default; - queue_properties2_chain(const queue_properties2_chain &) = delete; - queue_properties2_chain& operator=(const queue_properties2_chain &) = delete; - queue_properties2_chain(queue_properties2_chain &&) = delete; - queue_properties2_chain& operator=(queue_properties2_chain &&) = delete; + queue_properties2_chain(const queue_properties2_chain&) = delete; + queue_properties2_chain& operator=(const queue_properties2_chain&) = delete; + queue_properties2_chain(queue_properties2_chain&&) = delete; + queue_properties2_chain& operator=(queue_properties2_chain&&) = delete; void* start_of_chain = nullptr; VkQueueFamilyGlobalPriorityProperties QueueFamilyGlobalPriorityProperties{}; + VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR QueueFamilyOptimalImageTransferGranularityPropertiesKHR{}; + VkQueueFamilyOwnershipTransferPropertiesKHR QueueFamilyOwnershipTransferPropertiesKHR{}; VkQueueFamilyQueryResultStatusPropertiesKHR QueueFamilyQueryResultStatusPropertiesKHR{}; VkQueueFamilyVideoPropertiesKHR QueueFamilyVideoPropertiesKHR{}; - void initialize_chain(AppGpu &gpu ) noexcept { + void initialize_chain(AppGpu& gpu) noexcept { QueueFamilyGlobalPriorityProperties.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; + QueueFamilyOptimalImageTransferGranularityPropertiesKHR.sType = + VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR; + QueueFamilyOwnershipTransferPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; QueueFamilyQueryResultStatusPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; QueueFamilyVideoPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; std::vector<VkBaseOutStructure*> chain_members{}; - if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) - || gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) - && (gpu.api_version < VK_API_VERSION_1_4 )) + if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) && + (gpu.api_version < VK_API_VERSION_1_4)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&QueueFamilyGlobalPriorityProperties)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_11_EXTENSION_NAME)) + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure*>(&QueueFamilyOptimalImageTransferGranularityPropertiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&QueueFamilyOwnershipTransferPropertiesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_QUEUE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&QueueFamilyQueryResultStatusPropertiesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_QUEUE_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&QueueFamilyVideoPropertiesKHR)); if (!chain_members.empty()) { - for(size_t i = 0; i < chain_members.size() - 1; i++){ + for (size_t i = 0; i < chain_members.size() - 1; i++) { chain_members[i]->pNext = chain_members[i + 1]; } start_of_chain = chain_members[0]; } } }; -void setup_queue_properties2_chain(VkQueueFamilyProperties2& start, std::unique_ptr<queue_properties2_chain>& chain, AppGpu &gpu){ +void setup_queue_properties2_chain(VkQueueFamilyProperties2& start, std::unique_ptr<queue_properties2_chain>& chain, AppGpu& gpu) { chain = std::unique_ptr<queue_properties2_chain>(new queue_properties2_chain()); chain->initialize_chain(gpu); start.pNext = chain->start_of_chain; }; -void chain_iterator_queue_properties2(Printer &p, AppGpu &gpu, void * place) { +void chain_iterator_queue_properties2(Printer& p, AppGpu& gpu, const void* place) { while (place) { - struct VkBaseOutStructure *structure = (struct VkBaseOutStructure *)place; + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; p.SetSubHeader(); if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES) { - VkQueueFamilyGlobalPriorityProperties* props = (VkQueueFamilyGlobalPriorityProperties*)structure; - DumpVkQueueFamilyGlobalPriorityProperties(p, gpu.api_version >= VK_API_VERSION_1_4 ?"VkQueueFamilyGlobalPriorityProperties":"VkQueueFamilyGlobalPriorityPropertiesEXT", *props); + const VkQueueFamilyGlobalPriorityProperties* props = (const VkQueueFamilyGlobalPriorityProperties*)structure; + const char* name = gpu.api_version >= VK_API_VERSION_1_4 + ? "VkQueueFamilyGlobalPriorityProperties" + : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) + ? "VkQueueFamilyGlobalPriorityPropertiesKHR" + : ("VkQueueFamilyGlobalPriorityPropertiesEXT")); + DumpVkQueueFamilyGlobalPriorityProperties(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR) { + const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR* props = + (const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR*)structure; + const char* name = "VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR"; + DumpVkQueueFamilyOptimalImageTransferGranularityPropertiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR) { + const VkQueueFamilyOwnershipTransferPropertiesKHR* props = + (const VkQueueFamilyOwnershipTransferPropertiesKHR*)structure; + const char* name = "VkQueueFamilyOwnershipTransferPropertiesKHR"; + DumpVkQueueFamilyOwnershipTransferPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR) { - VkQueueFamilyQueryResultStatusPropertiesKHR* props = (VkQueueFamilyQueryResultStatusPropertiesKHR*)structure; - DumpVkQueueFamilyQueryResultStatusPropertiesKHR(p, "VkQueueFamilyQueryResultStatusPropertiesKHR", *props); + const VkQueueFamilyQueryResultStatusPropertiesKHR* props = + (const VkQueueFamilyQueryResultStatusPropertiesKHR*)structure; + const char* name = "VkQueueFamilyQueryResultStatusPropertiesKHR"; + DumpVkQueueFamilyQueryResultStatusPropertiesKHR(p, name, *props); p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR) { - VkQueueFamilyVideoPropertiesKHR* props = (VkQueueFamilyVideoPropertiesKHR*)structure; - DumpVkQueueFamilyVideoPropertiesKHR(p, "VkQueueFamilyVideoPropertiesKHR", *props); + const VkQueueFamilyVideoPropertiesKHR* props = (const VkQueueFamilyVideoPropertiesKHR*)structure; + const char* name = "VkQueueFamilyVideoPropertiesKHR"; + DumpVkQueueFamilyVideoPropertiesKHR(p, name, *props); p.AddNewline(); } place = structure->pNext; @@ -5872,67 +12034,1739 @@ (void)chain; return false; } -bool operator==(const VkExtent2D & a, const VkExtent2D b); -bool operator==(const VkSurfaceCapabilities2EXT & a, const VkSurfaceCapabilities2EXT b); -bool operator==(const VkSurfaceCapabilities2KHR & a, const VkSurfaceCapabilities2KHR b); -bool operator==(const VkSurfaceCapabilitiesKHR & a, const VkSurfaceCapabilitiesKHR b); -bool operator==(const VkSurfaceFormat2KHR & a, const VkSurfaceFormat2KHR b); -bool operator==(const VkSurfaceFormatKHR & a, const VkSurfaceFormatKHR b); -bool operator==(const VkExtent2D & a, const VkExtent2D b) { - return a.width == b.width - && a.height == b.height; +struct video_profile_info_chain { + video_profile_info_chain() = default; + video_profile_info_chain(const video_profile_info_chain&) = delete; + video_profile_info_chain& operator=(const video_profile_info_chain&) = delete; + video_profile_info_chain(video_profile_info_chain&&) = delete; + video_profile_info_chain& operator=(video_profile_info_chain&&) = delete; + void* start_of_chain = nullptr; + VkVideoDecodeAV1ProfileInfoKHR VideoDecodeAV1ProfileInfoKHR{}; + VkVideoDecodeH264ProfileInfoKHR VideoDecodeH264ProfileInfoKHR{}; + VkVideoDecodeH265ProfileInfoKHR VideoDecodeH265ProfileInfoKHR{}; + VkVideoDecodeUsageInfoKHR VideoDecodeUsageInfoKHR{}; + VkVideoDecodeVP9ProfileInfoKHR VideoDecodeVP9ProfileInfoKHR{}; + VkVideoEncodeAV1ProfileInfoKHR VideoEncodeAV1ProfileInfoKHR{}; + VkVideoEncodeH264ProfileInfoKHR VideoEncodeH264ProfileInfoKHR{}; + VkVideoEncodeH265ProfileInfoKHR VideoEncodeH265ProfileInfoKHR{}; + VkVideoEncodeProfileRgbConversionInfoVALVE VideoEncodeProfileRgbConversionInfoVALVE{}; + VkVideoEncodeUsageInfoKHR VideoEncodeUsageInfoKHR{}; + void initialize_chain(AppGpu& gpu) noexcept { + VideoDecodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; + VideoDecodeH264ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; + VideoDecodeH265ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; + VideoDecodeUsageInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; + VideoDecodeVP9ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; + VideoEncodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; + VideoEncodeH264ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; + VideoEncodeH265ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; + VideoEncodeProfileRgbConversionInfoVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE; + VideoEncodeUsageInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR; + std::vector<VkBaseOutStructure*> chain_members{}; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeAV1ProfileInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeH264ProfileInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeH265ProfileInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeUsageInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeVP9ProfileInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeAV1ProfileInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH264ProfileInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH265ProfileInfoKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeProfileRgbConversionInfoVALVE)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeUsageInfoKHR)); + + if (!chain_members.empty()) { + for (size_t i = 0; i < chain_members.size() - 1; i++) { + chain_members[i]->pNext = chain_members[i + 1]; + } + start_of_chain = chain_members[0]; + } + } +}; +void setup_video_profile_info_chain(VkVideoProfileInfoKHR& start, std::unique_ptr<video_profile_info_chain>& chain, AppGpu& gpu) { + chain = std::unique_ptr<video_profile_info_chain>(new video_profile_info_chain()); + chain->initialize_chain(gpu); + start.pNext = chain->start_of_chain; +}; + +void chain_iterator_video_profile_info(Printer& p, AppGpu& gpu, const void* place) { + while (place) { + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; + p.SetSubHeader(); + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR) { + const VkVideoDecodeAV1ProfileInfoKHR* props = (const VkVideoDecodeAV1ProfileInfoKHR*)structure; + const char* name = "VkVideoDecodeAV1ProfileInfoKHR"; + DumpVkVideoDecodeAV1ProfileInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR) { + const VkVideoDecodeH264ProfileInfoKHR* props = (const VkVideoDecodeH264ProfileInfoKHR*)structure; + const char* name = "VkVideoDecodeH264ProfileInfoKHR"; + DumpVkVideoDecodeH264ProfileInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR) { + const VkVideoDecodeH265ProfileInfoKHR* props = (const VkVideoDecodeH265ProfileInfoKHR*)structure; + const char* name = "VkVideoDecodeH265ProfileInfoKHR"; + DumpVkVideoDecodeH265ProfileInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR) { + const VkVideoDecodeUsageInfoKHR* props = (const VkVideoDecodeUsageInfoKHR*)structure; + const char* name = "VkVideoDecodeUsageInfoKHR"; + DumpVkVideoDecodeUsageInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR) { + const VkVideoDecodeVP9ProfileInfoKHR* props = (const VkVideoDecodeVP9ProfileInfoKHR*)structure; + const char* name = "VkVideoDecodeVP9ProfileInfoKHR"; + DumpVkVideoDecodeVP9ProfileInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR) { + const VkVideoEncodeAV1ProfileInfoKHR* props = (const VkVideoEncodeAV1ProfileInfoKHR*)structure; + const char* name = "VkVideoEncodeAV1ProfileInfoKHR"; + DumpVkVideoEncodeAV1ProfileInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR) { + const VkVideoEncodeH264ProfileInfoKHR* props = (const VkVideoEncodeH264ProfileInfoKHR*)structure; + const char* name = "VkVideoEncodeH264ProfileInfoKHR"; + DumpVkVideoEncodeH264ProfileInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR) { + const VkVideoEncodeH265ProfileInfoKHR* props = (const VkVideoEncodeH265ProfileInfoKHR*)structure; + const char* name = "VkVideoEncodeH265ProfileInfoKHR"; + DumpVkVideoEncodeH265ProfileInfoKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE) { + const VkVideoEncodeProfileRgbConversionInfoVALVE* props = (const VkVideoEncodeProfileRgbConversionInfoVALVE*)structure; + const char* name = "VkVideoEncodeProfileRgbConversionInfoVALVE"; + DumpVkVideoEncodeProfileRgbConversionInfoVALVE(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR) { + const VkVideoEncodeUsageInfoKHR* props = (const VkVideoEncodeUsageInfoKHR*)structure; + const char* name = "VkVideoEncodeUsageInfoKHR"; + DumpVkVideoEncodeUsageInfoKHR(p, name, *props); + p.AddNewline(); + } + place = structure->pNext; + } } -bool operator==(const VkSurfaceCapabilities2EXT & a, const VkSurfaceCapabilities2EXT b) { - return a.minImageCount == b.minImageCount - && a.maxImageCount == b.maxImageCount - && a.currentExtent == b.currentExtent - && a.minImageExtent == b.minImageExtent - && a.maxImageExtent == b.maxImageExtent - && a.maxImageArrayLayers == b.maxImageArrayLayers - && a.supportedTransforms == b.supportedTransforms - && a.currentTransform == b.currentTransform - && a.supportedCompositeAlpha == b.supportedCompositeAlpha - && a.supportedUsageFlags == b.supportedUsageFlags - && a.supportedSurfaceCounters == b.supportedSurfaceCounters; + +bool prepare_video_profile_info_twocall_chain_vectors(std::unique_ptr<video_profile_info_chain>& chain) { + (void)chain; + return false; } -bool operator==(const VkSurfaceCapabilities2KHR & a, const VkSurfaceCapabilities2KHR b) { +struct video_capabilities_chain { + video_capabilities_chain() = default; + video_capabilities_chain(const video_capabilities_chain&) = delete; + video_capabilities_chain& operator=(const video_capabilities_chain&) = delete; + video_capabilities_chain(video_capabilities_chain&&) = delete; + video_capabilities_chain& operator=(video_capabilities_chain&&) = delete; + void* start_of_chain = nullptr; + VkVideoDecodeAV1CapabilitiesKHR VideoDecodeAV1CapabilitiesKHR{}; + VkVideoDecodeCapabilitiesKHR VideoDecodeCapabilitiesKHR{}; + VkVideoDecodeH264CapabilitiesKHR VideoDecodeH264CapabilitiesKHR{}; + VkVideoDecodeH265CapabilitiesKHR VideoDecodeH265CapabilitiesKHR{}; + VkVideoDecodeVP9CapabilitiesKHR VideoDecodeVP9CapabilitiesKHR{}; + VkVideoEncodeAV1CapabilitiesKHR VideoEncodeAV1CapabilitiesKHR{}; + VkVideoEncodeAV1QuantizationMapCapabilitiesKHR VideoEncodeAV1QuantizationMapCapabilitiesKHR{}; + VkVideoEncodeCapabilitiesKHR VideoEncodeCapabilitiesKHR{}; + VkVideoEncodeH264CapabilitiesKHR VideoEncodeH264CapabilitiesKHR{}; + VkVideoEncodeH264QuantizationMapCapabilitiesKHR VideoEncodeH264QuantizationMapCapabilitiesKHR{}; + VkVideoEncodeH265CapabilitiesKHR VideoEncodeH265CapabilitiesKHR{}; + VkVideoEncodeH265QuantizationMapCapabilitiesKHR VideoEncodeH265QuantizationMapCapabilitiesKHR{}; + VkVideoEncodeIntraRefreshCapabilitiesKHR VideoEncodeIntraRefreshCapabilitiesKHR{}; + VkVideoEncodeQuantizationMapCapabilitiesKHR VideoEncodeQuantizationMapCapabilitiesKHR{}; + VkVideoEncodeRgbConversionCapabilitiesVALVE VideoEncodeRgbConversionCapabilitiesVALVE{}; + void initialize_chain(AppGpu& gpu) noexcept { + VideoDecodeAV1CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; + VideoDecodeCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; + VideoDecodeH264CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR; + VideoDecodeH265CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR; + VideoDecodeVP9CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; + VideoEncodeAV1CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + VideoEncodeAV1QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; + VideoEncodeCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; + VideoEncodeH264CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR; + VideoEncodeH264QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + VideoEncodeH265CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR; + VideoEncodeH265QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; + VideoEncodeIntraRefreshCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + VideoEncodeQuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + VideoEncodeRgbConversionCapabilitiesVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; + std::vector<VkBaseOutStructure*> chain_members{}; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeAV1CapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeCapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeH264CapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeH265CapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeVP9CapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeAV1CapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeAV1QuantizationMapCapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeCapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH264CapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH264QuantizationMapCapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH265CapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH265QuantizationMapCapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeIntraRefreshCapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeQuantizationMapCapabilitiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeRgbConversionCapabilitiesVALVE)); + + if (!chain_members.empty()) { + for (size_t i = 0; i < chain_members.size() - 1; i++) { + chain_members[i]->pNext = chain_members[i + 1]; + } + start_of_chain = chain_members[0]; + } + } +}; +void setup_video_capabilities_chain(VkVideoCapabilitiesKHR& start, std::unique_ptr<video_capabilities_chain>& chain, AppGpu& gpu) { + chain = std::unique_ptr<video_capabilities_chain>(new video_capabilities_chain()); + chain->initialize_chain(gpu); + start.pNext = chain->start_of_chain; +}; + +void chain_iterator_video_capabilities(Printer& p, AppGpu& gpu, const void* place) { + while (place) { + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; + p.SetSubHeader(); + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR) { + const VkVideoDecodeAV1CapabilitiesKHR* props = (const VkVideoDecodeAV1CapabilitiesKHR*)structure; + const char* name = "VkVideoDecodeAV1CapabilitiesKHR"; + DumpVkVideoDecodeAV1CapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR) { + const VkVideoDecodeCapabilitiesKHR* props = (const VkVideoDecodeCapabilitiesKHR*)structure; + const char* name = "VkVideoDecodeCapabilitiesKHR"; + DumpVkVideoDecodeCapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR) { + const VkVideoDecodeH264CapabilitiesKHR* props = (const VkVideoDecodeH264CapabilitiesKHR*)structure; + const char* name = "VkVideoDecodeH264CapabilitiesKHR"; + DumpVkVideoDecodeH264CapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR) { + const VkVideoDecodeH265CapabilitiesKHR* props = (const VkVideoDecodeH265CapabilitiesKHR*)structure; + const char* name = "VkVideoDecodeH265CapabilitiesKHR"; + DumpVkVideoDecodeH265CapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR) { + const VkVideoDecodeVP9CapabilitiesKHR* props = (const VkVideoDecodeVP9CapabilitiesKHR*)structure; + const char* name = "VkVideoDecodeVP9CapabilitiesKHR"; + DumpVkVideoDecodeVP9CapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR) { + const VkVideoEncodeAV1CapabilitiesKHR* props = (const VkVideoEncodeAV1CapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeAV1CapabilitiesKHR"; + DumpVkVideoEncodeAV1CapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR) { + const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* props = + (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR"; + DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR) { + const VkVideoEncodeCapabilitiesKHR* props = (const VkVideoEncodeCapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeCapabilitiesKHR"; + DumpVkVideoEncodeCapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR) { + const VkVideoEncodeH264CapabilitiesKHR* props = (const VkVideoEncodeH264CapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeH264CapabilitiesKHR"; + DumpVkVideoEncodeH264CapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR) { + const VkVideoEncodeH264QuantizationMapCapabilitiesKHR* props = + (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeH264QuantizationMapCapabilitiesKHR"; + DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR) { + const VkVideoEncodeH265CapabilitiesKHR* props = (const VkVideoEncodeH265CapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeH265CapabilitiesKHR"; + DumpVkVideoEncodeH265CapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR) { + const VkVideoEncodeH265QuantizationMapCapabilitiesKHR* props = + (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeH265QuantizationMapCapabilitiesKHR"; + DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR) { + const VkVideoEncodeIntraRefreshCapabilitiesKHR* props = (const VkVideoEncodeIntraRefreshCapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeIntraRefreshCapabilitiesKHR"; + DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR) { + const VkVideoEncodeQuantizationMapCapabilitiesKHR* props = + (const VkVideoEncodeQuantizationMapCapabilitiesKHR*)structure; + const char* name = "VkVideoEncodeQuantizationMapCapabilitiesKHR"; + DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE) { + const VkVideoEncodeRgbConversionCapabilitiesVALVE* props = + (const VkVideoEncodeRgbConversionCapabilitiesVALVE*)structure; + const char* name = "VkVideoEncodeRgbConversionCapabilitiesVALVE"; + DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(p, name, *props); + p.AddNewline(); + } + place = structure->pNext; + } +} + +bool prepare_video_capabilities_twocall_chain_vectors(std::unique_ptr<video_capabilities_chain>& chain) { + (void)chain; + return false; +} +struct video_format_properties_chain { + video_format_properties_chain() = default; + video_format_properties_chain(const video_format_properties_chain&) = delete; + video_format_properties_chain& operator=(const video_format_properties_chain&) = delete; + video_format_properties_chain(video_format_properties_chain&&) = delete; + video_format_properties_chain& operator=(video_format_properties_chain&&) = delete; + void* start_of_chain = nullptr; + VkVideoFormatAV1QuantizationMapPropertiesKHR VideoFormatAV1QuantizationMapPropertiesKHR{}; + VkVideoFormatH265QuantizationMapPropertiesKHR VideoFormatH265QuantizationMapPropertiesKHR{}; + VkVideoFormatQuantizationMapPropertiesKHR VideoFormatQuantizationMapPropertiesKHR{}; + void initialize_chain(AppGpu& gpu) noexcept { + VideoFormatAV1QuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + VideoFormatH265QuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; + VideoFormatQuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + std::vector<VkBaseOutStructure*> chain_members{}; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoFormatAV1QuantizationMapPropertiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoFormatH265QuantizationMapPropertiesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoFormatQuantizationMapPropertiesKHR)); + + if (!chain_members.empty()) { + for (size_t i = 0; i < chain_members.size() - 1; i++) { + chain_members[i]->pNext = chain_members[i + 1]; + } + start_of_chain = chain_members[0]; + } + } +}; +void setup_video_format_properties_chain(VkVideoFormatPropertiesKHR& start, std::unique_ptr<video_format_properties_chain>& chain, + AppGpu& gpu) { + chain = std::unique_ptr<video_format_properties_chain>(new video_format_properties_chain()); + chain->initialize_chain(gpu); + start.pNext = chain->start_of_chain; +}; + +void chain_iterator_video_format_properties(Printer& p, AppGpu& gpu, const void* place) { + while (place) { + const VkBaseOutStructure* structure = (const VkBaseOutStructure*)place; + p.SetSubHeader(); + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR) { + const VkVideoFormatAV1QuantizationMapPropertiesKHR* props = + (const VkVideoFormatAV1QuantizationMapPropertiesKHR*)structure; + const char* name = "VkVideoFormatAV1QuantizationMapPropertiesKHR"; + DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR) { + const VkVideoFormatH265QuantizationMapPropertiesKHR* props = + (const VkVideoFormatH265QuantizationMapPropertiesKHR*)structure; + const char* name = "VkVideoFormatH265QuantizationMapPropertiesKHR"; + DumpVkVideoFormatH265QuantizationMapPropertiesKHR(p, name, *props); + p.AddNewline(); + } + if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR) { + const VkVideoFormatQuantizationMapPropertiesKHR* props = (const VkVideoFormatQuantizationMapPropertiesKHR*)structure; + const char* name = "VkVideoFormatQuantizationMapPropertiesKHR"; + DumpVkVideoFormatQuantizationMapPropertiesKHR(p, name, *props); + p.AddNewline(); + } + place = structure->pNext; + } +} + +bool prepare_video_format_properties_twocall_chain_vectors(std::unique_ptr<video_format_properties_chain>& chain) { + (void)chain; + return false; +} +bool operator==(const VkExtent2D& a, const VkExtent2D b); +bool operator==(const VkSurfaceCapabilities2EXT& a, const VkSurfaceCapabilities2EXT b); +bool operator==(const VkSurfaceCapabilities2KHR& a, const VkSurfaceCapabilities2KHR b); +bool operator==(const VkSurfaceCapabilitiesKHR& a, const VkSurfaceCapabilitiesKHR b); +bool operator==(const VkSurfaceFormat2KHR& a, const VkSurfaceFormat2KHR b); +bool operator==(const VkSurfaceFormatKHR& a, const VkSurfaceFormatKHR b); +bool operator==(const VkExtent2D& a, const VkExtent2D b) { return a.width == b.width && a.height == b.height; } +bool operator==(const VkSurfaceCapabilities2EXT& a, const VkSurfaceCapabilities2EXT b) { + return a.minImageCount == b.minImageCount && a.maxImageCount == b.maxImageCount && a.currentExtent == b.currentExtent && + a.minImageExtent == b.minImageExtent && a.maxImageExtent == b.maxImageExtent && + a.maxImageArrayLayers == b.maxImageArrayLayers && a.supportedTransforms == b.supportedTransforms && + a.currentTransform == b.currentTransform && a.supportedCompositeAlpha == b.supportedCompositeAlpha && + a.supportedUsageFlags == b.supportedUsageFlags && a.supportedSurfaceCounters == b.supportedSurfaceCounters; +} +bool operator==(const VkSurfaceCapabilities2KHR& a, const VkSurfaceCapabilities2KHR b) { return a.surfaceCapabilities == b.surfaceCapabilities; } -bool operator==(const VkSurfaceCapabilitiesKHR & a, const VkSurfaceCapabilitiesKHR b) { - return a.minImageCount == b.minImageCount - && a.maxImageCount == b.maxImageCount - && a.currentExtent == b.currentExtent - && a.minImageExtent == b.minImageExtent - && a.maxImageExtent == b.maxImageExtent - && a.maxImageArrayLayers == b.maxImageArrayLayers - && a.supportedTransforms == b.supportedTransforms - && a.currentTransform == b.currentTransform - && a.supportedCompositeAlpha == b.supportedCompositeAlpha - && a.supportedUsageFlags == b.supportedUsageFlags; +bool operator==(const VkSurfaceCapabilitiesKHR& a, const VkSurfaceCapabilitiesKHR b) { + return a.minImageCount == b.minImageCount && a.maxImageCount == b.maxImageCount && a.currentExtent == b.currentExtent && + a.minImageExtent == b.minImageExtent && a.maxImageExtent == b.maxImageExtent && + a.maxImageArrayLayers == b.maxImageArrayLayers && a.supportedTransforms == b.supportedTransforms && + a.currentTransform == b.currentTransform && a.supportedCompositeAlpha == b.supportedCompositeAlpha && + a.supportedUsageFlags == b.supportedUsageFlags; } -bool operator==(const VkSurfaceFormat2KHR & a, const VkSurfaceFormat2KHR b) { - return a.surfaceFormat == b.surfaceFormat; +bool operator==(const VkSurfaceFormat2KHR& a, const VkSurfaceFormat2KHR b) { return a.surfaceFormat == b.surfaceFormat; } +bool operator==(const VkSurfaceFormatKHR& a, const VkSurfaceFormatKHR b) { + return a.format == b.format && a.colorSpace == b.colorSpace; } -bool operator==(const VkSurfaceFormatKHR & a, const VkSurfaceFormatKHR b) { - return a.format == b.format - && a.colorSpace == b.colorSpace; -} -std::ostream &operator<<(std::ostream &o, VkExtent3D &obj) { +std::ostream& operator<<(std::ostream& o, VkExtent2D& obj) { return o << "(" << obj.width << ',' << obj.height << ")"; } +std::ostream& operator<<(std::ostream& o, VkExtent3D& obj) { return o << "(" << obj.width << ',' << obj.height << ',' << obj.depth << ")"; } auto format_ranges = std::array{ FormatRange{0, nullptr, static_cast<VkFormat>(0), static_cast<VkFormat>(184)}, FormatRange{VK_API_VERSION_1_1, nullptr, static_cast<VkFormat>(1000156000), static_cast<VkFormat>(1000156033)}, - FormatRange{0, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, static_cast<VkFormat>(1000156000), static_cast<VkFormat>(1000156033)}, + FormatRange{0, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, static_cast<VkFormat>(1000156000), + static_cast<VkFormat>(1000156033)}, FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000330000), static_cast<VkFormat>(1000330003)}, - FormatRange{0, VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME, static_cast<VkFormat>(1000330000), static_cast<VkFormat>(1000330003)}, + FormatRange{0, VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME, static_cast<VkFormat>(1000330000), + static_cast<VkFormat>(1000330003)}, FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000340000), static_cast<VkFormat>(1000340001)}, FormatRange{0, VK_EXT_4444_FORMATS_EXTENSION_NAME, static_cast<VkFormat>(1000340000), static_cast<VkFormat>(1000340001)}, FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000066000), static_cast<VkFormat>(1000066013)}, - FormatRange{0, VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME, static_cast<VkFormat>(1000066000), static_cast<VkFormat>(1000066013)}, + FormatRange{0, VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME, static_cast<VkFormat>(1000066000), + static_cast<VkFormat>(1000066013)}, FormatRange{VK_API_VERSION_1_4, nullptr, static_cast<VkFormat>(1000470000), static_cast<VkFormat>(1000470001)}, FormatRange{0, VK_KHR_MAINTENANCE_5_EXTENSION_NAME, static_cast<VkFormat>(1000470000), static_cast<VkFormat>(1000470001)}, FormatRange{0, VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, static_cast<VkFormat>(1000054000), static_cast<VkFormat>(1000054007)}, + FormatRange{0, VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME, static_cast<VkFormat>(1000288000), + static_cast<VkFormat>(1000288029)}, + FormatRange{0, VK_ARM_TENSORS_EXTENSION_NAME, static_cast<VkFormat>(1000460000), static_cast<VkFormat>(1000460003)}, FormatRange{0, VK_NV_OPTICAL_FLOW_EXTENSION_NAME, static_cast<VkFormat>(1000464000), static_cast<VkFormat>(1000464000)}, + FormatRange{0, VK_ARM_FORMAT_PACK_EXTENSION_NAME, static_cast<VkFormat>(1000609000), static_cast<VkFormat>(1000609013)}, }; +bool is_video_format_same(const VkVideoFormatPropertiesKHR& format_a, const VkVideoFormatPropertiesKHR& format_b) { + auto a = reinterpret_cast<const VkBaseInStructure*>(&format_a); + auto b = reinterpret_cast<const VkBaseInStructure*>(&format_b); + bool same = true; + while (same && a != nullptr && b != nullptr) { + if (a->sType != b->sType) { + // Structure type mismatch (extension structures are expected to be chained in the same order) + same = false; + } else { + switch (a->sType) { + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: + same = same && memcmp(reinterpret_cast<const char*>(a) + sizeof(VkBaseInStructure), + reinterpret_cast<const char*>(b) + sizeof(VkBaseInStructure), + sizeof(VkVideoFormatPropertiesKHR) - sizeof(VkBaseInStructure)) == 0; + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + same = same && memcmp(reinterpret_cast<const char*>(a) + sizeof(VkBaseInStructure), + reinterpret_cast<const char*>(b) + sizeof(VkBaseInStructure), + sizeof(VkVideoFormatAV1QuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0; + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: + same = same && memcmp(reinterpret_cast<const char*>(a) + sizeof(VkBaseInStructure), + reinterpret_cast<const char*>(b) + sizeof(VkBaseInStructure), + sizeof(VkVideoFormatH265QuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0; + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + same = same && memcmp(reinterpret_cast<const char*>(a) + sizeof(VkBaseInStructure), + reinterpret_cast<const char*>(b) + sizeof(VkBaseInStructure), + sizeof(VkVideoFormatQuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0; + break; + default: + // Unexpected structure type + same = false; + break; + } + } + a = a->pNext; + b = b->pNext; + } + return same; +} + +std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu& gpu) { + std::vector<std::unique_ptr<AppVideoProfile>> result{}; + + struct ChromaSubsamplingInfo { + VkVideoChromaSubsamplingFlagsKHR value; + const char* name; + }; + const std::vector<ChromaSubsamplingInfo> chroma_subsampling_list = { + {VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, "4:2:0"}, + {VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, "4:2:2"}, + {VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, "4:4:4"}, + {VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, "monochrome"}}; + + struct BitDepthInfo { + VkVideoComponentBitDepthFlagsKHR value; + const char* name; + }; + const std::vector<BitDepthInfo> bit_depth_list = {{VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, "8"}, + {VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, "10"}, + {VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR, "12"}}; + + auto find_caps_struct = [](const VkVideoCapabilitiesKHR& capabilities, VkStructureType stype) -> const VkBaseInStructure* { + auto p = reinterpret_cast<const VkBaseInStructure*>(&capabilities); + while (p != nullptr) { + if (p->sType == stype) { + return p; + } + p = p->pNext; + } + return nullptr; + }; + + auto base_format = [](const ChromaSubsamplingInfo& chroma_subsampling, const BitDepthInfo& luma_bit_depth, + const BitDepthInfo& chroma_bit_depth) { + std::string result{}; + result += " ("; + result += chroma_subsampling.name; + result += " "; + result += luma_bit_depth.name; + if (luma_bit_depth.value != chroma_bit_depth.value) { + result += ":"; + result += chroma_bit_depth.name; + } + result += "-bit)"; + return result; + }; + + auto add_profile = [&](const std::string& name, const VkVideoProfileInfoKHR& profile_info, + AppVideoProfile::CreateProfileInfoChainCb create_profile_info_chain, + AppVideoProfile::CreateCapabilitiesChainCb create_capabilities_chain, + const AppVideoProfile::CreateFormatPropertiesChainCbList& create_format_properties_chain_list, + AppVideoProfile::InitProfileCb init_profile) { + auto profile = + std::make_unique<AppVideoProfile>(gpu, gpu.phys_device, name, profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, init_profile); + if (profile->supported) { + result.push_back(std::move(profile)); + } + }; + + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) { + const std::string codec_name = "H.264 Decode"; + + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && + luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); + VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + nullptr, + VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, + chroma_subsampling.value, + luma_bit_depth.value, + chroma_bit_depth.value}; + + auto create_profile_info_chain = [&](const void** ppnext) -> std::unique_ptr<video_profile_info_chain> { + auto profile_info_chain = std::make_unique<video_profile_info_chain>(); + if (profile_info_chain != nullptr) { + profile_info_chain->VideoDecodeH264ProfileInfoKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; + profile_info_chain->VideoDecodeH264ProfileInfoKHR.pNext = nullptr; + *ppnext = &profile_info_chain->VideoDecodeH264ProfileInfoKHR; + ppnext = &profile_info_chain->VideoDecodeH264ProfileInfoKHR.pNext; + } + return profile_info_chain; + }; + + auto create_capabilities_chain = [&](void** ppnext) -> std::unique_ptr<video_capabilities_chain> { + auto capabilities_chain = std::make_unique<video_capabilities_chain>(); + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeH264CapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeH264CapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeH264CapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeH264CapabilitiesKHR.pNext; + } + } + return capabilities_chain; + }; + + const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = { + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Decode Output", + VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "DPB", + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + }; + + add_profile(profile_base_name + " Baseline progressive", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_BASELINE; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR; + }); + add_profile(profile_base_name + " Main progressive", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_MAIN; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR; + }); + add_profile(profile_base_name + " High progressive", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR; + }); + add_profile(profile_base_name + " High 4:4:4 Predictive progressive", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR; + }); + add_profile(profile_base_name + " Baseline interlaced (interleaved lines)", profile_info, + create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list, + [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_BASELINE; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR; + }); + add_profile(profile_base_name + " Main interlaced (interleaved lines)", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_MAIN; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR; + }); + add_profile(profile_base_name + " High interlaced (interleaved lines)", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR; + }); + add_profile(profile_base_name + " High 4:4:4 Predictive interlaced (interleaved lines)", profile_info, + create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list, + [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR; + }); + add_profile(profile_base_name + " Baseline interlaced (separate planes)", profile_info, + create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list, + [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_BASELINE; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR; + }); + add_profile(profile_base_name + " Main interlaced (separate planes)", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_MAIN; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR; + }); + add_profile(profile_base_name + " High interlaced (separate planes)", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR; + }); + add_profile(profile_base_name + " High 4:4:4 Predictive interlaced (separate planes)", profile_info, + create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list, + [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout = + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR; + }); + } + } + } + } + + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) { + const std::string codec_name = "H.265 Decode"; + + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && + luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); + VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + nullptr, + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, + chroma_subsampling.value, + luma_bit_depth.value, + chroma_bit_depth.value}; + + auto create_profile_info_chain = [&](const void** ppnext) -> std::unique_ptr<video_profile_info_chain> { + auto profile_info_chain = std::make_unique<video_profile_info_chain>(); + if (profile_info_chain != nullptr) { + profile_info_chain->VideoDecodeH265ProfileInfoKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; + profile_info_chain->VideoDecodeH265ProfileInfoKHR.pNext = nullptr; + *ppnext = &profile_info_chain->VideoDecodeH265ProfileInfoKHR; + ppnext = &profile_info_chain->VideoDecodeH265ProfileInfoKHR.pNext; + } + return profile_info_chain; + }; + + auto create_capabilities_chain = [&](void** ppnext) -> std::unique_ptr<video_capabilities_chain> { + auto capabilities_chain = std::make_unique<video_capabilities_chain>(); + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeH265CapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeH265CapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeH265CapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeH265CapabilitiesKHR.pNext; + } + } + return capabilities_chain; + }; + + const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = { + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Decode Output", + VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "DPB", + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + }; + + add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_MAIN; + }); + add_profile(profile_base_name + " Main 10", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_MAIN_10; + }); + add_profile(profile_base_name + " Main Still Picture", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE; + }); + add_profile(profile_base_name + " Format range extensions", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS; + }); + add_profile(profile_base_name + " Screen content coding extensions", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS; + }); + } + } + } + } + + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) { + const std::string codec_name = "VP9 Decode"; + + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && + luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); + VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + nullptr, + VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR, + chroma_subsampling.value, + luma_bit_depth.value, + chroma_bit_depth.value}; + + auto create_profile_info_chain = [&](const void** ppnext) -> std::unique_ptr<video_profile_info_chain> { + auto profile_info_chain = std::make_unique<video_profile_info_chain>(); + if (profile_info_chain != nullptr) { + profile_info_chain->VideoDecodeVP9ProfileInfoKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; + profile_info_chain->VideoDecodeVP9ProfileInfoKHR.pNext = nullptr; + *ppnext = &profile_info_chain->VideoDecodeVP9ProfileInfoKHR; + ppnext = &profile_info_chain->VideoDecodeVP9ProfileInfoKHR.pNext; + } + return profile_info_chain; + }; + + auto create_capabilities_chain = [&](void** ppnext) -> std::unique_ptr<video_capabilities_chain> { + auto capabilities_chain = std::make_unique<video_capabilities_chain>(); + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeVP9CapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeVP9CapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeVP9CapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeVP9CapabilitiesKHR.pNext; + } + } + return capabilities_chain; + }; + + const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = { + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Decode Output", + VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "DPB", + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + }; + + add_profile(profile_base_name + " Profile 0", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_0; + }); + add_profile(profile_base_name + " Profile 1", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_1; + }); + add_profile(profile_base_name + " Profile 2", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_2; + }); + add_profile(profile_base_name + " Profile 3", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_3; + }); + } + } + } + } + + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) { + const std::string codec_name = "AV1 Decode"; + + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && + luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); + VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + nullptr, + VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, + chroma_subsampling.value, + luma_bit_depth.value, + chroma_bit_depth.value}; + + auto create_profile_info_chain = [&](const void** ppnext) -> std::unique_ptr<video_profile_info_chain> { + auto profile_info_chain = std::make_unique<video_profile_info_chain>(); + if (profile_info_chain != nullptr) { + profile_info_chain->VideoDecodeAV1ProfileInfoKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; + profile_info_chain->VideoDecodeAV1ProfileInfoKHR.pNext = nullptr; + *ppnext = &profile_info_chain->VideoDecodeAV1ProfileInfoKHR; + ppnext = &profile_info_chain->VideoDecodeAV1ProfileInfoKHR.pNext; + } + return profile_info_chain; + }; + + auto create_capabilities_chain = [&](void** ppnext) -> std::unique_ptr<video_capabilities_chain> { + auto capabilities_chain = std::make_unique<video_capabilities_chain>(); + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) { + capabilities_chain->VideoDecodeAV1CapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; + capabilities_chain->VideoDecodeAV1CapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoDecodeAV1CapabilitiesKHR; + ppnext = &capabilities_chain->VideoDecodeAV1CapabilitiesKHR.pNext; + } + } + return capabilities_chain; + }; + + const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = { + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Decode Output", + VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "DPB", + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + }; + + add_profile(profile_base_name + " Main with film grain support", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_MAIN; + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE; + }); + add_profile(profile_base_name + " High with film grain support", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_HIGH; + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE; + }); + add_profile(profile_base_name + " Professional with film grain support", profile_info, + create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list, + [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_PROFESSIONAL; + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE; + }); + add_profile(profile_base_name + " Main without film grain support", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_MAIN; + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE; + }); + add_profile(profile_base_name + " High without film grain support", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_HIGH; + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE; + }); + add_profile(profile_base_name + " Professional without film grain support", profile_info, + create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list, + [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_PROFESSIONAL; + profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE; + }); + } + } + } + } + + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) { + const std::string codec_name = "H.264 Encode"; + + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && + luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); + VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + nullptr, + VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, + chroma_subsampling.value, + luma_bit_depth.value, + chroma_bit_depth.value}; + + auto create_profile_info_chain = [&](const void** ppnext) -> std::unique_ptr<video_profile_info_chain> { + auto profile_info_chain = std::make_unique<video_profile_info_chain>(); + if (profile_info_chain != nullptr) { + profile_info_chain->VideoEncodeH264ProfileInfoKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; + profile_info_chain->VideoEncodeH264ProfileInfoKHR.pNext = nullptr; + *ppnext = &profile_info_chain->VideoEncodeH264ProfileInfoKHR; + ppnext = &profile_info_chain->VideoEncodeH264ProfileInfoKHR.pNext; + } + return profile_info_chain; + }; + + auto create_capabilities_chain = [&](void** ppnext) -> std::unique_ptr<video_capabilities_chain> { + auto capabilities_chain = std::make_unique<video_capabilities_chain>(); + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; + capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE; + ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeH264CapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeH264CapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeH264CapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeH264CapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.pNext; + } + } + return capabilities_chain; + }; + + const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = { + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Encode Input", + VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "DPB", + VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Quantization Delta Map", + VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>( + find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR)); + if (caps != nullptr) { + supported = + supported && + ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0); + } else { + supported = false; + } + } else { + supported = false; + } + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext; + } + } + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Emphasis Map", + VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>( + find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR)); + if (caps != nullptr) { + supported = + supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0); + } else { + supported = false; + } + } else { + supported = false; + } + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext; + } + } + return format_properties_chain; + }, + }, + }; + + add_profile(profile_base_name + " Baseline", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_BASELINE; + }); + add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_MAIN; + }); + add_profile(profile_base_name + " High", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH; + }); + add_profile(profile_base_name + " High 4:4:4 Predictive", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + }); + } + } + } + } + + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) { + const std::string codec_name = "H.265 Encode"; + + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && + luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); + VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + nullptr, + VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, + chroma_subsampling.value, + luma_bit_depth.value, + chroma_bit_depth.value}; + + auto create_profile_info_chain = [&](const void** ppnext) -> std::unique_ptr<video_profile_info_chain> { + auto profile_info_chain = std::make_unique<video_profile_info_chain>(); + if (profile_info_chain != nullptr) { + profile_info_chain->VideoEncodeH265ProfileInfoKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; + profile_info_chain->VideoEncodeH265ProfileInfoKHR.pNext = nullptr; + *ppnext = &profile_info_chain->VideoEncodeH265ProfileInfoKHR; + ppnext = &profile_info_chain->VideoEncodeH265ProfileInfoKHR.pNext; + } + return profile_info_chain; + }; + + auto create_capabilities_chain = [&](void** ppnext) -> std::unique_ptr<video_capabilities_chain> { + auto capabilities_chain = std::make_unique<video_capabilities_chain>(); + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; + capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE; + ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeH265CapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeH265CapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeH265CapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeH265CapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.pNext; + } + } + return capabilities_chain; + }; + + const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = { + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Encode Input", + VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "DPB", + VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Quantization Delta Map", + VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>( + find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR)); + if (caps != nullptr) { + supported = + supported && + ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0); + } else { + supported = false; + } + } else { + supported = false; + } + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext; + } + } + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext; + } + } + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Emphasis Map", + VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>( + find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR)); + if (caps != nullptr) { + supported = + supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0); + } else { + supported = false; + } + } else { + supported = false; + } + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext; + } + } + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext; + } + } + return format_properties_chain; + }, + }, + }; + + add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_MAIN; + }); + add_profile(profile_base_name + " Main 10", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_MAIN_10; + }); + add_profile(profile_base_name + " Main Still Picture", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE; + }); + add_profile(profile_base_name + " Format range extensions", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS; + }); + add_profile(profile_base_name + " Screen content coding extensions", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc = + STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS; + }); + } + } + } + } + + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) { + const std::string codec_name = "AV1 Encode"; + + for (auto chroma_subsampling : chroma_subsampling_list) { + for (auto luma_bit_depth : bit_depth_list) { + for (auto chroma_bit_depth : bit_depth_list) { + if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && + luma_bit_depth.value != chroma_bit_depth.value) { + // Ignore the chroma bit depth dimension for monochrome + continue; + } + + std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth); + VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + nullptr, + VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR, + chroma_subsampling.value, + luma_bit_depth.value, + chroma_bit_depth.value}; + + auto create_profile_info_chain = [&](const void** ppnext) -> std::unique_ptr<video_profile_info_chain> { + auto profile_info_chain = std::make_unique<video_profile_info_chain>(); + if (profile_info_chain != nullptr) { + profile_info_chain->VideoEncodeAV1ProfileInfoKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; + profile_info_chain->VideoEncodeAV1ProfileInfoKHR.pNext = nullptr; + *ppnext = &profile_info_chain->VideoEncodeAV1ProfileInfoKHR; + ppnext = &profile_info_chain->VideoEncodeAV1ProfileInfoKHR.pNext; + } + return profile_info_chain; + }; + + auto create_capabilities_chain = [&](void** ppnext) -> std::unique_ptr<video_capabilities_chain> { + auto capabilities_chain = std::make_unique<video_capabilities_chain>(); + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; + capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE; + ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext; + } + } + if (capabilities_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) { + capabilities_chain->VideoEncodeAV1CapabilitiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + capabilities_chain->VideoEncodeAV1CapabilitiesKHR.pNext = nullptr; + *ppnext = &capabilities_chain->VideoEncodeAV1CapabilitiesKHR; + ppnext = &capabilities_chain->VideoEncodeAV1CapabilitiesKHR.pNext; + } + } + return capabilities_chain; + }; + + const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = { + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Encode Input", + VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "DPB", + VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Quantization Delta Map", + VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>( + find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR)); + if (caps != nullptr) { + supported = + supported && + ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0); + } else { + supported = false; + } + } else { + supported = false; + } + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext; + } + } + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext; + } + } + return format_properties_chain; + }, + }, + AppVideoProfile::CreateFormatPropertiesChainCb{ + "Emphasis Map", + VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR, + [&](const VkVideoCapabilitiesKHR& capabilities) -> bool { + bool supported = true; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) { + auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>( + find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR)); + if (caps != nullptr) { + supported = + supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0); + } else { + supported = false; + } + } else { + supported = false; + } + return supported; + }, + [&](void** ppnext) -> std::unique_ptr<video_format_properties_chain> { + auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext; + } + } + if (format_properties_chain != nullptr) { + if (gpu.CheckPhysicalDeviceExtensionIncluded( + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { + format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.sType = + VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext = nullptr; + *ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR; + ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext; + } + } + return format_properties_chain; + }, + }, + }; + + add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_MAIN; + }); + add_profile(profile_base_name + " High", profile_info, create_profile_info_chain, create_capabilities_chain, + create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_HIGH; + }); + add_profile(profile_base_name + " Professional", profile_info, create_profile_info_chain, + create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile& profile) { + profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile = + STD_VIDEO_AV1_PROFILE_PROFESSIONAL; + }); + } + } + } + } + return result; +}
diff --git a/vulkaninfo/outputprinter.h b/vulkaninfo/outputprinter.h index d515b62..8255e92 100644 --- a/vulkaninfo/outputprinter.h +++ b/vulkaninfo/outputprinter.h
@@ -352,7 +352,7 @@ } out << std::string(static_cast<size_t>(get_top().indents), '\t'); // Objects with no name are elements in an array of objects - if (object_name == "" || get_top().element_index != -1) { + if (get_top().is_array || object_name == "" || get_top().element_index != -1) { out << "{\n"; get_top().element_index = -1; } else { @@ -370,12 +370,13 @@ } out << std::string(static_cast<size_t>(get_top().indents), '\t'); - if (get_top().element_index != -1) { - out << "\"" << object_name << "[" << get_top().element_index << "]\": {\n"; + if (get_top().is_array && get_top().element_index != -1) { + out << "\"" << object_name << "[" << get_top().element_index << "]\": "; get_top().element_index = -1; - } else { - out << "\"" << object_name << "\": {\n"; + } else if (!get_top().is_array) { + out << "\"" << object_name << "\": "; } + out << "{\n"; if (!value_description.empty()) { value_description = {}; } @@ -438,9 +439,11 @@ } else { get_top().is_first_item = false; } - out << std::string(static_cast<size_t>(get_top().indents), '\t') << "\"" << array_name << "\": " << "[\n"; - assert(get_top().is_array == false && - "Cant start an array object inside another array, must be enclosed in an object"); + out << std::string(static_cast<size_t>(get_top().indents), '\t'); + if (!get_top().is_array) { + out << "\"" << array_name << "\": "; + } + out << "[\n"; break; default: break; @@ -513,7 +516,10 @@ } else { get_top().is_first_item = false; } - out << std::string(static_cast<size_t>(get_top().indents), '\t') << "\"" << key << "\": "; + out << std::string(static_cast<size_t>(get_top().indents), '\t'); + if (!get_top().is_array) { + out << "\"" << key << "\": "; + } if (!value_description.empty()) { out << "\"" << value << " (" << value_description << ")\""; value_description = {};
diff --git a/vulkaninfo/vulkaninfo.cpp b/vulkaninfo/vulkaninfo.cpp index 8dd9d5e..47456c2 100644 --- a/vulkaninfo/vulkaninfo.cpp +++ b/vulkaninfo/vulkaninfo.cpp
@@ -1,8 +1,8 @@ /* - * Copyright (c) 2015-2021 The Khronos Group Inc. - * Copyright (c) 2015-2021 Valve Corporation - * Copyright (c) 2015-2021 LunarG, Inc. - * Copyright (c) 2023-2023 RasterGrid Kft. + * Copyright (c) 2015-2026 The Khronos Group Inc. + * Copyright (c) 2015-2026 Valve Corporation + * Copyright (c) 2015-2026 LunarG, Inc. + * Copyright (c) 2023-2024 RasterGrid Kft. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,6 +28,7 @@ * */ +#include <string> #ifdef _WIN32 #include <crtdbg.h> #endif @@ -304,10 +305,102 @@ } } // TODO buffer - memory type compatibility + + // Video // + video_profiles = enumerate_supported_video_profiles(*this); + + // Display // + display_planes = enumerate_display_planes(*this); + displays = enumerate_displays(*this, display_planes); + + vkDestroyDevice(dev, nullptr); + dev = VK_NULL_HANDLE; } AppGpu::~AppGpu() { vkDestroyDevice(dev, nullptr); } +AppVideoProfile::AppVideoProfile(AppGpu &gpu, VkPhysicalDevice phys_device, const std::string &in_name, + const VkVideoProfileInfoKHR &in_profile_info, CreateProfileInfoChainCb create_profile_info_chain, + CreateCapabilitiesChainCb create_capabilities_chain, + const CreateFormatPropertiesChainCbList &create_format_properties_chain_list, InitProfileCb init_profile) + : supported(true), name(in_name), profile_info(in_profile_info), capabilities({}) { + profile_info_chain = create_profile_info_chain(&profile_info.pNext); + if (profile_info_chain == nullptr) { + supported = false; + return; + } + + capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; + capabilities.pNext = nullptr; + capabilities_chain = create_capabilities_chain(&capabilities.pNext); + if (capabilities_chain == nullptr) { + supported = false; + return; + } + + init_profile(*this); + + VkResult result = vkGetPhysicalDeviceVideoCapabilitiesKHR(phys_device, &profile_info, &capabilities); + if (result != VK_SUCCESS) { + supported = false; + return; + } + + VkVideoProfileListInfoKHR profile_list = {VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, nullptr, 1, &profile_info}; + + std::vector<VkVideoFormatPropertiesKHR> video_format_props{}; + std::vector<std::unique_ptr<video_format_properties_chain>> video_format_props_chains{}; + for (const auto &create_format_properties_chain_info : create_format_properties_chain_list) { + if (!create_format_properties_chain_info.check_required_caps(capabilities)) { + continue; + } + + VkPhysicalDeviceVideoFormatInfoKHR video_format_info = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, + &profile_list, + create_format_properties_chain_info.image_usage_flags}; + + uint32_t video_format_property_count = 0; + result = + vkGetPhysicalDeviceVideoFormatPropertiesKHR(phys_device, &video_format_info, &video_format_property_count, nullptr); + if (result != VK_SUCCESS) { + continue; + } + + video_format_props.resize(video_format_property_count); + video_format_props_chains.resize(video_format_property_count); + + for (uint32_t i = 0; i < video_format_property_count; ++i) { + video_format_props[i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; + video_format_props_chains[i] = create_format_properties_chain_info.callback(&video_format_props[i].pNext); + } + + result = vkGetPhysicalDeviceVideoFormatPropertiesKHR(phys_device, &video_format_info, &video_format_property_count, + video_format_props.data()); + if (result == VK_SUCCESS) { + for (uint32_t i = 0; i < video_format_property_count; ++i) { + const VkVideoFormatPropertiesKHR *existing_format = nullptr; + for (const auto &format : formats) { + if (is_video_format_same(format.properties, video_format_props[i])) { + existing_format = &format.properties; + break; + } + } + if (existing_format == nullptr) { + formats.push_back(Format{video_format_props[i], std::move(video_format_props_chains[i])}); + formats_by_category[create_format_properties_chain_info.format_name].push_back(video_format_props[i]); + } else { + formats_by_category[create_format_properties_chain_info.format_name].push_back(*existing_format); + } + } + } + + video_format_props.clear(); + video_format_props_chains.clear(); + } +} + +AppVideoProfile::~AppVideoProfile() = default; + // Used to sort the formats into buckets by their properties. std::unordered_map<PropFlags, std::set<VkFormat>> FormatPropMap(AppGpu &gpu) { std::unordered_map<PropFlags, std::set<VkFormat>> map; @@ -445,12 +538,17 @@ if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { chain_iterator_surface_capabilities2(p, inst, gpu, surface.surface_capabilities2_khr.pNext); } - if (inst.CheckExtensionEnabled(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME)) { + if (inst.CheckExtensionEnabled(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME) || + inst.CheckExtensionEnabled(VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME)) { + const char *surf_ext_name = VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME; + if (!inst.CheckExtensionEnabled(VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME)) { + surf_ext_name = VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME; + } p.SetSubHeader(); - ObjectWrapper obj(p, "VK_EXT_surface_maintenance1"); + ObjectWrapper obj(p, surf_ext_name); for (auto &mode : surface.surf_present_modes) { - VkSurfacePresentModeEXT present_mode{}; - present_mode.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT; + VkSurfacePresentModeKHR present_mode{}; + present_mode.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR; present_mode.presentMode = mode; VkPhysicalDeviceSurfaceInfo2KHR surface_info{}; @@ -458,24 +556,24 @@ surface_info.surface = surface.surface_extension.surface; surface_info.pNext = &present_mode; - VkSurfacePresentModeCompatibilityEXT SurfacePresentModeCompatibilityEXT{}; - SurfacePresentModeCompatibilityEXT.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; + VkSurfacePresentModeCompatibilityKHR SurfacePresentModeCompatibilityKHR{}; + SurfacePresentModeCompatibilityKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; - VkSurfacePresentScalingCapabilitiesEXT SurfacePresentScalingCapabilitiesEXT{}; - SurfacePresentScalingCapabilitiesEXT.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; - SurfacePresentScalingCapabilitiesEXT.pNext = &SurfacePresentModeCompatibilityEXT; + VkSurfacePresentScalingCapabilitiesKHR SurfacePresentScalingCapabilitiesKHR{}; + SurfacePresentScalingCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; + SurfacePresentScalingCapabilitiesKHR.pNext = &SurfacePresentModeCompatibilityKHR; VkSurfaceCapabilities2KHR surface_caps2{}; surface_caps2.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR; - surface_caps2.pNext = &SurfacePresentScalingCapabilitiesEXT; + surface_caps2.pNext = &SurfacePresentScalingCapabilitiesKHR; VkResult err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu.phys_device, &surface_info, &surface_caps2); if (err != VK_SUCCESS) { continue; } - std::vector<VkPresentModeKHR> compatible_present_modes{SurfacePresentModeCompatibilityEXT.presentModeCount}; - SurfacePresentModeCompatibilityEXT.pPresentModes = compatible_present_modes.data(); + std::vector<VkPresentModeKHR> compatible_present_modes{SurfacePresentModeCompatibilityKHR.presentModeCount}; + SurfacePresentModeCompatibilityKHR.pPresentModes = compatible_present_modes.data(); err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu.phys_device, &surface_info, &surface_caps2); @@ -485,17 +583,32 @@ p.PrintKeyValue("minImageCount", surface_caps2.surfaceCapabilities.minImageCount); p.PrintKeyValue("maxImageCount", surface_caps2.surfaceCapabilities.maxImageCount); - DumpVkSurfacePresentScalingCapabilitiesEXT(p, "VkSurfacePresentScalingCapabilitiesEXT", - SurfacePresentScalingCapabilitiesEXT); - DumpVkSurfacePresentModeCompatibilityEXT(p, "VkSurfacePresentModeCompatibilityEXT", - SurfacePresentModeCompatibilityEXT); + DumpVkSurfacePresentScalingCapabilitiesKHR(p, "VkSurfacePresentScalingCapabilitiesKHR", + SurfacePresentScalingCapabilitiesKHR); + DumpVkSurfacePresentModeCompatibilityKHR(p, "VkSurfacePresentModeCompatibilityKHR", + SurfacePresentModeCompatibilityKHR); } } } } void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface, std::set<std::string> surface_types) { - ObjectWrapper obj(p, std::string("GPU id : ") + p.DecorateAsValue(std::to_string(gpu.id)) + " (" + gpu.props.deviceName + ")"); + std::string surface_type_list_str = ""; + if (surface_types.size() > 0) { + surface_type_list_str = " ["; + bool is_first = true; + for (auto &name : surface_types) { + if (!is_first) { + surface_type_list_str += ", "; + } else { + is_first = false; + } + surface_type_list_str += name; + } + surface_type_list_str += "]"; + } + ObjectWrapper obj(p, std::string("GPU id : ") + p.DecorateAsValue(std::to_string(gpu.id)) + " (" + gpu.props.deviceName + ")" + + surface_type_list_str); if (surface_types.size() == 0) { p.SetAsType().PrintKeyString("Surface type", "No type found"); @@ -846,6 +959,60 @@ } } +void GpuDumpCooperativeMatrix(Printer &p, AppGpu &gpu) { + auto props = GetCooperativeMatrixInfo(gpu); + if (props.size() > 0) { + p.SetSubHeader(); + ObjectWrapper obj(p, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"); + for (const auto prop : props) { + DumpVkCooperativeMatrixPropertiesKHR(p, "VkCooperativeMatrixPropertiesKHR", prop); + p.AddNewline(); + } + } +} + +void GpuDumpCalibrateableTimeDomain(Printer &p, AppGpu &gpu) { + auto props = GetTimeDomainInfo(gpu); + if (props.size() > 0) { + p.SetSubHeader(); + ObjectWrapper obj_mem_props(p, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"); + { + for (uint32_t i = 0; i < props.size(); ++i) { + p.SetElementIndex(static_cast<int>(i)); + DumpVkTimeDomainKHR(p, "pTimeDomains", props[i]); + p.AddNewline(); + } + } + } +} + +void GpuDumpFragmentShadingRate(Printer &p, AppGpu &gpu) { + auto props = GetFragmentShadingRateInfo(gpu); + if (props.size() > 0) { + p.SetSubHeader(); + ObjectWrapper obj(p, "vkGetPhysicalDeviceFragmentShadingRatesKHR"); + for (const auto prop : props) { + DumpVkPhysicalDeviceFragmentShadingRateKHR(p, "VkPhysicalDeviceFragmentShadingRateKHR", prop); + p.AddNewline(); + } + } +} + +// VK_EXT_sample_locations ('Multisample Properties' is too ambiguous of a name) +void GpuDumpSampleLocations(Printer &p, AppGpu &gpu) { + auto props = GetSampleLocationInfo(gpu); + if (props.size() > 0) { + p.SetSubHeader(); + ObjectWrapper obj(p, "vkGetPhysicalDeviceMultisamplePropertiesEXT"); + for (uint32_t i = 0; i < props.size(); i++) { + const VkSampleCountFlagBits sample_count = (VkSampleCountFlagBits)(1 << i); + DumpVkSampleCountFlagBits(p, "samples", sample_count); + DumpVkMultisamplePropertiesEXT(p, "VkMultisamplePropertiesEXT", props[i]); + p.AddNewline(); + } + } +} + void GpuDevDump(Printer &p, AppGpu &gpu) { p.SetHeader(); ObjectWrapper obj_format_props(p, "Format Properties"); @@ -893,13 +1060,224 @@ p.AddNewline(); } +void DumpVkVideoProfileInfoKHRCustom(Printer &p, std::string name, const VkVideoProfileInfoKHR &obj) { + // We use custom dumping here because we do not want to output ignored fields + // e.g. for monochrome chromaBitDepth is ignored + ObjectWrapper object{p, name}; + DumpVkVideoCodecOperationFlagBitsKHR(p, "videoCodecOperation", obj.videoCodecOperation); + DumpVkVideoChromaSubsamplingFlagsKHR(p, "chromaSubsampling", obj.chromaSubsampling); + DumpVkVideoComponentBitDepthFlagsKHR(p, "lumaBitDepth", obj.lumaBitDepth); + if (obj.chromaSubsampling != VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR) { + DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", obj.chromaBitDepth); + } else { + DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", 0); + } +} + +void GpuDumpVideoProfiles(Printer &p, AppGpu &gpu, bool show_video_props) { + p.SetHeader(); + ObjectWrapper video_profiles_obj(p, "Video Profiles", gpu.video_profiles.size()); + IndentWrapper indent_outer(p); + + if (p.Type() != OutputType::text || show_video_props) { + // Video profile details per profile + for (const auto &video_profile : gpu.video_profiles) { + p.SetSubHeader(); + ObjectWrapper video_profile_obj(p, video_profile->name); + IndentWrapper indent_inner(p); + { + p.SetSubHeader(); + ObjectWrapper profile_info_obj(p, "Video Profile Definition"); + p.SetSubHeader(); + DumpVkVideoProfileInfoKHRCustom(p, "VkVideoProfileInfoKHR", video_profile->profile_info); + chain_iterator_video_profile_info(p, gpu, video_profile->profile_info.pNext); + } + { + p.SetSubHeader(); + ObjectWrapper capabilities_obj(p, "Video Profile Capabilities"); + p.SetSubHeader(); + DumpVkVideoCapabilitiesKHR(p, "VkVideoCapabilitiesKHR", video_profile->capabilities); + chain_iterator_video_capabilities(p, gpu, video_profile->capabilities.pNext); + } + { + p.SetSubHeader(); + ObjectWrapper video_formats_obj(p, "Video Formats"); + for (const auto &video_formats_it : video_profile->formats_by_category) { + const auto &video_format_category_name = video_formats_it.first; + const auto &video_format_props = video_formats_it.second; + ObjectWrapper video_format_category(p, video_format_category_name, video_format_props.size()); + for (size_t i = 0; i < video_format_props.size(); ++i) { + ObjectWrapper video_format_obj(p, video_format_category_name + " Format #" + std::to_string(i + 1)); + p.SetSubHeader(); + DumpVkVideoFormatPropertiesKHR(p, "VkVideoFormatPropertiesKHR", video_format_props[i]); + chain_iterator_video_format_properties(p, gpu, video_format_props[i].pNext); + } + } + } + + p.AddNewline(); + } + } else { + // Video profile list only + for (const auto &video_profile : gpu.video_profiles) { + p.PrintString(video_profile->name); + } + } + + p.AddNewline(); +} + +AppDisplayPlane::AppDisplayPlane(AppGpu &gpu, uint32_t index, const VkDisplayPlanePropertiesKHR &in_prop) + : global_index(index), properties(in_prop) { + std::ostringstream display_name; + + supported_displays = GetVector<VkDisplayKHR>("vkGetDisplayPlaneSupportedDisplaysKHR", vkGetDisplayPlaneSupportedDisplaysKHR, + gpu.phys_device, global_index); +} + +std::vector<AppDisplayPlane> enumerate_display_planes(AppGpu &gpu) { + std::vector<AppDisplayPlane> result; + if (vkGetPhysicalDeviceDisplayPlanePropertiesKHR) { + auto planes = GetVector<VkDisplayPlanePropertiesKHR>("vkGetPhysicalDeviceDisplayPlanePropertiesKHR", + vkGetPhysicalDeviceDisplayPlanePropertiesKHR, gpu.phys_device); + for (uint32_t i = 0; i < planes.size(); i++) { + result.emplace_back(gpu, i, planes[i]); + } + } + return result; +} + +AppDisplayMode::AppDisplayMode(AppGpu &gpu, const VkDisplayModePropertiesKHR &in_properties, + const std::set<uint32_t> &supported_planes) + : properties(in_properties) { + for (auto plane : supported_planes) { + VkDisplayPlaneCapabilitiesKHR cap; + + vkGetDisplayPlaneCapabilitiesKHR(gpu.phys_device, properties.displayMode, plane, &cap); + capabilities[plane] = cap; + } +} + +static std::string MakeName(uint32_t index, const VkDisplayPropertiesKHR &prop) { + std::stringstream name; + name << "Display id : " << index << " (" << prop.displayName << ")"; + return name.str(); +} + +AppDisplay::AppDisplay(AppGpu &gpu, uint32_t index, const VkDisplayPropertiesKHR &in_properties, + const std::vector<AppDisplayPlane> &all_planes) + : global_index(index), name(MakeName(index, in_properties)), properties(in_properties) { + auto mode_props = GetVector<VkDisplayModePropertiesKHR>("vkGetDisplayModePropertiesKHR", vkGetDisplayModePropertiesKHR, + gpu.phys_device, properties.display); + + std::set<uint32_t> supported_planes; + for (const auto &plane : all_planes) { + for (const auto &display : plane.supported_displays) { + if (display == properties.display) { + supported_planes.insert(plane.global_index); + } + } + } + + for (const auto &prop : mode_props) { + modes.emplace_back(gpu, prop, supported_planes); + } +} + +std::vector<AppDisplay> enumerate_displays(AppGpu &gpu, const std::vector<AppDisplayPlane> &all_planes) { + std::vector<AppDisplay> result; + + if (vkGetPhysicalDeviceDisplayPropertiesKHR) { + auto properties = GetVector<VkDisplayPropertiesKHR>("vkGetPhysicalDeviceDisplayPropertiesKHR", + vkGetPhysicalDeviceDisplayPropertiesKHR, gpu.phys_device); + + for (uint32_t i = 0; i < properties.size(); i++) { + result.emplace_back(gpu, i, properties[i], all_planes); + } + } + return result; +} + +void GpuDumpDisplays(Printer &p, AppGpu &gpu) { + if (gpu.displays.size() == 0) { + return; + } + + p.SetHeader(); + ObjectWrapper display_props_obj(p, "Display Properties", gpu.displays.size()); + + for (const auto &display : gpu.displays) { + p.SetSubHeader(); + ObjectWrapper display_obj(p, display.name); + + DumpVkDisplayPropertiesKHR(p, "VkDisplayPropertiesKHR", display.properties); + ArrayWrapper arr(p, "Display Modes", display.modes.size()); + + for (uint32_t m = 0; m < display.modes.size(); m++) { + const auto &mode = display.modes[m]; + std::ostringstream mode_name; + mode_name << "Display Mode : " << p.DecorateAsValue(std::to_string(m)) << " (" + << mode.properties.parameters.visibleRegion.width << " x " << mode.properties.parameters.visibleRegion.height + << ")"; + + ObjectWrapper mode_obj(p, mode_name.str()); + + DumpVkDisplayModeParametersKHR(p, "VkDisplayModeParametersKHR", mode.properties.parameters); + + ArrayWrapper cap_arr(p, "Display Plane Capabilities", mode.capabilities.size()); + for (const auto &cap : mode.capabilities) { + std::ostringstream cap_name; + cap_name << "Capabilities (Plane " << p.DecorateAsValue(std::to_string(cap.first)) << ")"; + + ObjectWrapper cap_obj(p, cap_name.str()); + + DumpVkDisplayPlaneCapabilitiesKHR(p, "VkDisplayPlaneCapabilitiesKHR", cap.second); + } + } + } +} + +void GpuDumpDisplayPlanes(Printer &p, AppGpu &gpu) { + if (gpu.display_planes.size() == 0) { + return; + } + + p.SetHeader(); + ObjectWrapper display_props_obj(p, "Display Plane Properties", gpu.display_planes.size()); + + for (const auto &plane : gpu.display_planes) { + p.SetSubHeader(); + ObjectWrapper display_obj(p, std::string("Display Plane id : ") + p.DecorateAsValue(std::to_string(plane.global_index))); + + auto *current = gpu.FindDisplay(plane.properties.currentDisplay); + + p.PrintKeyString("currentDisplay", current ? current->name.c_str() : "none"); + + DumpVkDisplayPlanePropertiesKHR(p, "VkDisplayPlanePropertiesKHR", plane.properties); + + ArrayWrapper arr(p, "Supported Displays", plane.supported_displays.size()); + for (auto handle : plane.supported_displays) { + auto *display = gpu.FindDisplay(handle); + p.SetAsType().PrintString(display ? display->name.c_str() : "UNKNOWN"); + } + } +} + +struct ShowSettings { + bool all = false; + bool tool_props = false; + bool formats = false; + bool promoted_structs = false; + bool video_props = false; +}; + // Print gpu info for text, html, & vkconfig_output // Uses a separate function than schema-json for clarity -void DumpGpu(Printer &p, AppGpu &gpu, bool show_tooling_info, bool show_formats, bool show_promoted_structs) { +void DumpGpu(Printer &p, AppGpu &gpu, const ShowSettings &show) { ObjectWrapper obj_gpu(p, "GPU" + std::to_string(gpu.id)); IndentWrapper indent(p); - GpuDumpProps(p, gpu, show_promoted_structs); + GpuDumpProps(p, gpu, show.promoted_structs); DumpExtensions(p, "Device Extensions", gpu.device_extensions); p.AddNewline(); { @@ -910,27 +1288,46 @@ } } GpuDumpMemoryProps(p, gpu); - GpuDumpFeatures(p, gpu, show_promoted_structs); - if (show_tooling_info) { + GpuDumpFeatures(p, gpu, show.promoted_structs); + if (show.tool_props) { GpuDumpToolingInfo(p, gpu); } - if (p.Type() != OutputType::text || show_formats) { + if (show.all) { + GpuDumpCooperativeMatrix(p, gpu); + GpuDumpCalibrateableTimeDomain(p, gpu); + GpuDumpFragmentShadingRate(p, gpu); + GpuDumpSampleLocations(p, gpu); + } + + if (p.Type() != OutputType::text || show.formats) { GpuDevDump(p, gpu); } + if (!gpu.video_profiles.empty()) { + GpuDumpVideoProfiles(p, gpu, show.video_props); + } + + if (!gpu.displays.empty()) { + GpuDumpDisplays(p, gpu); + } + + if (!gpu.display_planes.empty()) { + GpuDumpDisplayPlanes(p, gpu); + } + p.AddNewline(); } // Print capabilities section of profiles schema -void DumpGpuProfileCapabilities(Printer &p, AppGpu &gpu) { +void DumpGpuProfileCapabilities(Printer &p, AppGpu &gpu, bool show_promoted_structs) { ObjectWrapper capabilities(p, "capabilities"); { ObjectWrapper temp_name_obj(p, "device"); DumpExtensions(p, "extensions", gpu.device_extensions); { ObjectWrapper obj(p, "features"); - GpuDumpFeatures(p, gpu, false); + GpuDumpFeatures(p, gpu, show_promoted_structs); } { ObjectWrapper obj(p, "properties"); @@ -953,7 +1350,7 @@ } if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { void *place = gpu.props2.pNext; - chain_iterator_phys_device_props2(p, gpu.inst, gpu, false, place); + chain_iterator_phys_device_props2(p, gpu.inst, gpu, show_promoted_structs, place); } } { @@ -1006,6 +1403,30 @@ chain_iterator_queue_properties2(p, gpu, extended_queue_prop.pNext); } } + if (!gpu.video_profiles.empty()) { + ArrayWrapper video_profiles(p, "videoProfiles"); + for (const auto &video_profile : gpu.video_profiles) { + ObjectWrapper video_profile_obj(p, ""); + { + ObjectWrapper profile_info_obj(p, "profile"); + DumpVkVideoProfileInfoKHRCustom(p, "VkVideoProfileInfoKHR", video_profile->profile_info); + chain_iterator_video_profile_info(p, gpu, video_profile->profile_info.pNext); + } + { + ObjectWrapper capabilities_obj(p, "capabilities"); + DumpVkVideoCapabilitiesKHR(p, "VkVideoCapabilitiesKHR", video_profile->capabilities); + chain_iterator_video_capabilities(p, gpu, video_profile->capabilities.pNext); + } + { + ArrayWrapper video_formats(p, "formats"); + for (const auto &video_format : video_profile->formats) { + ObjectWrapper video_format_obj(p, ""); + DumpVkVideoFormatPropertiesKHR(p, "VkVideoFormatPropertiesKHR", video_format.properties); + chain_iterator_video_format_properties(p, gpu, video_format.properties.pNext); + } + } + } + } } #if defined(VK_ENABLE_BETA_EXTENSIONS) // Print portability subset extension, features, and properties if available @@ -1058,7 +1479,9 @@ p.PrintKeyString("api-version", APIVersion(apiVersion).str()); p.PrintKeyString("label", device_label); p.PrintKeyString("description", std::string("Exported from ") + APP_SHORT_NAME); - { ObjectWrapper contributors(p, "contributors"); } + { + ObjectWrapper contributors(p, "contributors"); + } { ArrayWrapper contributors(p, "history"); ObjectWrapper element(p, ""); @@ -1211,16 +1634,23 @@ "_[DEVICE_NAME]_[DRIVER_VERSION].json\"\n" " of the first gpu in the system.\n" "[-j=<gpu-number>, --json=<gpu-number>]\n" - " For a multi-gpu system, a single gpu can be targetted by\n" + " For a multi-gpu system, a single gpu can be targeted by\n" " specifying the gpu-number associated with the gpu of \n" " interest. This number can be determined by running\n" " " APP_SHORT_NAME " without any options specified.\n" + "[--show-all] Show everything (includes all the below options)\n" "[--show-tool-props] Show the active VkPhysicalDeviceToolPropertiesEXT that " APP_SHORT_NAME " finds.\n" "[--show-formats] Display the format properties of each physical device.\n" " Note: This only affects text output.\n" - "[--show-promoted-structs] Include structs promoted to core in pNext Chains.\n"; + "[--show-promoted-structs] Include structs promoted to core in pNext Chains.\n" + "[--show-video-props]\n" + " Display the video profile info, video capabilities and\n" + " video format properties of each video profile supported\n" + " by each physical device.\n" + " Note: This only affects text output which by default\n" + " only contains the list of supported video profile names.\n"; void print_usage(const std::string &executable_name) { std::cout << "\n" APP_SHORT_NAME " - Summarize " API_NAME " information in relation to the current environment.\n\n"; @@ -1230,27 +1660,26 @@ std::cout << " " << executable_name << " -j | -j=<gpu-number> | --json | --json=<gpu-number>\n"; std::cout << " " << executable_name << " --text\n"; std::cout << " " << executable_name << " --html\n"; + std::cout << " " << executable_name << " --show-all\n"; std::cout << " " << executable_name << " --show-formats\n"; std::cout << " " << executable_name << " --show-tool-props\n"; std::cout << " " << executable_name << " --show-promoted-structs\n"; + std::cout << " " << executable_name << " --show-video-props\n"; std::cout << "\n" << help_message_body << std::endl; } struct ParsedResults { - OutputCategory output_category; - uint32_t selected_gpu; - bool has_selected_gpu; // differentiate between selecting the 0th gpu and using the default 0th value - bool show_tool_props; - bool show_formats; - bool show_promoted_structs; - bool print_to_file; - std::string filename; // set if explicitely given, or if vkconfig_output has a <path> argument + OutputCategory output_category = OutputCategory::text; + uint32_t selected_gpu = 0; + bool has_selected_gpu = false; // differentiate between selecting the 0th gpu and using the default 0th value + ShowSettings show; + bool print_to_file = false; + std::string filename; // set if explicitly given, or if vkconfig_output has a <path> argument std::string default_filename; }; util::vulkaninfo_optional<ParsedResults> parse_arguments(int argc, char **argv, std::string executable_name) { - ParsedResults results{}; // default it to zero init everything - results.output_category = OutputCategory::text; // default output category + ParsedResults results{}; results.default_filename = APP_SHORT_NAME ".txt"; for (int i = 1; i < argc; ++i) { // A internal-use-only format for communication with the Vulkan Configurator tool @@ -1289,12 +1718,20 @@ results.output_category = OutputCategory::html; results.print_to_file = true; results.default_filename = APP_SHORT_NAME ".html"; + } else if (strcmp(argv[i], "--show-all") == 0) { + results.show.all = true; + results.show.tool_props = true; + results.show.formats = true; + results.show.promoted_structs = true; + results.show.video_props = true; } else if (strcmp(argv[i], "--show-tool-props") == 0) { - results.show_tool_props = true; + results.show.tool_props = true; } else if (strcmp(argv[i], "--show-formats") == 0) { - results.show_formats = true; + results.show.formats = true; } else if (strcmp(argv[i], "--show-promoted-structs") == 0) { - results.show_promoted_structs = true; + results.show.promoted_structs = true; + } else if (strcmp(argv[i], "--show-video-props") == 0) { + results.show.video_props = true; } else if ((strcmp(argv[i], "--output") == 0 || strcmp(argv[i], "-o") == 0) && argc > (i + 1)) { if (argv[i + 1][0] == '-') { std::cout << "-o or --output must be followed by a filename\n"; @@ -1362,7 +1799,7 @@ DumpSummaryGPU(p, *(gpu.get())); } } else if (parse_data.output_category == OutputCategory::profile_json) { - DumpGpuProfileCapabilities(p, *(gpus.at(parse_data.selected_gpu).get())); + DumpGpuProfileCapabilities(p, *(gpus.at(parse_data.selected_gpu).get()), parse_data.show.promoted_structs); DumpGpuProfileInfo(p, *(gpus.at(parse_data.selected_gpu).get())); } else { // text, html, vkconfig_output @@ -1382,7 +1819,7 @@ IndentWrapper indent(p); for (auto &gpu : gpus) { - DumpGpu(p, *(gpu.get()), parse_data.show_tool_props, parse_data.show_formats, parse_data.show_promoted_structs); + DumpGpu(p, *(gpu.get()), parse_data.show); } } } @@ -1455,7 +1892,7 @@ uint32_t gpu_counter = 0; for (auto &phys_device : phys_devices) { gpus.push_back( - std::unique_ptr<AppGpu>(new AppGpu(instance, gpu_counter++, phys_device, parse_data.show_promoted_structs))); + std::unique_ptr<AppGpu>(new AppGpu(instance, gpu_counter++, phys_device, parse_data.show.promoted_structs))); } std::vector<std::unique_ptr<AppSurface>> surfaces;
diff --git a/vulkaninfo/vulkaninfo.h b/vulkaninfo/vulkaninfo.h index 0aff2fa..47aea4a 100644 --- a/vulkaninfo/vulkaninfo.h +++ b/vulkaninfo/vulkaninfo.h
@@ -1,8 +1,8 @@ /* - * Copyright (c) 2015-2021 The Khronos Group Inc. - * Copyright (c) 2015-2021 Valve Corporation - * Copyright (c) 2015-2021 LunarG, Inc. - * Copyright (c) 2023-2023 RasterGrid Kft. + * Copyright (c) 2015-2026 The Khronos Group Inc. + * Copyright (c) 2015-2026 Valve Corporation + * Copyright (c) 2015-2026 LunarG, Inc. + * Copyright (c) 2023-2024 RasterGrid Kft. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -30,9 +30,11 @@ #include <algorithm> #include <array> +#include <cstdint> #include <exception> #include <iostream> #include <fstream> +#include <map> #include <memory> #include <ostream> #include <set> @@ -41,6 +43,7 @@ #include <set> #include <vector> #include <utility> +#include <functional> #include <assert.h> #include <stdint.h> @@ -83,10 +86,9 @@ #include <wayland-client.h> #endif -#include <vulkan/vulkan.h> +#include "vulkaninfo_functions.h" -#define VOLK_IMPLEMENTATION -#include "volk.h" +#include <vulkan/vulkan.h> static std::string VkResultString(VkResult err); @@ -260,8 +262,15 @@ struct surface_capabilities2_chain; struct format_properties2_chain; struct queue_properties2_chain; +struct video_profile_info_chain; +struct video_capabilities_chain; +struct video_format_properties_chain; struct AppInstance; struct AppGpu; +struct AppVideoProfile; +struct AppDisplay; +struct AppDisplayMode; +struct AppDisplayPlane; void setup_phys_device_props2_chain(VkPhysicalDeviceProperties2 &start, std::unique_ptr<phys_device_props2_chain> &chain, AppInstance &inst, AppGpu &gpu, bool show_promoted_structs); @@ -276,6 +285,12 @@ bool prepare_phys_device_props2_twocall_chain_vectors(std::unique_ptr<phys_device_props2_chain> &chain); +bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b); +std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu); + +std::vector<AppDisplayPlane> enumerate_display_planes(AppGpu &gpu); +std::vector<AppDisplay> enumerate_displays(AppGpu &gpu, const std::vector<AppDisplayPlane> &all_planes); + /* An ptional contains either a value or nothing. The optional asserts if a value is trying to be gotten but none exist. * The interface is taken from C++17's <optional> with many aspects removed. * This class assumes the template type is 'trivial' @@ -325,6 +340,72 @@ bool operator==(const SurfaceExtension &other) { return name == other.name && surface == other.surface; } }; +struct AppVideoProfile { + bool supported; + + std::string name; + + VkVideoProfileInfoKHR profile_info; + std::unique_ptr<video_profile_info_chain> profile_info_chain; + + VkVideoCapabilitiesKHR capabilities; + std::unique_ptr<video_capabilities_chain> capabilities_chain; + + struct Format { + VkVideoFormatPropertiesKHR properties; + std::unique_ptr<video_format_properties_chain> properties_chain; + }; + std::vector<Format> formats; + std::unordered_map<std::string, std::vector<VkVideoFormatPropertiesKHR>> formats_by_category; + + using CreateProfileInfoChainCb = std::function<std::unique_ptr<video_profile_info_chain>(const void **)>; + using CreateCapabilitiesChainCb = std::function<std::unique_ptr<video_capabilities_chain>(void **)>; + struct CreateFormatPropertiesChainCb { + std::string format_name; + VkImageUsageFlags image_usage_flags; + std::function<bool(const VkVideoCapabilitiesKHR &capabilities)> check_required_caps; + std::function<std::unique_ptr<video_format_properties_chain>(void **)> callback; + }; + using CreateFormatPropertiesChainCbList = std::vector<CreateFormatPropertiesChainCb>; + using InitProfileCb = std::function<void(AppVideoProfile &)>; + + AppVideoProfile(AppGpu &gpu, VkPhysicalDevice phys_device, const std::string &in_name, + const VkVideoProfileInfoKHR &in_profile_info, CreateProfileInfoChainCb create_profile_info_chain, + CreateCapabilitiesChainCb create_capabilities_chain, + const CreateFormatPropertiesChainCbList &create_format_properties_chain_list, InitProfileCb init_profile); + ~AppVideoProfile(); +}; + +struct AppDisplayPlane { + uint32_t global_index; + std::string name; + VkDisplayPlanePropertiesKHR properties; + std::vector<VkDisplayKHR> supported_displays; + + AppDisplayPlane(AppGpu &gpu, uint32_t index, const VkDisplayPlanePropertiesKHR &in_prop); +}; + +struct AppDisplayMode { + VkDisplayModePropertiesKHR properties; + + // key is a AppDisplayPlane::global_index value + std::map<uint32_t, VkDisplayPlaneCapabilitiesKHR> capabilities; + + AppDisplayMode(AppGpu &gpu, const VkDisplayModePropertiesKHR &in_prop, const std::set<uint32_t> &supported_planes); +}; + +struct AppDisplay { + uint32_t global_index; + + std::string name; + + VkDisplayPropertiesKHR properties; + std::vector<AppDisplayMode> modes; + + AppDisplay(AppGpu &gpu, uint32_t index, const VkDisplayPropertiesKHR &in_properties, + const std::vector<AppDisplayPlane> &all_planes); +}; + class APIVersion { public: APIVersion() : api_version_(VK_API_VERSION_1_0) {} @@ -403,7 +484,7 @@ struct _screen_window *window; #endif AppInstance() { - VkResult dllErr = volkInitialize(); + VkResult dllErr = load_vulkan_library(); if (dllErr != VK_SUCCESS) { THROW_ERR("Failed to initialize: " API_NAME " loader is not installed, not found, or failed to load."); @@ -458,7 +539,7 @@ THROW_VK_ERR("vkCreateInstance", err); } - volkLoadInstance(instance); + load_vulkan_instance_functions(instance); err = vkCreateDebugReportCallbackEXT(instance, &dbg_info, nullptr, &debug_callback); if (err != VK_SUCCESS) { @@ -469,7 +550,7 @@ ~AppInstance() { if (debug_callback) vkDestroyDebugReportCallbackEXT(instance, debug_callback, nullptr); if (vkDestroyInstance) vkDestroyInstance(instance, nullptr); - volkFinalize(); + unload_vulkan_library(); } AppInstance(const AppInstance &) = delete; @@ -582,6 +663,11 @@ inst_extensions.push_back(ext.extensionName); } #endif +#ifdef VK_USE_PLATFORM_DISPLAY + if (strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, ext.extensionName) == 0) { + inst_extensions.push_back(ext.extensionName); + } +#endif if (strcmp(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); } @@ -594,6 +680,9 @@ if (strcmp(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); } + if (strcmp(VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME, ext.extensionName) == 0) { + inst_extensions.push_back(ext.extensionName); + } } } @@ -618,7 +707,8 @@ #if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_WIN32_KHR) || \ defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_METAL_EXT) || defined(VK_USE_PLATFORM_WAYLAND_KHR) || \ - defined(VK_USE_PLATFORM_DIRECTFB_EXT) || defined(VK_USE_PLATFORM_GGP) || defined(VK_USE_PLATFORM_SCREEN_QNX) + defined(VK_USE_PLATFORM_DIRECTFB_EXT) || defined(VK_USE_PLATFORM_GGP) || defined(VK_USE_PLATFORM_SCREEN_QNX) || \ + defined(VK_USE_PLATFORM_DISPLAY) #define VULKANINFO_WSI_ENABLED #endif @@ -1173,6 +1263,7 @@ inst.AddSurfaceExtension(surface_ext_qnx_screen); } #endif +// TODO: add support for VK_KHR_display surfaces } // ---------- Surfaces -------------- // @@ -1420,6 +1511,11 @@ std::unique_ptr<phys_device_features2_chain> chain_for_phys_device_features2; std::vector<std::unique_ptr<queue_properties2_chain>> chain_for_queue_props2; + std::vector<std::unique_ptr<AppVideoProfile>> video_profiles; + + std::vector<AppDisplay> displays; + std::vector<AppDisplayPlane> display_planes; + AppGpu(AppInstance &inst, uint32_t id, VkPhysicalDevice phys_device, bool show_promoted_structs); ~AppGpu(); @@ -1442,7 +1538,7 @@ // True if this extension is present if (format_range.extension_name != nullptr) { - return inst.CheckExtensionEnabled(format_range.extension_name); + return CheckPhysicalDeviceExtensionIncluded(format_range.extension_name); } // True if standard and supported by both this instance and this GPU @@ -1482,6 +1578,14 @@ return APIVersion(v).str(); } } + const AppDisplay *FindDisplay(VkDisplayKHR handle) { + for (const auto &disp : displays) { + if (disp.properties.display == handle) { + return &disp; + } + } + return NULL; + } }; std::vector<VkPhysicalDeviceToolPropertiesEXT> GetToolingInfo(AppGpu &gpu) { @@ -1490,6 +1594,43 @@ vkGetPhysicalDeviceToolPropertiesEXT, gpu.phys_device); } +std::vector<VkCooperativeMatrixPropertiesKHR> GetCooperativeMatrixInfo(AppGpu &gpu) { + if (vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR == nullptr || + !gpu.CheckPhysicalDeviceExtensionIncluded("VK_KHR_cooperative_matrix")) + return {}; + return GetVector<VkCooperativeMatrixPropertiesKHR>("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", + vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, gpu.phys_device); +} +std::vector<VkTimeDomainKHR> GetTimeDomainInfo(AppGpu &gpu) { + if (vkGetPhysicalDeviceCalibrateableTimeDomainsKHR == nullptr || + !gpu.CheckPhysicalDeviceExtensionIncluded("VK_KHR_calibrated_timestamps")) + return {}; + return GetVector<VkTimeDomainKHR>("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, gpu.phys_device); +} +std::vector<VkPhysicalDeviceFragmentShadingRateKHR> GetFragmentShadingRateInfo(AppGpu &gpu) { + if (vkGetPhysicalDeviceFragmentShadingRatesKHR == nullptr || + !gpu.CheckPhysicalDeviceExtensionIncluded("VK_KHR_fragment_shading_rate")) + return {}; + return GetVector<VkPhysicalDeviceFragmentShadingRateKHR>("vkGetPhysicalDeviceFragmentShadingRatesKHR", + vkGetPhysicalDeviceFragmentShadingRatesKHR, gpu.phys_device); +} +// Returns vector where each index maps to VkSampleCountFlagBits +std::vector<VkMultisamplePropertiesEXT> GetSampleLocationInfo(AppGpu &gpu) { + if (vkGetPhysicalDeviceMultisamplePropertiesEXT == nullptr || + !gpu.CheckPhysicalDeviceExtensionIncluded("VK_EXT_sample_locations")) + return {}; + std::vector<VkMultisamplePropertiesEXT> result; + // 7 covers VK_SAMPLE_COUNT_1_BIT to 64_BIT + for (uint32_t i = 0; i < 7; i++) { + const VkSampleCountFlagBits sample_count = (VkSampleCountFlagBits)(1 << i); + VkMultisamplePropertiesEXT props = {VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, nullptr}; + vkGetPhysicalDeviceMultisamplePropertiesEXT(gpu.phys_device, sample_count, &props); + result.emplace_back(props); + } + return result; +} + // --------- Format Properties ----------// // can't use autogen because that is put in a header that we can't include because that header depends on stuff defined here bool operator==(const VkFormatProperties &a, const VkFormatProperties b) {
diff --git a/vulkaninfo/vulkaninfo.md b/vulkaninfo/vulkaninfo.md index 8755b41..17b4a8b 100644 --- a/vulkaninfo/vulkaninfo.md +++ b/vulkaninfo/vulkaninfo.md
@@ -56,8 +56,8 @@ vulkaninfo -j | -j=<gpu-number> | --json | --json=<gpu-number> vulkaninfo --text vulkaninfo --html + vulkaninfo --show-all vulkaninfo --show-formats - vulkaninfo --show-tool-props OPTIONS: [-h, --help] Print this help. @@ -75,13 +75,22 @@ \"VP_VULKANINFO_[DEVICE_NAME]_[DRIVER_VERSION].json\" of the first gpu in the system. [-j=<gpu-number>, --json=<gpu-number>] - For a multi-gpu system, a single gpu can be targetted by + For a multi-gpu system, a single gpu can be targeted by specifying the gpu-number associated with the gpu of interest. This number can be determined by running vulkaninfo without any options specified. -[--show-tool-props] Show the active VkPhysicalDeviceToolPropertiesEXT that vulkaninfo finds. +[--show-all] Show everything (includes all the below options) [--show-formats] Display the format properties of each physical device. Note: This only affects text output. +[--show-tool-props] Show the active VkPhysicalDeviceToolPropertiesEXT that vulkaninfo finds. +[--show-promoted-structs] + Include structs promoted to core in pNext Chains. +[--show-video-props] + Display the video profile info, video capabilities and + video format properties of each video profile supported + by each physical device. + Note: This only affects text output which by default + only contains the list of supported video profile names. ``` ### Windows
diff --git a/vulkaninfo/vulkaninfo_functions.h b/vulkaninfo/vulkaninfo_functions.h new file mode 100644 index 0000000..2876155 --- /dev/null +++ b/vulkaninfo/vulkaninfo_functions.h
@@ -0,0 +1,268 @@ +/* + * Copyright (c) 2025-2026 The Khronos Group Inc. + * Copyright (c) 2025-2026 Valve Corporation + * Copyright (c) 2025-2026 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: Charles Giessen <charles@lunarg.com> + * + */ +#pragma once + +// Need to include relevant system headers to open the dynamic library +#if defined(WIN32) +#include <windows.h> +#elif defined(__APPLE__) +#include <stdlib.h> +#include <dlfcn.h> +#else +#include <dlfcn.h> +#endif + +// We are providing storage for all functions, make sure the vulkan headers doesn't conflate with ours. +#if !defined(VK_NO_PROTOTYPES) +#define VK_NO_PROTOTYPES +#endif + +#include <vulkan/vulkan.h> + +void* vulkan_library; + +// Global Functions +PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; +PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; +PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; +PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion; +PFN_vkCreateInstance vkCreateInstance; + +// Per-platform Instance functions +#if defined(VK_USE_PLATFORM_WIN32_KHR) +PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) +PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_XLIB_KHR) +PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_XCB_KHR) +PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_METAL_EXT) +PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; +#endif +#if defined(VK_USE_PLATFORM_MACOS_MVK) +PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; +#endif +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX; +#endif +#if defined(VK_USE_PLATFORM_DISPLAY) +PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR; +#endif +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) +PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; +#endif +#if defined(VK_USE_PLATFORM_GGP) +PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; +#endif +// Instance functions +PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT; +PFN_vkCreateDevice vkCreateDevice; +PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT; +PFN_vkDestroyInstance vkDestroyInstance; +PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR; +PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; +PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR; +PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR; +PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR; +PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR; +PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR; +PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; +PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; +PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; +PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; +PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; +PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR; +PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR; +PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR; +PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR; +PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; +PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR; +PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR; +PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; +PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR; +PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR; +PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties; +PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR; +PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR; +PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR; +PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR; +PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; +PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT; +PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT; +PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR; +PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; +PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; +PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR; +PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT; + +// Device functions +PFN_vkCreateImage vkCreateImage; +PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; +PFN_vkDestroyImage vkDestroyImage; +PFN_vkDestroyDevice vkDestroyDevice; + +#define LOAD_INSTANCE_FUNCTION(instance, function) function = (PFN_##function)vkGetInstanceProcAddr(instance, #function) + +static VkResult load_vulkan_library() { + vulkan_library = NULL; +#if defined(WIN32) + HMODULE library = LoadLibraryA("vulkan-1.dll"); + if (library == NULL) return VK_ERROR_INITIALIZATION_FAILED; + + vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)(void (*)(void))GetProcAddress(library, "vkGetInstanceProcAddr"); +#elif defined(__APPLE__) + void* library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) { + library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); + } + if (library == NULL && getenv("DYLD_FALLBACK_LIBRARY_PATH") == NULL) { + library = dlopen("/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) { + library = dlopen("/usr/local/lib/libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); + } + } + if (library == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr"); +#else // Assume everything else supports dlopen + void* library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL); + if (library == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr"); +#endif + if (vkGetInstanceProcAddr == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + vulkan_library = library; + LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceExtensionProperties); + LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceLayerProperties); + LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceVersion); + LOAD_INSTANCE_FUNCTION(NULL, vkCreateInstance); + + return VK_SUCCESS; +} + +static void unload_vulkan_library() { + if (vulkan_library != NULL) { +#if defined(WIN32) + FreeLibrary((HMODULE)vulkan_library); +#else + dlclose(vulkan_library); +#endif + vulkan_library = NULL; + } +} + +static void load_vulkan_instance_functions(VkInstance instance) { +#if defined(VK_USE_PLATFORM_WIN32_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateWin32SurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateWaylandSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateAndroidSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_XLIB_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateXlibSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_XCB_KHR) + LOAD_INSTANCE_FUNCTION(instance, vkCreateXcbSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_METAL_EXT) + LOAD_INSTANCE_FUNCTION(instance, vkCreateMetalSurfaceEXT); +#endif +#if defined(VK_USE_PLATFORM_MACOS_MVK) + LOAD_INSTANCE_FUNCTION(instance, vkCreateMacOSSurfaceMVK); +#endif +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + LOAD_INSTANCE_FUNCTION(instance, vkCreateScreenSurfaceQNX); +#endif +#if defined(VK_USE_PLATFORM_DISPLAY) + LOAD_INSTANCE_FUNCTION(instance, vkCreateDisplayPlaneSurfaceKHR); +#endif +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + LOAD_INSTANCE_FUNCTION(instance, vkCreateDirectFBSurfaceEXT); +#endif +#if defined(VK_USE_PLATFORM_GGP) + LOAD_INSTANCE_FUNCTION(instance, vkCreateStreamDescriptorSurfaceGGP); +#endif + + LOAD_INSTANCE_FUNCTION(instance, vkCreateDebugReportCallbackEXT); + LOAD_INSTANCE_FUNCTION(instance, vkCreateDevice); + LOAD_INSTANCE_FUNCTION(instance, vkDestroyDebugReportCallbackEXT); + LOAD_INSTANCE_FUNCTION(instance, vkDestroyInstance); + LOAD_INSTANCE_FUNCTION(instance, vkDestroySurfaceKHR); + LOAD_INSTANCE_FUNCTION(instance, vkEnumerateDeviceExtensionProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayModePropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneCapabilitiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneSupportedDisplaysKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormatsKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfacePresentModesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceSupportKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceVideoCapabilitiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormats2KHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilities2KHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceVideoFormatPropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDeviceGroupsKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetDeviceGroupPresentCapabilitiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceImageFormatProperties); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties2KHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties2KHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures2KHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties2KHR); + LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDevices); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilities2EXT); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceToolPropertiesEXT); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties2KHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceCalibrateableTimeDomainsKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFragmentShadingRatesKHR); + LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMultisamplePropertiesEXT); + + // Load device functions using vkGetInstanceProcAddr, vulkaninfo doesn't care about the extra indirection it causes + LOAD_INSTANCE_FUNCTION(instance, vkCreateImage); + LOAD_INSTANCE_FUNCTION(instance, vkGetImageMemoryRequirements); + LOAD_INSTANCE_FUNCTION(instance, vkDestroyImage); + LOAD_INSTANCE_FUNCTION(instance, vkDestroyDevice); +} + +#undef LOAD_INSTANCE_FUNCTION